First commit

hGameTest/bin/linux/obj/include/openfl/Lib.h

@@ -0,0 +1,132 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_Lib
+#define INCLUDED_openfl_Lib
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+HX_DECLARE_CLASS1(openfl,Lib)
+HX_DECLARE_CLASS2(openfl,display,Application)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,MovieClip)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,net,URLRequest)
+
+namespace openfl{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lib_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Lib_obj OBJ_;
+		Lib_obj();
+
+	public:
+		enum { _hx_ClassId = 0x19d6bed5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.Lib")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.Lib"); }
+
+		inline static hx::ObjectPtr< Lib_obj > __new() {
+			hx::ObjectPtr< Lib_obj > __this = new Lib_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Lib_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Lib_obj *__this = (Lib_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Lib_obj), false, "openfl.Lib"));
+			*(void **)__this = Lib_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Lib_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lib",25,07,3a,00); }
+
+		static void __boot();
+		static int _hx___lastTimerID;
+		static  ::haxe::ds::StringMap _hx___sentWarnings;
+		static  ::haxe::ds::IntMap _hx___timers;
+		static  ::Dynamic as( ::Dynamic v,hx::Class c);
+		static ::Dynamic as_dyn();
+
+		static  ::openfl::display::MovieClip attach(::String name);
+		static ::Dynamic attach_dyn();
+
+		static void clearInterval(int id);
+		static ::Dynamic clearInterval_dyn();
+
+		static void clearTimeout(int id);
+		static ::Dynamic clearTimeout_dyn();
+
+		static hx::Class getDefinitionByName(::String name);
+		static ::Dynamic getDefinitionByName_dyn();
+
+		static ::String getQualifiedClassName( ::Dynamic value);
+		static ::Dynamic getQualifiedClassName_dyn();
+
+		static ::String getQualifiedSuperclassName( ::Dynamic value);
+		static ::Dynamic getQualifiedSuperclassName_dyn();
+
+		static int getTimer();
+		static ::Dynamic getTimer_dyn();
+
+		static void getURL( ::openfl::net::URLRequest request,::String target);
+		static ::Dynamic getURL_dyn();
+
+		static void navigateToURL( ::openfl::net::URLRequest request,::String window);
+		static ::Dynamic navigateToURL_dyn();
+
+		static void notImplemented( ::Dynamic posInfo);
+		static ::Dynamic notImplemented_dyn();
+
+		static void preventDefaultTouchMove();
+		static ::Dynamic preventDefaultTouchMove_dyn();
+
+		static void sendToURL( ::openfl::net::URLRequest request);
+		static ::Dynamic sendToURL_dyn();
+
+		static int setInterval( ::Dynamic closure,int delay,::cpp::VirtualArray args);
+		static ::Dynamic setInterval_dyn();
+
+		static int setTimeout( ::Dynamic closure,int delay,::cpp::VirtualArray args);
+		static ::Dynamic setTimeout_dyn();
+
+		static void trace( ::Dynamic arg);
+		static ::Dynamic trace_dyn();
+
+		static  ::openfl::display::Application get_application();
+		static ::Dynamic get_application_dyn();
+
+		static  ::openfl::display::MovieClip get_current();
+		static ::Dynamic get_current_dyn();
+
+};
+
+} // end namespace openfl
+
+#endif /* INCLUDED_openfl_Lib */ 

hGameTest/bin/linux/obj/include/openfl/_Vector/BoolVector.h

@@ -0,0 +1,145 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__Vector_BoolVector
+#define INCLUDED_openfl__Vector_BoolVector
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl__Vector_IVector
+#include <openfl/_Vector/IVector.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,BoolVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+
+namespace openfl{
+namespace _Vector{
+
+
+class HXCPP_CLASS_ATTRIBUTES BoolVector_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BoolVector_obj OBJ_;
+		BoolVector_obj();
+
+	public:
+		enum { _hx_ClassId = 0x63ff549f };
+
+		void __construct(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::Array< bool > array);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl._Vector.BoolVector")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl._Vector.BoolVector"); }
+		static hx::ObjectPtr< BoolVector_obj > __new(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::Array< bool > array);
+		static hx::ObjectPtr< BoolVector_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::Array< bool > array);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BoolVector_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		void unshift_489e4d05( ::Dynamic value);
+
+		 ::Dynamic set_15539e57(int index, ::Dynamic value);
+
+		 ::Dynamic removeAt_c4bfee54(int index);
+
+		int push_9c73657a( ::Dynamic value);
+
+		int lastIndexOf_02dfccf1( ::Dynamic x, ::Dynamic from);
+
+		void insertAt_5d1f93e2(int index, ::Dynamic element);
+
+		int indexOf_44372b40( ::Dynamic x,hx::Null< int >  from);
+
+		 ::Dynamic get_c4bfee54(int index);
+		::String __ToString() const { return HX_("BoolVector",ad,28,bf,2d); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool fixed;
+		::Array< bool > _hx___array;
+		::Dynamic concat(::Dynamic a);
+		::Dynamic concat_dyn();
+
+		::Dynamic copy();
+		::Dynamic copy_dyn();
+
+		::Dynamic filter( ::Dynamic callback);
+		::Dynamic filter_dyn();
+
+		bool get(int index);
+		::Dynamic get_dyn();
+
+		int indexOf(bool x,hx::Null< int >  from);
+		::Dynamic indexOf_dyn();
+
+		void insertAt(int index,bool element);
+		::Dynamic insertAt_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+		::String join(::String sep);
+		::Dynamic join_dyn();
+
+		int lastIndexOf(bool x, ::Dynamic from);
+		::Dynamic lastIndexOf_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+		int push(bool x);
+		::Dynamic push_dyn();
+
+		bool removeAt(int index);
+		::Dynamic removeAt_dyn();
+
+		::Dynamic reverse();
+		::Dynamic reverse_dyn();
+
+		bool set(int index,bool value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic shift();
+		::Dynamic shift_dyn();
+
+		::Dynamic slice(hx::Null< int >  startIndex, ::Dynamic endIndex);
+		::Dynamic slice_dyn();
+
+		void sort( ::Dynamic f);
+		::Dynamic sort_dyn();
+
+		::Dynamic splice(int pos,int len);
+		::Dynamic splice_dyn();
+
+		 ::Dynamic toJSON();
+		::Dynamic toJSON_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		void unshift(bool x);
+		::Dynamic unshift_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		int set_length(int value);
+		::Dynamic set_length_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _Vector
+
+#endif /* INCLUDED_openfl__Vector_BoolVector */ 

hGameTest/bin/linux/obj/include/openfl/_Vector/FloatVector.h

@@ -0,0 +1,145 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__Vector_FloatVector
+#define INCLUDED_openfl__Vector_FloatVector
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl__Vector_IVector
+#include <openfl/_Vector/IVector.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+
+namespace openfl{
+namespace _Vector{
+
+
+class HXCPP_CLASS_ATTRIBUTES FloatVector_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef FloatVector_obj OBJ_;
+		FloatVector_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6497e72d };
+
+		void __construct(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array,hx::Null< bool >  __o_forceCopy);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl._Vector.FloatVector")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl._Vector.FloatVector"); }
+		static hx::ObjectPtr< FloatVector_obj > __new(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array,hx::Null< bool >  __o_forceCopy);
+		static hx::ObjectPtr< FloatVector_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array,hx::Null< bool >  __o_forceCopy);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FloatVector_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		void unshift_489e4d05( ::Dynamic value);
+
+		 ::Dynamic set_15539e57(int index, ::Dynamic value);
+
+		 ::Dynamic removeAt_c4bfee54(int index);
+
+		int push_9c73657a( ::Dynamic value);
+
+		int lastIndexOf_02dfccf1( ::Dynamic x, ::Dynamic from);
+
+		void insertAt_5d1f93e2(int index, ::Dynamic element);
+
+		int indexOf_44372b40( ::Dynamic x,hx::Null< int >  from);
+
+		 ::Dynamic get_c4bfee54(int index);
+		::String __ToString() const { return HX_("FloatVector",5f,9f,b1,22); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool fixed;
+		::Array< Float > _hx___array;
+		::Dynamic concat(::Dynamic a);
+		::Dynamic concat_dyn();
+
+		::Dynamic copy();
+		::Dynamic copy_dyn();
+
+		::Dynamic filter( ::Dynamic callback);
+		::Dynamic filter_dyn();
+
+		Float get(int index);
+		::Dynamic get_dyn();
+
+		int indexOf(Float x,hx::Null< int >  from);
+		::Dynamic indexOf_dyn();
+
+		void insertAt(int index,Float element);
+		::Dynamic insertAt_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+		::String join(::String sep);
+		::Dynamic join_dyn();
+
+		int lastIndexOf(Float x, ::Dynamic from);
+		::Dynamic lastIndexOf_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+		int push(Float x);
+		::Dynamic push_dyn();
+
+		Float removeAt(int index);
+		::Dynamic removeAt_dyn();
+
+		::Dynamic reverse();
+		::Dynamic reverse_dyn();
+
+		Float set(int index,Float value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic shift();
+		::Dynamic shift_dyn();
+
+		::Dynamic slice(hx::Null< int >  startIndex, ::Dynamic endIndex);
+		::Dynamic slice_dyn();
+
+		void sort( ::Dynamic f);
+		::Dynamic sort_dyn();
+
+		::Dynamic splice(int pos,int len);
+		::Dynamic splice_dyn();
+
+		 ::Dynamic toJSON();
+		::Dynamic toJSON_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		void unshift(Float x);
+		::Dynamic unshift_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		int set_length(int value);
+		::Dynamic set_length_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _Vector
+
+#endif /* INCLUDED_openfl__Vector_FloatVector */ 

hGameTest/bin/linux/obj/include/openfl/_Vector/FunctionVector.h

@@ -0,0 +1,130 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__Vector_FunctionVector
+#define INCLUDED_openfl__Vector_FunctionVector
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl__Vector_IVector
+#include <openfl/_Vector/IVector.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,FunctionVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+
+namespace openfl{
+namespace _Vector{
+
+
+class HXCPP_CLASS_ATTRIBUTES FunctionVector_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef FunctionVector_obj OBJ_;
+		FunctionVector_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3899d30d };
+
+		void __construct(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl._Vector.FunctionVector")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl._Vector.FunctionVector"); }
+		static hx::ObjectPtr< FunctionVector_obj > __new(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array);
+		static hx::ObjectPtr< FunctionVector_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FunctionVector_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("FunctionVector",1b,c6,6f,50); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool fixed;
+		::cpp::VirtualArray _hx___array;
+		::Dynamic concat(::Dynamic a);
+		::Dynamic concat_dyn();
+
+		::Dynamic copy();
+		::Dynamic copy_dyn();
+
+		::Dynamic filter( ::Dynamic callback);
+		::Dynamic filter_dyn();
+
+		 ::Dynamic get(int index);
+		::Dynamic get_dyn();
+
+		int indexOf( ::Dynamic x,hx::Null< int >  from);
+		::Dynamic indexOf_dyn();
+
+		void insertAt(int index, ::Dynamic element);
+		::Dynamic insertAt_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+		::String join(::String sep);
+		::Dynamic join_dyn();
+
+		int lastIndexOf( ::Dynamic x, ::Dynamic from);
+		::Dynamic lastIndexOf_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+		int push( ::Dynamic x);
+		::Dynamic push_dyn();
+
+		 ::Dynamic removeAt(int index);
+		::Dynamic removeAt_dyn();
+
+		::Dynamic reverse();
+		::Dynamic reverse_dyn();
+
+		 ::Dynamic set(int index, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic shift();
+		::Dynamic shift_dyn();
+
+		::Dynamic slice(hx::Null< int >  startIndex, ::Dynamic endIndex);
+		::Dynamic slice_dyn();
+
+		void sort( ::Dynamic f);
+		::Dynamic sort_dyn();
+
+		::Dynamic splice(int pos,int len);
+		::Dynamic splice_dyn();
+
+		 ::Dynamic toJSON();
+		::Dynamic toJSON_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		void unshift( ::Dynamic x);
+		::Dynamic unshift_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		int set_length(int value);
+		::Dynamic set_length_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _Vector
+
+#endif /* INCLUDED_openfl__Vector_FunctionVector */ 

hGameTest/bin/linux/obj/include/openfl/_Vector/IVector.h

@@ -0,0 +1,114 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__Vector_IVector
+#define INCLUDED_openfl__Vector_IVector
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+
+namespace openfl{
+namespace _Vector{
+
+
+class HXCPP_CLASS_ATTRIBUTES IVector_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		static void __boot();
+		int (hx::Object :: *_hx_get_length)(); 
+		static inline int get_length( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_get_length)();
+		}
+		int (hx::Object :: *_hx_set_length)(int value); 
+		static inline int set_length( ::Dynamic _hx_,int value) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_set_length)(value);
+		}
+		::Dynamic (hx::Object :: *_hx_concat)(::Dynamic vec); 
+		static inline ::Dynamic concat( ::Dynamic _hx_,::Dynamic vec) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_concat)(vec);
+		}
+		::Dynamic (hx::Object :: *_hx_copy)(); 
+		static inline ::Dynamic copy( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_copy)();
+		}
+		::Dynamic (hx::Object :: *_hx_filter)( ::Dynamic callback); 
+		static inline ::Dynamic filter( ::Dynamic _hx_, ::Dynamic callback) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_filter)(callback);
+		}
+		 ::Dynamic (hx::Object :: *_hx_get)(int index); 
+		static inline  ::Dynamic get( ::Dynamic _hx_,int index) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_get)(index);
+		}
+		int (hx::Object :: *_hx_indexOf)( ::Dynamic x,hx::Null< int >  from); 
+		static inline int indexOf( ::Dynamic _hx_, ::Dynamic x,hx::Null< int >  from) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_indexOf)(x,from);
+		}
+		void (hx::Object :: *_hx_insertAt)(int index, ::Dynamic element); 
+		static inline void insertAt( ::Dynamic _hx_,int index, ::Dynamic element) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_insertAt)(index,element);
+		}
+		 ::Dynamic (hx::Object :: *_hx_iterator)(); 
+		static inline  ::Dynamic iterator( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_iterator)();
+		}
+		::String (hx::Object :: *_hx_join)(::String sep); 
+		static inline ::String join( ::Dynamic _hx_,::String sep) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_join)(sep);
+		}
+		int (hx::Object :: *_hx_lastIndexOf)( ::Dynamic x, ::Dynamic from); 
+		static inline int lastIndexOf( ::Dynamic _hx_, ::Dynamic x, ::Dynamic from) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_lastIndexOf)(x,from);
+		}
+		 ::Dynamic (hx::Object :: *_hx_pop)(); 
+		static inline  ::Dynamic pop( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_pop)();
+		}
+		int (hx::Object :: *_hx_push)( ::Dynamic value); 
+		static inline int push( ::Dynamic _hx_, ::Dynamic value) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_push)(value);
+		}
+		 ::Dynamic (hx::Object :: *_hx_removeAt)(int index); 
+		static inline  ::Dynamic removeAt( ::Dynamic _hx_,int index) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_removeAt)(index);
+		}
+		::Dynamic (hx::Object :: *_hx_reverse)(); 
+		static inline ::Dynamic reverse( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_reverse)();
+		}
+		 ::Dynamic (hx::Object :: *_hx_set)(int index, ::Dynamic value); 
+		static inline  ::Dynamic set( ::Dynamic _hx_,int index, ::Dynamic value) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_set)(index,value);
+		}
+		 ::Dynamic (hx::Object :: *_hx_shift)(); 
+		static inline  ::Dynamic shift( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_shift)();
+		}
+		::Dynamic (hx::Object :: *_hx_slice)(hx::Null< int >  startIndex, ::Dynamic endIndex); 
+		static inline ::Dynamic slice( ::Dynamic _hx_,hx::Null< int >  startIndex, ::Dynamic endIndex) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_slice)(startIndex,endIndex);
+		}
+		void (hx::Object :: *_hx_sort)( ::Dynamic f); 
+		static inline void sort( ::Dynamic _hx_, ::Dynamic f) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_sort)(f);
+		}
+		::Dynamic (hx::Object :: *_hx_splice)(int pos,int len); 
+		static inline ::Dynamic splice( ::Dynamic _hx_,int pos,int len) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_splice)(pos,len);
+		}
+		::String (hx::Object :: *_hx_toString)(); 
+		static inline ::String toString( ::Dynamic _hx_) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_toString)();
+		}
+		void (hx::Object :: *_hx_unshift)( ::Dynamic value); 
+		static inline void unshift( ::Dynamic _hx_, ::Dynamic value) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::_Vector::IVector_obj *>(_hx_.mPtr->_hx_getInterface(0x45e7caba)))->_hx_unshift)(value);
+		}
+};
+
+} // end namespace openfl
+} // end namespace _Vector
+
+#endif /* INCLUDED_openfl__Vector_IVector */ 

hGameTest/bin/linux/obj/include/openfl/_Vector/IntVector.h

@@ -0,0 +1,145 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__Vector_IntVector
+#define INCLUDED_openfl__Vector_IntVector
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl__Vector_IVector
+#include <openfl/_Vector/IVector.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+
+namespace openfl{
+namespace _Vector{
+
+
+class HXCPP_CLASS_ATTRIBUTES IntVector_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef IntVector_obj OBJ_;
+		IntVector_obj();
+
+	public:
+		enum { _hx_ClassId = 0x56650740 };
+
+		void __construct(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::Array< int > array);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl._Vector.IntVector")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl._Vector.IntVector"); }
+		static hx::ObjectPtr< IntVector_obj > __new(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::Array< int > array);
+		static hx::ObjectPtr< IntVector_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::Array< int > array);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~IntVector_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		void unshift_489e4d05( ::Dynamic value);
+
+		 ::Dynamic set_15539e57(int index, ::Dynamic value);
+
+		 ::Dynamic removeAt_c4bfee54(int index);
+
+		int push_9c73657a( ::Dynamic value);
+
+		int lastIndexOf_02dfccf1( ::Dynamic x, ::Dynamic from);
+
+		void insertAt_5d1f93e2(int index, ::Dynamic element);
+
+		int indexOf_44372b40( ::Dynamic x,hx::Null< int >  from);
+
+		 ::Dynamic get_c4bfee54(int index);
+		::String __ToString() const { return HX_("IntVector",f2,ee,2f,5e); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool fixed;
+		::Array< int > _hx___array;
+		::Dynamic concat(::Dynamic a);
+		::Dynamic concat_dyn();
+
+		::Dynamic copy();
+		::Dynamic copy_dyn();
+
+		::Dynamic filter( ::Dynamic callback);
+		::Dynamic filter_dyn();
+
+		int get(int index);
+		::Dynamic get_dyn();
+
+		int indexOf(int x,hx::Null< int >  from);
+		::Dynamic indexOf_dyn();
+
+		void insertAt(int index,int element);
+		::Dynamic insertAt_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+		::String join(::String sep);
+		::Dynamic join_dyn();
+
+		int lastIndexOf(int x, ::Dynamic from);
+		::Dynamic lastIndexOf_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+		int push(int x);
+		::Dynamic push_dyn();
+
+		int removeAt(int index);
+		::Dynamic removeAt_dyn();
+
+		::Dynamic reverse();
+		::Dynamic reverse_dyn();
+
+		int set(int index,int value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic shift();
+		::Dynamic shift_dyn();
+
+		::Dynamic slice(hx::Null< int >  startIndex, ::Dynamic endIndex);
+		::Dynamic slice_dyn();
+
+		void sort( ::Dynamic f);
+		::Dynamic sort_dyn();
+
+		::Dynamic splice(int pos,int len);
+		::Dynamic splice_dyn();
+
+		 ::Dynamic toJSON();
+		::Dynamic toJSON_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		void unshift(int x);
+		::Dynamic unshift_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		int set_length(int value);
+		::Dynamic set_length_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _Vector
+
+#endif /* INCLUDED_openfl__Vector_IntVector */ 

hGameTest/bin/linux/obj/include/openfl/_Vector/ObjectVector.h

@@ -0,0 +1,130 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__Vector_ObjectVector
+#define INCLUDED_openfl__Vector_ObjectVector
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl__Vector_IVector
+#include <openfl/_Vector/IVector.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,ObjectVector)
+
+namespace openfl{
+namespace _Vector{
+
+
+class HXCPP_CLASS_ATTRIBUTES ObjectVector_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ObjectVector_obj OBJ_;
+		ObjectVector_obj();
+
+	public:
+		enum { _hx_ClassId = 0x020730c8 };
+
+		void __construct(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array,hx::Null< bool >  __o_forceCopy);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl._Vector.ObjectVector")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl._Vector.ObjectVector"); }
+		static hx::ObjectPtr< ObjectVector_obj > __new(hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array,hx::Null< bool >  __o_forceCopy);
+		static hx::ObjectPtr< ObjectVector_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_length,hx::Null< bool >  __o_fixed,::cpp::VirtualArray array,hx::Null< bool >  __o_forceCopy);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ObjectVector_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("ObjectVector",02,09,7a,39); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool fixed;
+		::cpp::VirtualArray _hx___array;
+		::Dynamic concat(::Dynamic a);
+		::Dynamic concat_dyn();
+
+		::Dynamic copy();
+		::Dynamic copy_dyn();
+
+		::Dynamic filter( ::Dynamic callback);
+		::Dynamic filter_dyn();
+
+		 ::Dynamic get(int index);
+		::Dynamic get_dyn();
+
+		int indexOf( ::Dynamic x,hx::Null< int >  from);
+		::Dynamic indexOf_dyn();
+
+		void insertAt(int index, ::Dynamic element);
+		::Dynamic insertAt_dyn();
+
+		 ::Dynamic iterator();
+		::Dynamic iterator_dyn();
+
+		::String join(::String sep);
+		::Dynamic join_dyn();
+
+		int lastIndexOf( ::Dynamic x, ::Dynamic from);
+		::Dynamic lastIndexOf_dyn();
+
+		 ::Dynamic pop();
+		::Dynamic pop_dyn();
+
+		int push( ::Dynamic x);
+		::Dynamic push_dyn();
+
+		 ::Dynamic removeAt(int index);
+		::Dynamic removeAt_dyn();
+
+		::Dynamic reverse();
+		::Dynamic reverse_dyn();
+
+		 ::Dynamic set(int index, ::Dynamic value);
+		::Dynamic set_dyn();
+
+		 ::Dynamic shift();
+		::Dynamic shift_dyn();
+
+		::Dynamic slice(hx::Null< int >  startIndex, ::Dynamic endIndex);
+		::Dynamic slice_dyn();
+
+		void sort( ::Dynamic f);
+		::Dynamic sort_dyn();
+
+		::Dynamic splice(int pos,int len);
+		::Dynamic splice_dyn();
+
+		 ::Dynamic toJSON();
+		::Dynamic toJSON_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		void unshift( ::Dynamic x);
+		::Dynamic unshift_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		int set_length(int value);
+		::Dynamic set_length_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _Vector
+
+#endif /* INCLUDED_openfl__Vector_ObjectVector */ 

hGameTest/bin/linux/obj/include/openfl/_Vector/Vector_Impl_.h

@@ -0,0 +1,175 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__Vector_Vector_Impl_
+#define INCLUDED_openfl__Vector_Vector_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,_Vector,BoolVector)
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,FunctionVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+HX_DECLARE_CLASS2(openfl,_Vector,ObjectVector)
+HX_DECLARE_CLASS2(openfl,_Vector,Vector_Impl_)
+
+namespace openfl{
+namespace _Vector{
+
+
+class HXCPP_CLASS_ATTRIBUTES Vector_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Vector_Impl__obj OBJ_;
+		Vector_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x0620c351 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl._Vector.Vector_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl._Vector.Vector_Impl_"); }
+
+		inline static hx::ObjectPtr< Vector_Impl__obj > __new() {
+			hx::ObjectPtr< Vector_Impl__obj > __this = new Vector_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Vector_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			Vector_Impl__obj *__this = (Vector_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Vector_Impl__obj), false, "openfl._Vector.Vector_Impl_"));
+			*(void **)__this = Vector_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Vector_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Vector_Impl_",c3,ad,36,7e); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::openfl::_Vector::ObjectVector concat(::Dynamic this1, ::openfl::_Vector::ObjectVector vec);
+		static ::Dynamic concat_dyn();
+
+		static  ::openfl::_Vector::ObjectVector copy(::Dynamic this1);
+		static ::Dynamic copy_dyn();
+
+		static  ::openfl::_Vector::ObjectVector filter(::Dynamic this1, ::Dynamic callback);
+		static ::Dynamic filter_dyn();
+
+		static  ::Dynamic get(::Dynamic this1,int index);
+		static ::Dynamic get_dyn();
+
+		static int indexOf(::Dynamic this1, ::Dynamic searchElement,hx::Null< int >  fromIndex);
+		static ::Dynamic indexOf_dyn();
+
+		static void insertAt(::Dynamic this1,int index, ::Dynamic element);
+		static ::Dynamic insertAt_dyn();
+
+		static  ::Dynamic iterator(::Dynamic this1);
+		static ::Dynamic iterator_dyn();
+
+		static ::String join(::Dynamic this1,::String sep);
+		static ::Dynamic join_dyn();
+
+		static int lastIndexOf(::Dynamic this1, ::Dynamic searchElement, ::Dynamic fromIndex);
+		static ::Dynamic lastIndexOf_dyn();
+
+		static  ::Dynamic pop(::Dynamic this1);
+		static ::Dynamic pop_dyn();
+
+		static int push(::Dynamic this1, ::Dynamic value);
+		static ::Dynamic push_dyn();
+
+		static  ::Dynamic removeAt(::Dynamic this1,int index);
+		static ::Dynamic removeAt_dyn();
+
+		static  ::openfl::_Vector::ObjectVector reverse(::Dynamic this1);
+		static ::Dynamic reverse_dyn();
+
+		static  ::Dynamic set(::Dynamic this1,int index, ::Dynamic value);
+		static ::Dynamic set_dyn();
+
+		static  ::Dynamic shift(::Dynamic this1);
+		static ::Dynamic shift_dyn();
+
+		static  ::openfl::_Vector::ObjectVector slice(::Dynamic this1,hx::Null< int >  startIndex, ::Dynamic endIndex);
+		static ::Dynamic slice_dyn();
+
+		static void sort(::Dynamic this1, ::Dynamic sortBehavior);
+		static ::Dynamic sort_dyn();
+
+		static  ::openfl::_Vector::ObjectVector splice(::Dynamic this1,int startIndex,int deleteCount);
+		static ::Dynamic splice_dyn();
+
+		static ::String toString(::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+		static void unshift(::Dynamic this1, ::Dynamic value);
+		static ::Dynamic unshift_dyn();
+
+		static ::Dynamic convert(::Dynamic vec);
+		static ::Dynamic convert_dyn();
+
+		static  ::openfl::_Vector::BoolVector toBoolVector(::Dynamic t,int length,bool fixed,::cpp::VirtualArray array);
+		static ::Dynamic toBoolVector_dyn();
+
+		static  ::openfl::_Vector::IntVector toIntVector(::Dynamic t,int length,bool fixed,::cpp::VirtualArray array);
+		static ::Dynamic toIntVector_dyn();
+
+		static  ::openfl::_Vector::FloatVector toFloatVector(::Dynamic t,int length,bool fixed,::cpp::VirtualArray array);
+		static ::Dynamic toFloatVector_dyn();
+
+		static  ::openfl::_Vector::FunctionVector toFunctionVector(::Dynamic t,int length,bool fixed,::cpp::VirtualArray array);
+		static ::Dynamic toFunctionVector_dyn();
+
+		static  ::openfl::_Vector::ObjectVector toObjectVector(::Dynamic t,int length,bool fixed,::cpp::VirtualArray array);
+		static ::Dynamic toObjectVector_dyn();
+
+		static  ::openfl::_Vector::ObjectVector toNullVector(::Dynamic t,int length,bool fixed,::cpp::VirtualArray array);
+		static ::Dynamic toNullVector_dyn();
+
+		static  ::openfl::_Vector::ObjectVector fromBoolVector( ::openfl::_Vector::BoolVector vector);
+		static ::Dynamic fromBoolVector_dyn();
+
+		static  ::openfl::_Vector::ObjectVector fromIntVector( ::openfl::_Vector::IntVector vector);
+		static ::Dynamic fromIntVector_dyn();
+
+		static  ::openfl::_Vector::ObjectVector fromFloatVector( ::openfl::_Vector::FloatVector vector);
+		static ::Dynamic fromFloatVector_dyn();
+
+		static  ::openfl::_Vector::FunctionVector fromFunctionVector( ::openfl::_Vector::FunctionVector vector);
+		static ::Dynamic fromFunctionVector_dyn();
+
+		static  ::openfl::_Vector::ObjectVector fromObjectVector( ::openfl::_Vector::ObjectVector vector);
+		static ::Dynamic fromObjectVector_dyn();
+
+		static bool get_fixed(::Dynamic this1);
+		static ::Dynamic get_fixed_dyn();
+
+		static bool set_fixed(::Dynamic this1,bool value);
+		static ::Dynamic set_fixed_dyn();
+
+		static int get_length(::Dynamic this1);
+		static ::Dynamic get_length_dyn();
+
+		static int set_length(::Dynamic this1,int value);
+		static ::Dynamic set_length_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _Vector
+
+#endif /* INCLUDED_openfl__Vector_Vector_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/_internal/Lib.h

@@ -0,0 +1,82 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__internal_Lib
+#define INCLUDED_openfl__internal_Lib
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+HX_DECLARE_CLASS2(openfl,_internal,Lib)
+HX_DECLARE_CLASS2(openfl,display,Application)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,MovieClip)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES Lib_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Lib_obj OBJ_;
+		Lib_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0a0eec29 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl._internal.Lib")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl._internal.Lib"); }
+
+		inline static hx::ObjectPtr< Lib_obj > __new() {
+			hx::ObjectPtr< Lib_obj > __this = new Lib_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Lib_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Lib_obj *__this = (Lib_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Lib_obj), false, "openfl._internal.Lib"));
+			*(void **)__this = Lib_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Lib_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Lib",25,07,3a,00); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::openfl::display::Application application;
+		static  ::openfl::display::MovieClip current;
+		static  ::haxe::ds::StringMap _hx___sentWarnings;
+		static void notImplemented( ::Dynamic posInfo);
+		static ::Dynamic notImplemented_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl__internal_Lib */ 

hGameTest/bin/linux/obj/include/openfl/_internal/utils/TouchData.h

@@ -0,0 +1,73 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl__internal_utils_TouchData
+#define INCLUDED_openfl__internal_utils_TouchData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,ui,Touch)
+HX_DECLARE_CLASS2(lime,utils,ObjectPool)
+HX_DECLARE_CLASS3(openfl,_internal,utils,TouchData)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace _internal{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES TouchData_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef TouchData_obj OBJ_;
+		TouchData_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4f4ffc24 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl._internal.utils.TouchData")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl._internal.utils.TouchData"); }
+		static hx::ObjectPtr< TouchData_obj > __new();
+		static hx::ObjectPtr< TouchData_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~TouchData_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TouchData",69,c5,a2,a9); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::lime::utils::ObjectPool _hx___pool;
+		::Array< ::Dynamic> rollOutStack;
+		 ::lime::ui::Touch touch;
+		 ::openfl::display::InteractiveObject touchDownTarget;
+		 ::openfl::display::InteractiveObject touchOverTarget;
+		void reset();
+		::Dynamic reset_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace _internal
+} // end namespace utils
+
+#endif /* INCLUDED_openfl__internal_utils_TouchData */ 

hGameTest/bin/linux/obj/include/openfl/display/Application.h

@@ -0,0 +1,59 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Application
+#define INCLUDED_openfl_display_Application
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_lime_app_Application
+#include <lime/app/Application.h>
+#endif
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+HX_DECLARE_CLASS2(lime,ui,Window)
+HX_DECLARE_CLASS2(openfl,display,Application)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Application_obj : public  ::lime::app::Application_obj
+{
+	public:
+		typedef  ::lime::app::Application_obj super;
+		typedef Application_obj OBJ_;
+		Application_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4b993f3e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Application")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Application"); }
+		static hx::ObjectPtr< Application_obj > __new();
+		static hx::ObjectPtr< Application_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Application_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Application",30,43,71,0e); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::lime::ui::Window createWindow( ::Dynamic attributes);
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Application */ 

hGameTest/bin/linux/obj/include/openfl/display/Bitmap.h

@@ -0,0 +1,107 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Bitmap
+#define INCLUDED_openfl_display_Bitmap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObject
+#include <openfl/display/DisplayObject.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,Bitmap)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Bitmap_obj : public  ::openfl::display::DisplayObject_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObject_obj super;
+		typedef Bitmap_obj OBJ_;
+		Bitmap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3b5602c1 };
+
+		void __construct( ::openfl::display::BitmapData bitmapData, ::Dynamic pixelSnapping,hx::Null< bool >  __o_smoothing);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Bitmap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Bitmap"); }
+		static hx::ObjectPtr< Bitmap_obj > __new( ::openfl::display::BitmapData bitmapData, ::Dynamic pixelSnapping,hx::Null< bool >  __o_smoothing);
+		static hx::ObjectPtr< Bitmap_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::BitmapData bitmapData, ::Dynamic pixelSnapping,hx::Null< bool >  __o_smoothing);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Bitmap_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Bitmap",0f,84,a0,25); }
+
+		 ::Dynamic pixelSnapping;
+		bool smoothing;
+		 ::openfl::display::BitmapData _hx___bitmapData;
+		int _hx___imageVersion;
+		void _hx___enterFrame(int deltaTime);
+
+		void _hx___getBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+
+		bool _hx___hitTest(Float x,Float y,bool shapeFlag,::Array< ::Dynamic> stack,bool interactiveOnly, ::openfl::display::DisplayObject hitObject);
+
+		bool _hx___hitTestMask(Float x,Float y);
+
+		void _hx___renderCairo( ::openfl::display::CairoRenderer renderer);
+
+		void _hx___renderCairoMask( ::openfl::display::CairoRenderer renderer);
+
+		void _hx___renderCanvas( ::openfl::display::CanvasRenderer renderer);
+
+		void _hx___renderCanvasMask( ::openfl::display::CanvasRenderer renderer);
+
+		void _hx___renderDOM( ::openfl::display::DOMRenderer renderer);
+
+		void _hx___renderDOMClear( ::openfl::display::DOMRenderer renderer);
+
+		void _hx___renderGL( ::openfl::display::OpenGLRenderer renderer);
+
+		void _hx___renderGLMask( ::openfl::display::OpenGLRenderer renderer);
+
+		bool _hx___updateCacheBitmap( ::openfl::display::DisplayObjectRenderer renderer,bool force);
+
+		 ::openfl::display::BitmapData get_bitmapData();
+		::Dynamic get_bitmapData_dyn();
+
+		 ::openfl::display::BitmapData set_bitmapData( ::openfl::display::BitmapData value);
+		::Dynamic set_bitmapData_dyn();
+
+		Float set_height(Float value);
+
+		Float set_width(Float value);
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Bitmap */ 

hGameTest/bin/linux/obj/include/openfl/display/BitmapData.h

@@ -0,0 +1,344 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_BitmapData
+#define INCLUDED_openfl_display_BitmapData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IBitmapDrawable
+#include <openfl/display/IBitmapDrawable.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,graphics,Image)
+HX_DECLARE_CLASS2(lime,graphics,RenderContext)
+HX_DECLARE_CLASS3(lime,graphics,opengl,GLObject)
+HX_DECLARE_CLASS2(lime,math,Vector2)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,display3D,IndexBuffer3D)
+HX_DECLARE_CLASS2(openfl,display3D,VertexBuffer3D)
+HX_DECLARE_CLASS3(openfl,display3D,textures,TextureBase)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,filters,BitmapFilter)
+HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Point)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES BitmapData_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BitmapData_obj OBJ_;
+		BitmapData_obj();
+
+	public:
+		enum { _hx_ClassId = 0x28c743a7 };
+
+		void __construct(int width,int height,hx::Null< bool >  __o_transparent,hx::Null< int >  __o_fillColor);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.BitmapData")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.BitmapData"); }
+		static hx::ObjectPtr< BitmapData_obj > __new(int width,int height,hx::Null< bool >  __o_transparent,hx::Null< int >  __o_fillColor);
+		static hx::ObjectPtr< BitmapData_obj > __alloc(hx::Ctx *_hx_ctx,int width,int height,hx::Null< bool >  __o_transparent,hx::Null< int >  __o_fillColor);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BitmapData_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("BitmapData",d9,b9,71,2a); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static int VERTEX_BUFFER_STRIDE;
+		static  ::Dynamic _hx___supportsBGRA;
+		static int _hx___textureFormat;
+		static int _hx___textureInternalFormat;
+		static  ::lime::math::Vector2 _hx___tempVector;
+		static  ::openfl::display::BitmapData fromBase64(::String base64,::String type);
+		static ::Dynamic fromBase64_dyn();
+
+		static  ::openfl::display::BitmapData fromBytes( ::openfl::utils::ByteArrayData bytes, ::openfl::utils::ByteArrayData rawAlpha);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::openfl::display::BitmapData fromFile(::String path);
+		static ::Dynamic fromFile_dyn();
+
+		static  ::openfl::display::BitmapData fromImage( ::lime::graphics::Image image,hx::Null< bool >  transparent);
+		static ::Dynamic fromImage_dyn();
+
+		static  ::openfl::display::BitmapData fromTexture( ::openfl::display3D::textures::TextureBase texture);
+		static ::Dynamic fromTexture_dyn();
+
+		static  ::lime::app::Future loadFromBase64(::String base64,::String type);
+		static ::Dynamic loadFromBase64_dyn();
+
+		static  ::lime::app::Future loadFromBytes( ::openfl::utils::ByteArrayData bytes, ::openfl::utils::ByteArrayData rawAlpha);
+		static ::Dynamic loadFromBytes_dyn();
+
+		static  ::lime::app::Future loadFromFile(::String path);
+		static ::Dynamic loadFromFile_dyn();
+
+		int height;
+		 ::lime::graphics::Image image;
+		bool readable;
+		 ::openfl::geom::Rectangle rect;
+		bool transparent;
+		int width;
+		 ::Dynamic _hx___blendMode;
+		 ::lime::graphics::opengl::GLObject _hx___framebuffer;
+		 ::lime::graphics::RenderContext _hx___framebufferContext;
+		 ::openfl::display3D::IndexBuffer3D _hx___indexBuffer;
+		 ::lime::graphics::RenderContext _hx___indexBufferContext;
+		 ::lime::utils::ArrayBufferView _hx___indexBufferData;
+		 ::openfl::geom::Rectangle _hx___indexBufferGrid;
+		bool _hx___isMask;
+		bool _hx___isValid;
+		 ::openfl::display::DisplayObject _hx___mask;
+		bool _hx___renderable;
+		 ::openfl::geom::Matrix _hx___renderTransform;
+		 ::openfl::geom::Rectangle _hx___scrollRect;
+		 ::lime::graphics::opengl::GLObject _hx___stencilBuffer;
+		 ::Dynamic _hx___surface;
+		 ::openfl::display3D::textures::TextureBase _hx___texture;
+		 ::lime::graphics::RenderContext _hx___textureContext;
+		int _hx___textureHeight;
+		int _hx___textureVersion;
+		int _hx___textureWidth;
+		 ::openfl::geom::Matrix _hx___transform;
+		 ::openfl::geom::Rectangle _hx___uvRect;
+		 ::openfl::display3D::VertexBuffer3D _hx___vertexBuffer;
+		 ::lime::graphics::RenderContext _hx___vertexBufferContext;
+		 ::lime::utils::ArrayBufferView _hx___vertexBufferData;
+		 ::openfl::geom::Rectangle _hx___vertexBufferGrid;
+		Float _hx___vertexBufferHeight;
+		Float _hx___vertexBufferScaleX;
+		Float _hx___vertexBufferScaleY;
+		Float _hx___vertexBufferWidth;
+		Float _hx___worldAlpha;
+		 ::openfl::geom::ColorTransform _hx___worldColorTransform;
+		 ::openfl::geom::Matrix _hx___worldTransform;
+		void applyFilter( ::openfl::display::BitmapData sourceBitmapData, ::openfl::geom::Rectangle sourceRect, ::openfl::geom::Point destPoint, ::openfl::filters::BitmapFilter filter);
+		::Dynamic applyFilter_dyn();
+
+		 ::openfl::display::BitmapData clone();
+		::Dynamic clone_dyn();
+
+		void colorTransform( ::openfl::geom::Rectangle rect, ::openfl::geom::ColorTransform colorTransform);
+		::Dynamic colorTransform_dyn();
+
+		 ::Dynamic compare( ::openfl::display::BitmapData otherBitmapData);
+		::Dynamic compare_dyn();
+
+		void copyChannel( ::openfl::display::BitmapData sourceBitmapData, ::openfl::geom::Rectangle sourceRect, ::openfl::geom::Point destPoint,int sourceChannel,int destChannel);
+		::Dynamic copyChannel_dyn();
+
+		void copyPixels( ::openfl::display::BitmapData sourceBitmapData, ::openfl::geom::Rectangle sourceRect, ::openfl::geom::Point destPoint, ::openfl::display::BitmapData alphaBitmapData, ::openfl::geom::Point alphaPoint,hx::Null< bool >  mergeAlpha);
+		::Dynamic copyPixels_dyn();
+
+		void dispose();
+		::Dynamic dispose_dyn();
+
+		void disposeImage();
+		::Dynamic disposeImage_dyn();
+
+		void draw(::Dynamic source, ::openfl::geom::Matrix matrix, ::openfl::geom::ColorTransform colorTransform, ::Dynamic blendMode, ::openfl::geom::Rectangle clipRect,hx::Null< bool >  smoothing);
+		::Dynamic draw_dyn();
+
+		void drawWithQuality(::Dynamic source, ::openfl::geom::Matrix matrix, ::openfl::geom::ColorTransform colorTransform, ::Dynamic blendMode, ::openfl::geom::Rectangle clipRect,hx::Null< bool >  smoothing, ::Dynamic quality);
+		::Dynamic drawWithQuality_dyn();
+
+		 ::openfl::utils::ByteArrayData encode( ::openfl::geom::Rectangle rect, ::Dynamic compressor, ::openfl::utils::ByteArrayData byteArray);
+		::Dynamic encode_dyn();
+
+		void fillRect( ::openfl::geom::Rectangle rect,int color);
+		::Dynamic fillRect_dyn();
+
+		void floodFill(int x,int y,int color);
+		::Dynamic floodFill_dyn();
+
+		 ::openfl::geom::Rectangle generateFilterRect( ::openfl::geom::Rectangle sourceRect, ::openfl::filters::BitmapFilter filter);
+		::Dynamic generateFilterRect_dyn();
+
+		 ::openfl::display3D::IndexBuffer3D getIndexBuffer( ::openfl::display3D::Context3D context, ::openfl::geom::Rectangle scale9Grid);
+		::Dynamic getIndexBuffer_dyn();
+
+		 ::openfl::display3D::VertexBuffer3D getVertexBuffer( ::openfl::display3D::Context3D context, ::openfl::geom::Rectangle scale9Grid, ::openfl::display::DisplayObject targetObject);
+		::Dynamic getVertexBuffer_dyn();
+
+		 ::openfl::geom::Rectangle getColorBoundsRect(int mask,int color,hx::Null< bool >  findColor);
+		::Dynamic getColorBoundsRect_dyn();
+
+		int getPixel(int x,int y);
+		::Dynamic getPixel_dyn();
+
+		int getPixel32(int x,int y);
+		::Dynamic getPixel32_dyn();
+
+		 ::openfl::utils::ByteArrayData getPixels( ::openfl::geom::Rectangle rect);
+		::Dynamic getPixels_dyn();
+
+		 ::Dynamic getSurface();
+		::Dynamic getSurface_dyn();
+
+		 ::openfl::display3D::textures::TextureBase getTexture( ::openfl::display3D::Context3D context);
+		::Dynamic getTexture_dyn();
+
+		 ::openfl::_Vector::IntVector getVector( ::openfl::geom::Rectangle rect);
+		::Dynamic getVector_dyn();
+
+		::Array< ::Dynamic> histogram( ::openfl::geom::Rectangle hRect);
+		::Dynamic histogram_dyn();
+
+		bool hitTest( ::openfl::geom::Point firstPoint,int firstAlphaThreshold, ::Dynamic secondObject, ::openfl::geom::Point secondBitmapDataPoint,hx::Null< int >  secondAlphaThreshold);
+		::Dynamic hitTest_dyn();
+
+		void lock();
+		::Dynamic lock_dyn();
+
+		void merge( ::openfl::display::BitmapData sourceBitmapData, ::openfl::geom::Rectangle sourceRect, ::openfl::geom::Point destPoint,int redMultiplier,int greenMultiplier,int blueMultiplier,int alphaMultiplier);
+		::Dynamic merge_dyn();
+
+		void noise(int randomSeed,hx::Null< int >  low,hx::Null< int >  high,hx::Null< int >  channelOptions,hx::Null< bool >  grayScale);
+		::Dynamic noise_dyn();
+
+		void paletteMap( ::openfl::display::BitmapData sourceBitmapData, ::openfl::geom::Rectangle sourceRect, ::openfl::geom::Point destPoint,::Array< int > redArray,::Array< int > greenArray,::Array< int > blueArray,::Array< int > alphaArray);
+		::Dynamic paletteMap_dyn();
+
+		void perlinNoise(Float baseX,Float baseY,int numOctaves,int randomSeed,bool stitch,bool fractalNoise,hx::Null< int >  channelOptions,hx::Null< bool >  grayScale,::Array< ::Dynamic> offsets);
+		::Dynamic perlinNoise_dyn();
+
+		void scroll(int x,int y);
+		::Dynamic scroll_dyn();
+
+		void setPixel(int x,int y,int color);
+		::Dynamic setPixel_dyn();
+
+		void setPixel32(int x,int y,int color);
+		::Dynamic setPixel32_dyn();
+
+		void setPixels( ::openfl::geom::Rectangle rect, ::openfl::utils::ByteArrayData byteArray);
+		::Dynamic setPixels_dyn();
+
+		void setVector( ::openfl::geom::Rectangle rect, ::openfl::_Vector::IntVector inputVector);
+		::Dynamic setVector_dyn();
+
+		int threshold( ::openfl::display::BitmapData sourceBitmapData, ::openfl::geom::Rectangle sourceRect, ::openfl::geom::Point destPoint,::String operation,int threshold,hx::Null< int >  color,hx::Null< int >  mask,hx::Null< bool >  copySource);
+		::Dynamic threshold_dyn();
+
+		void unlock( ::openfl::geom::Rectangle changeRect);
+		::Dynamic unlock_dyn();
+
+		void _hx___applyAlpha( ::openfl::utils::ByteArrayData alpha);
+		::Dynamic _hx___applyAlpha_dyn();
+
+		void _hx___drawCairo(::Dynamic source, ::openfl::display::CairoRenderer renderer);
+		::Dynamic _hx___drawCairo_dyn();
+
+		void _hx___drawCanvas(::Dynamic source, ::openfl::display::CanvasRenderer renderer);
+		::Dynamic _hx___drawCanvas_dyn();
+
+		void _hx___drawGL(::Dynamic source, ::openfl::display::OpenGLRenderer renderer);
+		::Dynamic _hx___drawGL_dyn();
+
+		void _hx___fillRect( ::openfl::geom::Rectangle rect,int color,bool allowFramebuffer);
+		::Dynamic _hx___fillRect_dyn();
+
+		void _hx___fromBase64(::String base64,::String type);
+		::Dynamic _hx___fromBase64_dyn();
+
+		void _hx___fromBytes( ::openfl::utils::ByteArrayData bytes, ::openfl::utils::ByteArrayData rawAlpha);
+		::Dynamic _hx___fromBytes_dyn();
+
+		void _hx___fromFile(::String path);
+		::Dynamic _hx___fromFile_dyn();
+
+		void _hx___fromImage( ::lime::graphics::Image image);
+		::Dynamic _hx___fromImage_dyn();
+
+		void _hx___getBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+		::Dynamic _hx___getBounds_dyn();
+
+		 ::lime::app::Future _hx___loadFromBase64(::String base64,::String type);
+		::Dynamic _hx___loadFromBase64_dyn();
+
+		 ::lime::app::Future _hx___loadFromBytes( ::openfl::utils::ByteArrayData bytes, ::openfl::utils::ByteArrayData rawAlpha);
+		::Dynamic _hx___loadFromBytes_dyn();
+
+		 ::lime::app::Future _hx___loadFromFile(::String path);
+		::Dynamic _hx___loadFromFile_dyn();
+
+		void _hx___renderCairo( ::openfl::display::CairoRenderer renderer);
+		::Dynamic _hx___renderCairo_dyn();
+
+		void _hx___renderCairoMask( ::openfl::display::CairoRenderer renderer);
+		::Dynamic _hx___renderCairoMask_dyn();
+
+		void _hx___renderCanvas( ::openfl::display::CanvasRenderer renderer);
+		::Dynamic _hx___renderCanvas_dyn();
+
+		void _hx___renderCanvasMask( ::openfl::display::CanvasRenderer renderer);
+		::Dynamic _hx___renderCanvasMask_dyn();
+
+		void _hx___renderDOM( ::openfl::display::DOMRenderer renderer);
+		::Dynamic _hx___renderDOM_dyn();
+
+		void _hx___renderGL( ::openfl::display::OpenGLRenderer renderer);
+		::Dynamic _hx___renderGL_dyn();
+
+		void _hx___renderGLMask( ::openfl::display::OpenGLRenderer renderer);
+		::Dynamic _hx___renderGLMask_dyn();
+
+		void _hx___resize(int width,int height);
+		::Dynamic _hx___resize_dyn();
+
+		void _hx___setUVRect( ::openfl::display3D::Context3D context,Float x,Float y,Float width,Float height);
+		::Dynamic _hx___setUVRect_dyn();
+
+		void _hx___sync();
+		::Dynamic _hx___sync_dyn();
+
+		void _hx___update(bool transformOnly,bool updateChildren);
+		::Dynamic _hx___update_dyn();
+
+		void _hx___updateTransforms( ::openfl::geom::Matrix overrideTransform);
+		::Dynamic _hx___updateTransforms_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_BitmapData */ 

hGameTest/bin/linux/obj/include/openfl/display/CairoRenderer.h

@@ -0,0 +1,93 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_CairoRenderer
+#define INCLUDED_openfl_display_CairoRenderer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObjectRenderer
+#include <openfl/display/DisplayObjectRenderer.h>
+#endif
+HX_DECLARE_CLASS3(lime,graphics,cairo,Cairo)
+HX_DECLARE_CLASS2(lime,math,Matrix3)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES CairoRenderer_obj : public  ::openfl::display::DisplayObjectRenderer_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObjectRenderer_obj super;
+		typedef CairoRenderer_obj OBJ_;
+		CairoRenderer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7eb06559 };
+
+		void __construct( ::lime::graphics::cairo::Cairo cairo);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.CairoRenderer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.CairoRenderer"); }
+		static hx::ObjectPtr< CairoRenderer_obj > __new( ::lime::graphics::cairo::Cairo cairo);
+		static hx::ObjectPtr< CairoRenderer_obj > __alloc(hx::Ctx *_hx_ctx, ::lime::graphics::cairo::Cairo cairo);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CairoRenderer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CairoRenderer",cb,c9,86,aa); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::lime::graphics::cairo::Cairo cairo;
+		 ::openfl::geom::Matrix _hx___matrix;
+		 ::lime::math::Matrix3 _hx___matrix3;
+		void applyMatrix( ::openfl::geom::Matrix transform, ::lime::graphics::cairo::Cairo cairo);
+		::Dynamic applyMatrix_dyn();
+
+		void _hx___clear();
+
+		void _hx___popMask();
+
+		void _hx___popMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___popMaskRect();
+
+		void _hx___pushMask( ::openfl::display::DisplayObject mask);
+
+		void _hx___pushMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___pushMaskRect( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix transform);
+
+		void _hx___render(::Dynamic object);
+
+		void _hx___setBlendMode( ::Dynamic value);
+
+		void _hx___setBlendModeCairo( ::lime::graphics::cairo::Cairo cairo, ::Dynamic value);
+		::Dynamic _hx___setBlendModeCairo_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_CairoRenderer */ 

hGameTest/bin/linux/obj/include/openfl/display/CanvasRenderer.h

@@ -0,0 +1,95 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_CanvasRenderer
+#define INCLUDED_openfl_display_CanvasRenderer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObjectRenderer
+#include <openfl/display/DisplayObjectRenderer.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES CanvasRenderer_obj : public  ::openfl::display::DisplayObjectRenderer_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObjectRenderer_obj super;
+		typedef CanvasRenderer_obj OBJ_;
+		CanvasRenderer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0388830d };
+
+		void __construct( ::Dynamic context);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.CanvasRenderer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.CanvasRenderer"); }
+		static hx::ObjectPtr< CanvasRenderer_obj > __new( ::Dynamic context);
+		static hx::ObjectPtr< CanvasRenderer_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic context);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CanvasRenderer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CanvasRenderer",5b,02,4a,33); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic context;
+		Float pixelRatio;
+		bool _hx___isDOM;
+		 ::openfl::geom::Matrix _hx___tempMatrix;
+		void applySmoothing( ::Dynamic context,bool value);
+		::Dynamic applySmoothing_dyn();
+
+		void setTransform( ::openfl::geom::Matrix transform, ::Dynamic context);
+		::Dynamic setTransform_dyn();
+
+		void _hx___clear();
+
+		void _hx___popMask();
+
+		void _hx___popMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___popMaskRect();
+
+		void _hx___pushMask( ::openfl::display::DisplayObject mask);
+
+		void _hx___pushMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___pushMaskRect( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix transform);
+
+		void _hx___render(::Dynamic object);
+
+		void _hx___setBlendMode( ::Dynamic value);
+
+		void _hx___setBlendModeContext( ::Dynamic context, ::Dynamic value);
+		::Dynamic _hx___setBlendModeContext_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_CanvasRenderer */ 

hGameTest/bin/linux/obj/include/openfl/display/DOMRenderer.h

@@ -0,0 +1,103 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_DOMRenderer
+#define INCLUDED_openfl_display_DOMRenderer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObjectRenderer
+#include <openfl/display/DisplayObjectRenderer.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES DOMRenderer_obj : public  ::openfl::display::DisplayObjectRenderer_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObjectRenderer_obj super;
+		typedef DOMRenderer_obj OBJ_;
+		DOMRenderer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1dbc9c37 };
+
+		void __construct( ::Dynamic element);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.DOMRenderer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.DOMRenderer"); }
+		static hx::ObjectPtr< DOMRenderer_obj > __new( ::Dynamic element);
+		static hx::ObjectPtr< DOMRenderer_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic element);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DOMRenderer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DOMRenderer",c5,91,39,91); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic element;
+		Float pixelRatio;
+		 ::openfl::display::CanvasRenderer _hx___canvasRenderer;
+		::Array< ::Dynamic> _hx___clipRects;
+		 ::openfl::geom::Rectangle _hx___currentClipRect;
+		int _hx___numClipRects;
+		::String _hx___transformOriginProperty;
+		::String _hx___transformProperty;
+		::String _hx___vendorPrefix;
+		int _hx___z;
+		void applyStyle( ::openfl::display::DisplayObject parent, ::Dynamic childElement);
+		::Dynamic applyStyle_dyn();
+
+		void clearStyle( ::Dynamic childElement);
+		::Dynamic clearStyle_dyn();
+
+		void _hx___applyStyle( ::openfl::display::DisplayObject displayObject,bool setTransform,bool setAlpha,bool setClip);
+		::Dynamic _hx___applyStyle_dyn();
+
+		void _hx___popMask();
+
+		void _hx___popMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___popMaskRect();
+
+		void _hx___pushMask( ::openfl::display::DisplayObject mask);
+
+		void _hx___pushMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___pushMaskRect( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix transform);
+
+		void _hx___render(::Dynamic object);
+
+		void _hx___setBlendMode( ::Dynamic value);
+
+		void _hx___updateClip( ::openfl::display::DisplayObject displayObject);
+		::Dynamic _hx___updateClip_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_DOMRenderer */ 

hGameTest/bin/linux/obj/include/openfl/display/DefaultPreloader.h

@@ -0,0 +1,101 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_DefaultPreloader
+#define INCLUDED_openfl_display_DefaultPreloader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_Sprite
+#include <openfl/display/Sprite.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DefaultPreloader)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Shape)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,ProgressEvent)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES DefaultPreloader_obj : public  ::openfl::display::Sprite_obj
+{
+	public:
+		typedef  ::openfl::display::Sprite_obj super;
+		typedef DefaultPreloader_obj OBJ_;
+		DefaultPreloader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x015b8e1b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.DefaultPreloader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.DefaultPreloader"); }
+		static hx::ObjectPtr< DefaultPreloader_obj > __new();
+		static hx::ObjectPtr< DefaultPreloader_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DefaultPreloader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DefaultPreloader",95,27,6f,5f); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		int endAnimation;
+		 ::openfl::display::Shape outline;
+		 ::openfl::display::Shape progress;
+		int startAnimation;
+		int getBackgroundColor();
+		::Dynamic getBackgroundColor_dyn();
+
+		Float getHeight();
+		::Dynamic getHeight_dyn();
+
+		Float getWidth();
+		::Dynamic getWidth_dyn();
+
+		void onInit();
+		::Dynamic onInit_dyn();
+
+		void onLoaded();
+		::Dynamic onLoaded_dyn();
+
+		void onUpdate(int bytesLoaded,int bytesTotal);
+		::Dynamic onUpdate_dyn();
+
+		void this_onAddedToStage( ::openfl::events::Event event);
+		::Dynamic this_onAddedToStage_dyn();
+
+		void this_onComplete( ::openfl::events::Event event);
+		::Dynamic this_onComplete_dyn();
+
+		void this_onEnterFrame( ::openfl::events::Event event);
+		::Dynamic this_onEnterFrame_dyn();
+
+		void this_onProgress( ::openfl::events::ProgressEvent event);
+		::Dynamic this_onProgress_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_DefaultPreloader */ 

hGameTest/bin/linux/obj/include/openfl/display/DisplayObject.h

@@ -0,0 +1,425 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_DisplayObject
+#define INCLUDED_openfl_display_DisplayObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_EventDispatcher
+#include <openfl/events/EventDispatcher.h>
+#endif
+#ifndef INCLUDED_openfl_display_IBitmapDrawable
+#include <openfl/display/IBitmapDrawable.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS3(lime,graphics,cairo,Cairo)
+HX_DECLARE_CLASS2(lime,utils,ObjectPool)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,ObjectVector)
+HX_DECLARE_CLASS2(openfl,display,Bitmap)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,Graphics)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,LoaderInfo)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS2(openfl,display,Stage)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,RenderEvent)
+HX_DECLARE_CLASS2(openfl,filters,BitmapFilter)
+HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Point)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+HX_DECLARE_CLASS2(openfl,geom,Transform)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES DisplayObject_obj : public  ::openfl::events::EventDispatcher_obj
+{
+	public:
+		typedef  ::openfl::events::EventDispatcher_obj super;
+		typedef DisplayObject_obj OBJ_;
+		DisplayObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x19c29573 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.DisplayObject")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.DisplayObject"); }
+		static hx::ObjectPtr< DisplayObject_obj > __new();
+		static hx::ObjectPtr< DisplayObject_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DisplayObject_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("DisplayObject",81,8a,92,1e); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::haxe::ds::StringMap _hx___broadcastEvents;
+		static  ::openfl::display::Stage _hx___initStage;
+		static int _hx___instanceCount;
+		static bool _hx___supportDOM;
+		static  ::lime::utils::ObjectPool _hx___tempStack;
+		static void _hx___calculateAbsoluteTransform( ::openfl::geom::Matrix local, ::openfl::geom::Matrix parentTransform, ::openfl::geom::Matrix target);
+		static ::Dynamic _hx___calculateAbsoluteTransform_dyn();
+
+		 ::Dynamic opaqueBackground;
+		 ::openfl::display::DisplayObjectContainer parent;
+		 ::openfl::display::Stage stage;
+		Float _hx___alpha;
+		 ::Dynamic _hx___blendMode;
+		bool _hx___cacheAsBitmap;
+		 ::openfl::geom::Matrix _hx___cacheAsBitmapMatrix;
+		 ::openfl::display::Bitmap _hx___cacheBitmap;
+		 ::Dynamic _hx___cacheBitmapBackground;
+		 ::openfl::geom::ColorTransform _hx___cacheBitmapColorTransform;
+		 ::openfl::display::BitmapData _hx___cacheBitmapData;
+		 ::openfl::display::BitmapData _hx___cacheBitmapData2;
+		 ::openfl::display::BitmapData _hx___cacheBitmapData3;
+		 ::openfl::geom::Matrix _hx___cacheBitmapMatrix;
+		 ::openfl::display::DisplayObjectRenderer _hx___cacheBitmapRenderer;
+		 ::lime::graphics::cairo::Cairo _hx___cairo;
+		::Array< ::Dynamic> _hx___children;
+		bool _hx___customRenderClear;
+		 ::openfl::events::RenderEvent _hx___customRenderEvent;
+		::Array< ::Dynamic> _hx___filters;
+		 ::openfl::display::Graphics _hx___graphics;
+		bool _hx___interactive;
+		bool _hx___isCacheBitmapRender;
+		bool _hx___isMask;
+		 ::openfl::display::LoaderInfo _hx___loaderInfo;
+		 ::openfl::display::DisplayObject _hx___mask;
+		 ::openfl::display::DisplayObject _hx___maskTarget;
+		::String _hx___name;
+		 ::openfl::geom::Transform _hx___objectTransform;
+		bool _hx___renderable;
+		bool _hx___renderDirty;
+		 ::openfl::display::DisplayObject _hx___renderParent;
+		 ::openfl::geom::Matrix _hx___renderTransform;
+		 ::openfl::geom::Matrix _hx___renderTransformCache;
+		bool _hx___renderTransformChanged;
+		Float _hx___rotation;
+		Float _hx___rotationCosine;
+		Float _hx___rotationSine;
+		 ::openfl::geom::Rectangle _hx___scale9Grid;
+		Float _hx___scaleX;
+		Float _hx___scaleY;
+		 ::openfl::geom::Rectangle _hx___scrollRect;
+		 ::openfl::display::Shader _hx___shader;
+		 ::openfl::geom::Point _hx___tempPoint;
+		 ::openfl::geom::Matrix _hx___transform;
+		bool _hx___transformDirty;
+		bool _hx___visible;
+		Float _hx___worldAlpha;
+		bool _hx___worldAlphaChanged;
+		 ::Dynamic _hx___worldBlendMode;
+		 ::openfl::geom::Rectangle _hx___worldClip;
+		bool _hx___worldClipChanged;
+		 ::openfl::geom::ColorTransform _hx___worldColorTransform;
+		 ::openfl::display::Shader _hx___worldShader;
+		 ::openfl::geom::Rectangle _hx___worldScale9Grid;
+		 ::openfl::geom::Matrix _hx___worldTransform;
+		bool _hx___worldVisible;
+		bool _hx___worldVisibleChanged;
+		bool _hx___worldTransformInvalid;
+		int _hx___worldZ;
+		void addEventListener(::String type, ::Dynamic listener,hx::Null< bool >  useCapture,hx::Null< int >  priority,hx::Null< bool >  useWeakReference);
+
+		bool dispatchEvent( ::openfl::events::Event event);
+
+		 ::openfl::geom::Rectangle getBounds( ::openfl::display::DisplayObject targetCoordinateSpace);
+		::Dynamic getBounds_dyn();
+
+		 ::openfl::geom::Rectangle getRect( ::openfl::display::DisplayObject targetCoordinateSpace);
+		::Dynamic getRect_dyn();
+
+		 ::openfl::geom::Point globalToLocal( ::openfl::geom::Point pos);
+		::Dynamic globalToLocal_dyn();
+
+		bool hitTestObject( ::openfl::display::DisplayObject obj);
+		::Dynamic hitTestObject_dyn();
+
+		bool hitTestPoint(Float x,Float y,hx::Null< bool >  shapeFlag);
+		::Dynamic hitTestPoint_dyn();
+
+		virtual void invalidate();
+		::Dynamic invalidate_dyn();
+
+		virtual  ::openfl::geom::Point localToGlobal( ::openfl::geom::Point point);
+		::Dynamic localToGlobal_dyn();
+
+		void removeEventListener(::String type, ::Dynamic listener,hx::Null< bool >  useCapture);
+
+		virtual void _hx___cleanup();
+		::Dynamic _hx___cleanup_dyn();
+
+		bool _hx___dispatch( ::openfl::events::Event event);
+		::Dynamic _hx___dispatch_dyn();
+
+		virtual void _hx___dispatchChildren( ::openfl::events::Event event);
+		::Dynamic _hx___dispatchChildren_dyn();
+
+		virtual bool _hx___dispatchEvent( ::openfl::events::Event event);
+
+		bool _hx___dispatchWithCapture( ::openfl::events::Event event);
+		::Dynamic _hx___dispatchWithCapture_dyn();
+
+		virtual void _hx___enterFrame(int deltaTime);
+		::Dynamic _hx___enterFrame_dyn();
+
+		virtual void _hx___getBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+		::Dynamic _hx___getBounds_dyn();
+
+		virtual ::String _hx___getCursor();
+		::Dynamic _hx___getCursor_dyn();
+
+		virtual void _hx___getFilterBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+		::Dynamic _hx___getFilterBounds_dyn();
+
+		virtual bool _hx___getInteractive(::Array< ::Dynamic> stack);
+		::Dynamic _hx___getInteractive_dyn();
+
+		void _hx___getLocalBounds( ::openfl::geom::Rectangle rect);
+		::Dynamic _hx___getLocalBounds_dyn();
+
+		virtual void _hx___getRenderBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+		::Dynamic _hx___getRenderBounds_dyn();
+
+		 ::openfl::geom::Matrix _hx___getRenderTransform();
+		::Dynamic _hx___getRenderTransform_dyn();
+
+		 ::openfl::geom::Matrix _hx___getWorldTransform();
+		::Dynamic _hx___getWorldTransform_dyn();
+
+		virtual  ::openfl::geom::Point _hx___globalToLocal( ::openfl::geom::Point global, ::openfl::geom::Point local);
+		::Dynamic _hx___globalToLocal_dyn();
+
+		virtual bool _hx___hitTest(Float x,Float y,bool shapeFlag,::Array< ::Dynamic> stack,bool interactiveOnly, ::openfl::display::DisplayObject hitObject);
+		::Dynamic _hx___hitTest_dyn();
+
+		virtual bool _hx___hitTestMask(Float x,Float y);
+		::Dynamic _hx___hitTestMask_dyn();
+
+		virtual void _hx___readGraphicsData( ::openfl::_Vector::ObjectVector graphicsData,bool recurse);
+		::Dynamic _hx___readGraphicsData_dyn();
+
+		virtual void _hx___renderCairo( ::openfl::display::CairoRenderer renderer);
+		::Dynamic _hx___renderCairo_dyn();
+
+		virtual void _hx___renderCairoMask( ::openfl::display::CairoRenderer renderer);
+		::Dynamic _hx___renderCairoMask_dyn();
+
+		virtual void _hx___renderCanvas( ::openfl::display::CanvasRenderer renderer);
+		::Dynamic _hx___renderCanvas_dyn();
+
+		virtual void _hx___renderCanvasMask( ::openfl::display::CanvasRenderer renderer);
+		::Dynamic _hx___renderCanvasMask_dyn();
+
+		virtual void _hx___renderDOM( ::openfl::display::DOMRenderer renderer);
+		::Dynamic _hx___renderDOM_dyn();
+
+		virtual void _hx___renderDOMClear( ::openfl::display::DOMRenderer renderer);
+		::Dynamic _hx___renderDOMClear_dyn();
+
+		void _hx___renderEvent( ::openfl::display::DisplayObjectRenderer renderer);
+		::Dynamic _hx___renderEvent_dyn();
+
+		virtual void _hx___renderGL( ::openfl::display::OpenGLRenderer renderer);
+		::Dynamic _hx___renderGL_dyn();
+
+		virtual void _hx___renderGLMask( ::openfl::display::OpenGLRenderer renderer);
+		::Dynamic _hx___renderGLMask_dyn();
+
+		void _hx___setParentRenderDirty();
+		::Dynamic _hx___setParentRenderDirty_dyn();
+
+		void _hx___setRenderDirty();
+		::Dynamic _hx___setRenderDirty_dyn();
+
+		virtual void _hx___setStageReference( ::openfl::display::Stage stage);
+		::Dynamic _hx___setStageReference_dyn();
+
+		void _hx___setTransformDirty();
+		::Dynamic _hx___setTransformDirty_dyn();
+
+		virtual void _hx___setWorldTransformInvalid();
+		::Dynamic _hx___setWorldTransformInvalid_dyn();
+
+		virtual  ::Dynamic _hx___shouldCacheHardware( ::Dynamic value);
+		::Dynamic _hx___shouldCacheHardware_dyn();
+
+		virtual void _hx___stopAllMovieClips();
+		::Dynamic _hx___stopAllMovieClips_dyn();
+
+		virtual void _hx___update(bool transformOnly,bool updateChildren);
+		::Dynamic _hx___update_dyn();
+
+		virtual bool _hx___updateCacheBitmap( ::openfl::display::DisplayObjectRenderer renderer,bool force);
+		::Dynamic _hx___updateCacheBitmap_dyn();
+
+		void _hx___updateTransforms( ::openfl::geom::Matrix overrideTransform);
+		::Dynamic _hx___updateTransforms_dyn();
+
+		Float get_alpha();
+		::Dynamic get_alpha_dyn();
+
+		Float set_alpha(Float value);
+		::Dynamic set_alpha_dyn();
+
+		 ::Dynamic get_blendMode();
+		::Dynamic get_blendMode_dyn();
+
+		 ::Dynamic set_blendMode( ::Dynamic value);
+		::Dynamic set_blendMode_dyn();
+
+		bool get_cacheAsBitmap();
+		::Dynamic get_cacheAsBitmap_dyn();
+
+		bool set_cacheAsBitmap(bool value);
+		::Dynamic set_cacheAsBitmap_dyn();
+
+		 ::openfl::geom::Matrix get_cacheAsBitmapMatrix();
+		::Dynamic get_cacheAsBitmapMatrix_dyn();
+
+		 ::openfl::geom::Matrix set_cacheAsBitmapMatrix( ::openfl::geom::Matrix value);
+		::Dynamic set_cacheAsBitmapMatrix_dyn();
+
+		::Array< ::Dynamic> get_filters();
+		::Dynamic get_filters_dyn();
+
+		::Array< ::Dynamic> set_filters(::Array< ::Dynamic> value);
+		::Dynamic set_filters_dyn();
+
+		Float get_height();
+		::Dynamic get_height_dyn();
+
+		virtual Float set_height(Float value);
+		::Dynamic set_height_dyn();
+
+		 ::openfl::display::LoaderInfo get_loaderInfo();
+		::Dynamic get_loaderInfo_dyn();
+
+		 ::openfl::display::DisplayObject get_mask();
+		::Dynamic get_mask_dyn();
+
+		 ::openfl::display::DisplayObject set_mask( ::openfl::display::DisplayObject value);
+		::Dynamic set_mask_dyn();
+
+		virtual Float get_mouseX();
+		::Dynamic get_mouseX_dyn();
+
+		virtual Float get_mouseY();
+		::Dynamic get_mouseY_dyn();
+
+		::String get_name();
+		::Dynamic get_name_dyn();
+
+		::String set_name(::String value);
+		::Dynamic set_name_dyn();
+
+		 ::openfl::display::DisplayObject get_root();
+		::Dynamic get_root_dyn();
+
+		Float get_rotation();
+		::Dynamic get_rotation_dyn();
+
+		virtual Float set_rotation(Float value);
+		::Dynamic set_rotation_dyn();
+
+		 ::openfl::geom::Rectangle get_scale9Grid();
+		::Dynamic get_scale9Grid_dyn();
+
+		 ::openfl::geom::Rectangle set_scale9Grid( ::openfl::geom::Rectangle value);
+		::Dynamic set_scale9Grid_dyn();
+
+		Float get_scaleX();
+		::Dynamic get_scaleX_dyn();
+
+		virtual Float set_scaleX(Float value);
+		::Dynamic set_scaleX_dyn();
+
+		Float get_scaleY();
+		::Dynamic get_scaleY_dyn();
+
+		virtual Float set_scaleY(Float value);
+		::Dynamic set_scaleY_dyn();
+
+		 ::openfl::geom::Rectangle get_scrollRect();
+		::Dynamic get_scrollRect_dyn();
+
+		 ::openfl::geom::Rectangle set_scrollRect( ::openfl::geom::Rectangle value);
+		::Dynamic set_scrollRect_dyn();
+
+		 ::openfl::display::Shader get_shader();
+		::Dynamic get_shader_dyn();
+
+		 ::openfl::display::Shader set_shader( ::openfl::display::Shader value);
+		::Dynamic set_shader_dyn();
+
+		 ::openfl::geom::Transform get_transform();
+		::Dynamic get_transform_dyn();
+
+		virtual  ::openfl::geom::Transform set_transform( ::openfl::geom::Transform value);
+		::Dynamic set_transform_dyn();
+
+		bool get_visible();
+		::Dynamic get_visible_dyn();
+
+		bool set_visible(bool value);
+		::Dynamic set_visible_dyn();
+
+		Float get_width();
+		::Dynamic get_width_dyn();
+
+		virtual Float set_width(Float value);
+		::Dynamic set_width_dyn();
+
+		Float get_x();
+		::Dynamic get_x_dyn();
+
+		virtual Float set_x(Float value);
+		::Dynamic set_x_dyn();
+
+		Float get_y();
+		::Dynamic get_y_dyn();
+
+		virtual Float set_y(Float value);
+		::Dynamic set_y_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_DisplayObject */ 

hGameTest/bin/linux/obj/include/openfl/display/DisplayObjectContainer.h

@@ -0,0 +1,182 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_DisplayObjectContainer
+#define INCLUDED_openfl_display_DisplayObjectContainer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_InteractiveObject
+#include <openfl/display/InteractiveObject.h>
+#endif
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,ObjectVector)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS2(openfl,display,Stage)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Point)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES DisplayObjectContainer_obj : public  ::openfl::display::InteractiveObject_obj
+{
+	public:
+		typedef  ::openfl::display::InteractiveObject_obj super;
+		typedef DisplayObjectContainer_obj OBJ_;
+		DisplayObjectContainer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x17120186 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.DisplayObjectContainer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.DisplayObjectContainer"); }
+		static hx::ObjectPtr< DisplayObjectContainer_obj > __new();
+		static hx::ObjectPtr< DisplayObjectContainer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DisplayObjectContainer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DisplayObjectContainer",80,f2,98,ea); }
+
+		bool mouseChildren;
+		 ::openfl::_Vector::ObjectVector _hx___removedChildren;
+		bool _hx___tabChildren;
+		 ::openfl::display::DisplayObject addChild( ::openfl::display::DisplayObject child);
+		::Dynamic addChild_dyn();
+
+		 ::openfl::display::DisplayObject addChildAt( ::openfl::display::DisplayObject child,int index);
+		::Dynamic addChildAt_dyn();
+
+		bool areInaccessibleObjectsUnderPoint( ::openfl::geom::Point point);
+		::Dynamic areInaccessibleObjectsUnderPoint_dyn();
+
+		bool contains( ::openfl::display::DisplayObject child);
+		::Dynamic contains_dyn();
+
+		 ::openfl::display::DisplayObject getChildAt(int index);
+		::Dynamic getChildAt_dyn();
+
+		 ::openfl::display::DisplayObject getChildByName(::String name);
+		::Dynamic getChildByName_dyn();
+
+		int getChildIndex( ::openfl::display::DisplayObject child);
+		::Dynamic getChildIndex_dyn();
+
+		::Array< ::Dynamic> getObjectsUnderPoint( ::openfl::geom::Point point);
+		::Dynamic getObjectsUnderPoint_dyn();
+
+		 ::openfl::display::DisplayObject removeChild( ::openfl::display::DisplayObject child);
+		::Dynamic removeChild_dyn();
+
+		 ::openfl::display::DisplayObject removeChildAt(int index);
+		::Dynamic removeChildAt_dyn();
+
+		void removeChildren(hx::Null< int >  beginIndex,hx::Null< int >  endIndex);
+		::Dynamic removeChildren_dyn();
+
+		 ::openfl::display::DisplayObject resolve(::String fieldName);
+		::Dynamic resolve_dyn();
+
+		void setChildIndex( ::openfl::display::DisplayObject child,int index);
+		::Dynamic setChildIndex_dyn();
+
+		void stopAllMovieClips();
+		::Dynamic stopAllMovieClips_dyn();
+
+		void swapChildren( ::openfl::display::DisplayObject child1, ::openfl::display::DisplayObject child2);
+		::Dynamic swapChildren_dyn();
+
+		void swapChildrenAt(int index1,int index2);
+		::Dynamic swapChildrenAt_dyn();
+
+		void _hx___cleanup();
+
+		void _hx___cleanupRemovedChildren();
+		::Dynamic _hx___cleanupRemovedChildren_dyn();
+
+		void _hx___dispatchChildren( ::openfl::events::Event event);
+
+		virtual void _hx___enterFrame(int deltaTime);
+
+		void _hx___getBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+
+		void _hx___getFilterBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+
+		void _hx___getRenderBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+
+		virtual bool _hx___hitTest(Float x,Float y,bool shapeFlag,::Array< ::Dynamic> stack,bool interactiveOnly, ::openfl::display::DisplayObject hitObject);
+
+		virtual bool _hx___hitTestMask(Float x,Float y);
+
+		void _hx___readGraphicsData( ::openfl::_Vector::ObjectVector graphicsData,bool recurse);
+
+		void _hx___renderCairo( ::openfl::display::CairoRenderer renderer);
+
+		void _hx___renderCairoMask( ::openfl::display::CairoRenderer renderer);
+
+		void _hx___renderCanvas( ::openfl::display::CanvasRenderer renderer);
+
+		void _hx___renderCanvasMask( ::openfl::display::CanvasRenderer renderer);
+
+		void _hx___renderDOM( ::openfl::display::DOMRenderer renderer);
+
+		void _hx___renderDOMClear( ::openfl::display::DOMRenderer renderer);
+
+		void _hx___renderGL( ::openfl::display::OpenGLRenderer renderer);
+
+		void _hx___renderGLMask( ::openfl::display::OpenGLRenderer renderer);
+
+		void _hx___setStageReference( ::openfl::display::Stage stage);
+
+		void _hx___setWorldTransformInvalid();
+
+		 ::Dynamic _hx___shouldCacheHardware( ::Dynamic value);
+
+		virtual void _hx___stopAllMovieClips();
+
+		virtual void _hx___tabTest(::Array< ::Dynamic> stack);
+
+		virtual void _hx___update(bool transformOnly,bool updateChildren);
+
+		int get_numChildren();
+		::Dynamic get_numChildren_dyn();
+
+		bool get_tabChildren();
+		::Dynamic get_tabChildren_dyn();
+
+		bool set_tabChildren(bool value);
+		::Dynamic set_tabChildren_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_DisplayObjectContainer */ 

hGameTest/bin/linux/obj/include/openfl/display/DisplayObjectRenderer.h

@@ -0,0 +1,118 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_DisplayObjectRenderer
+#define INCLUDED_openfl_display_DisplayObjectRenderer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_EventDispatcher
+#include <openfl/events/EventDispatcher.h>
+#endif
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,graphics,RenderContext)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Stage)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES DisplayObjectRenderer_obj : public  ::openfl::events::EventDispatcher_obj
+{
+	public:
+		typedef  ::openfl::events::EventDispatcher_obj super;
+		typedef DisplayObjectRenderer_obj OBJ_;
+		DisplayObjectRenderer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7cdf41d6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.DisplayObjectRenderer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.DisplayObjectRenderer"); }
+		static hx::ObjectPtr< DisplayObjectRenderer_obj > __new();
+		static hx::ObjectPtr< DisplayObjectRenderer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DisplayObjectRenderer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DisplayObjectRenderer",e4,f4,5f,fb); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool _hx___allowSmoothing;
+		 ::Dynamic _hx___blendMode;
+		bool _hx___cleared;
+		 ::lime::graphics::RenderContext _hx___context;
+		 ::Dynamic _hx___overrideBlendMode;
+		bool _hx___roundPixels;
+		 ::openfl::display::Stage _hx___stage;
+		 ::openfl::geom::ColorTransform _hx___tempColorTransform;
+		bool _hx___transparent;
+		::String _hx___type;
+		Float _hx___worldAlpha;
+		 ::openfl::geom::ColorTransform _hx___worldColorTransform;
+		 ::openfl::geom::Matrix _hx___worldTransform;
+		virtual void _hx___clear();
+		::Dynamic _hx___clear_dyn();
+
+		Float _hx___getAlpha(Float value);
+		::Dynamic _hx___getAlpha_dyn();
+
+		 ::openfl::geom::ColorTransform _hx___getColorTransform( ::openfl::geom::ColorTransform value);
+		::Dynamic _hx___getColorTransform_dyn();
+
+		virtual void _hx___popMask();
+		::Dynamic _hx___popMask_dyn();
+
+		virtual void _hx___popMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+		::Dynamic _hx___popMaskObject_dyn();
+
+		virtual void _hx___popMaskRect();
+		::Dynamic _hx___popMaskRect_dyn();
+
+		virtual void _hx___pushMask( ::openfl::display::DisplayObject mask);
+		::Dynamic _hx___pushMask_dyn();
+
+		virtual void _hx___pushMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+		::Dynamic _hx___pushMaskObject_dyn();
+
+		virtual void _hx___pushMaskRect( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix transform);
+		::Dynamic _hx___pushMaskRect_dyn();
+
+		virtual void _hx___render(::Dynamic object);
+		::Dynamic _hx___render_dyn();
+
+		virtual void _hx___resize(int width,int height);
+		::Dynamic _hx___resize_dyn();
+
+		virtual void _hx___setBlendMode( ::Dynamic value);
+		::Dynamic _hx___setBlendMode_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_DisplayObjectRenderer */ 

hGameTest/bin/linux/obj/include/openfl/display/DisplayObjectShader.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_DisplayObjectShader
+#define INCLUDED_openfl_display_DisplayObjectShader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_Shader
+#include <openfl/display/Shader.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectShader)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS2(openfl,display,ShaderInput_openfl_display_BitmapData)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Bool)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Float)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES DisplayObjectShader_obj : public  ::openfl::display::Shader_obj
+{
+	public:
+		typedef  ::openfl::display::Shader_obj super;
+		typedef DisplayObjectShader_obj OBJ_;
+		DisplayObjectShader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x119ff35c };
+
+		void __construct( ::openfl::utils::ByteArrayData code);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.DisplayObjectShader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.DisplayObjectShader"); }
+		static hx::ObjectPtr< DisplayObjectShader_obj > __new( ::openfl::utils::ByteArrayData code);
+		static hx::ObjectPtr< DisplayObjectShader_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::utils::ByteArrayData code);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DisplayObjectShader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DisplayObjectShader",86,14,1c,30); }
+
+		 ::openfl::display::ShaderParameter_Float openfl_Alpha;
+		 ::openfl::display::ShaderParameter_Float openfl_ColorMultiplier;
+		 ::openfl::display::ShaderParameter_Float openfl_ColorOffset;
+		 ::openfl::display::ShaderParameter_Float openfl_Position;
+		 ::openfl::display::ShaderParameter_Float openfl_TextureCoord;
+		 ::openfl::display::ShaderParameter_Float openfl_Matrix;
+		 ::openfl::display::ShaderParameter_Bool openfl_HasColorTransform;
+		 ::openfl::display::ShaderParameter_Float openfl_TextureSize;
+		 ::openfl::display::ShaderInput_openfl_display_BitmapData openfl_Texture;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_DisplayObjectShader */ 

hGameTest/bin/linux/obj/include/openfl/display/FrameLabel.h

@@ -0,0 +1,59 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_FrameLabel
+#define INCLUDED_openfl_display_FrameLabel
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_EventDispatcher
+#include <openfl/events/EventDispatcher.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,FrameLabel)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES FrameLabel_obj : public  ::openfl::events::EventDispatcher_obj
+{
+	public:
+		typedef  ::openfl::events::EventDispatcher_obj super;
+		typedef FrameLabel_obj OBJ_;
+		FrameLabel_obj();
+
+	public:
+		enum { _hx_ClassId = 0x47dbd075 };
+
+		void __construct(::String name,int frame);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.FrameLabel")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.FrameLabel"); }
+		static hx::ObjectPtr< FrameLabel_obj > __new(::String name,int frame);
+		static hx::ObjectPtr< FrameLabel_obj > __alloc(hx::Ctx *_hx_ctx,::String name,int frame);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FrameLabel_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FrameLabel",a7,46,86,49); }
+
+		int frame;
+		::String name;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_FrameLabel */ 

hGameTest/bin/linux/obj/include/openfl/display/FrameScript.h

@@ -0,0 +1,63 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_FrameScript
+#define INCLUDED_openfl_display_FrameScript
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,FrameScript)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,MovieClip)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES FrameScript_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef FrameScript_obj OBJ_;
+		FrameScript_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4702ae06 };
+
+		void __construct( ::Dynamic script,int frame);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.FrameScript")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.FrameScript"); }
+		static hx::ObjectPtr< FrameScript_obj > __new( ::Dynamic script,int frame);
+		static hx::ObjectPtr< FrameScript_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic script,int frame);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FrameScript_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FrameScript",f8,b1,da,09); }
+
+		int frame;
+		 ::Dynamic script;
+		Dynamic script_dyn() { return script;}
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_FrameScript */ 

hGameTest/bin/linux/obj/include/openfl/display/Graphics.h

@@ -0,0 +1,210 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Graphics
+#define INCLUDED_openfl_display_Graphics
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS3(lime,graphics,cairo,Cairo)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(lime,utils,ObjectPool)
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+HX_DECLARE_CLASS2(openfl,_Vector,ObjectVector)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,Graphics)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DBuffer)
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
+HX_DECLARE_CLASS2(openfl,display3D,IndexBuffer3D)
+HX_DECLARE_CLASS2(openfl,display3D,VertexBuffer3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Graphics_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Graphics_obj OBJ_;
+		Graphics_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6b098f39 };
+
+		void __construct( ::openfl::display::DisplayObject owner);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Graphics")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Graphics"); }
+		static hx::ObjectPtr< Graphics_obj > __new( ::openfl::display::DisplayObject owner);
+		static hx::ObjectPtr< Graphics_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::DisplayObject owner);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Graphics_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Graphics",eb,b4,19,ec); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::Dynamic maxTextureHeight;
+		static  ::Dynamic maxTextureWidth;
+		 ::openfl::geom::Rectangle _hx___bounds;
+		 ::openfl::display::_internal::DrawCommandBuffer _hx___commands;
+		bool _hx___dirty;
+		bool _hx___hardwareDirty;
+		int _hx___height;
+		bool _hx___managed;
+		Float _hx___positionX;
+		Float _hx___positionY;
+		 ::openfl::display::_internal::Context3DBuffer _hx___quadBuffer;
+		 ::openfl::geom::Matrix _hx___renderTransform;
+		 ::lime::utils::ObjectPool _hx___shaderBufferPool;
+		bool _hx___softwareDirty;
+		Float _hx___strokePadding;
+		bool _hx___transformDirty;
+		 ::openfl::display3D::IndexBuffer3D _hx___triangleIndexBuffer;
+		int _hx___triangleIndexBufferCount;
+		 ::lime::utils::ArrayBufferView _hx___triangleIndexBufferData;
+		 ::haxe::ds::List _hx___usedShaderBuffers;
+		 ::openfl::display3D::VertexBuffer3D _hx___vertexBuffer;
+		int _hx___vertexBufferCount;
+		int _hx___vertexBufferCountUVT;
+		 ::lime::utils::ArrayBufferView _hx___vertexBufferData;
+		 ::lime::utils::ArrayBufferView _hx___vertexBufferDataUVT;
+		 ::openfl::display3D::VertexBuffer3D _hx___vertexBufferUVT;
+		bool _hx___visible;
+		 ::openfl::display::DisplayObject _hx___owner;
+		int _hx___width;
+		 ::openfl::geom::Matrix _hx___worldTransform;
+		 ::lime::graphics::cairo::Cairo _hx___cairo;
+		 ::openfl::display::BitmapData _hx___bitmap;
+		void beginBitmapFill( ::openfl::display::BitmapData bitmap, ::openfl::geom::Matrix matrix,hx::Null< bool >  repeat,hx::Null< bool >  smooth);
+		::Dynamic beginBitmapFill_dyn();
+
+		void beginFill(hx::Null< int >  color,hx::Null< Float >  alpha);
+		::Dynamic beginFill_dyn();
+
+		void beginGradientFill( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,hx::Null< Float >  focalPointRatio);
+		::Dynamic beginGradientFill_dyn();
+
+		void beginShaderFill( ::openfl::display::Shader shader, ::openfl::geom::Matrix matrix);
+		::Dynamic beginShaderFill_dyn();
+
+		void clear();
+		::Dynamic clear_dyn();
+
+		void copyFrom( ::openfl::display::Graphics sourceGraphics);
+		::Dynamic copyFrom_dyn();
+
+		void cubicCurveTo(Float controlX1,Float controlY1,Float controlX2,Float controlY2,Float anchorX,Float anchorY);
+		::Dynamic cubicCurveTo_dyn();
+
+		void curveTo(Float controlX,Float controlY,Float anchorX,Float anchorY);
+		::Dynamic curveTo_dyn();
+
+		void drawCircle(Float x,Float y,Float radius);
+		::Dynamic drawCircle_dyn();
+
+		void drawEllipse(Float x,Float y,Float width,Float height);
+		::Dynamic drawEllipse_dyn();
+
+		void drawGraphicsData( ::openfl::_Vector::ObjectVector graphicsData);
+		::Dynamic drawGraphicsData_dyn();
+
+		void drawPath( ::openfl::_Vector::IntVector commands, ::openfl::_Vector::FloatVector data, ::Dynamic winding);
+		::Dynamic drawPath_dyn();
+
+		void drawQuads( ::openfl::_Vector::FloatVector rects, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector transforms);
+		::Dynamic drawQuads_dyn();
+
+		void drawRect(Float x,Float y,Float width,Float height);
+		::Dynamic drawRect_dyn();
+
+		void drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth, ::Dynamic ellipseHeight);
+		::Dynamic drawRoundRect_dyn();
+
+		void drawRoundRectComplex(Float x,Float y,Float width,Float height,Float topLeftRadius,Float topRightRadius,Float bottomLeftRadius,Float bottomRightRadius);
+		::Dynamic drawRoundRectComplex_dyn();
+
+		void drawTriangles( ::openfl::_Vector::FloatVector vertices, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector uvtData, ::Dynamic culling);
+		::Dynamic drawTriangles_dyn();
+
+		void endFill();
+		::Dynamic endFill_dyn();
+
+		void lineBitmapStyle( ::openfl::display::BitmapData bitmap, ::openfl::geom::Matrix matrix,hx::Null< bool >  repeat,hx::Null< bool >  smooth);
+		::Dynamic lineBitmapStyle_dyn();
+
+		void lineGradientStyle( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,hx::Null< Float >  focalPointRatio);
+		::Dynamic lineGradientStyle_dyn();
+
+		void lineStyle( ::Dynamic thickness,hx::Null< int >  color,hx::Null< Float >  alpha,hx::Null< bool >  pixelHinting, ::Dynamic scaleMode, ::Dynamic caps, ::Dynamic joints,hx::Null< Float >  miterLimit);
+		::Dynamic lineStyle_dyn();
+
+		void lineTo(Float x,Float y);
+		::Dynamic lineTo_dyn();
+
+		void moveTo(Float x,Float y);
+		::Dynamic moveTo_dyn();
+
+		void overrideBlendMode( ::Dynamic blendMode);
+		::Dynamic overrideBlendMode_dyn();
+
+		 ::openfl::_Vector::ObjectVector readGraphicsData(hx::Null< bool >  recurse);
+		::Dynamic readGraphicsData_dyn();
+
+		Float _hx___calculateBezierCubicPoint(Float t,Float p1,Float p2,Float p3,Float p4);
+		::Dynamic _hx___calculateBezierCubicPoint_dyn();
+
+		Float _hx___calculateBezierQuadPoint(Float t,Float p1,Float p2,Float p3);
+		::Dynamic _hx___calculateBezierQuadPoint_dyn();
+
+		void _hx___cleanup();
+		::Dynamic _hx___cleanup_dyn();
+
+		void _hx___getBounds( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix);
+		::Dynamic _hx___getBounds_dyn();
+
+		bool _hx___hitTest(Float x,Float y,bool shapeFlag, ::openfl::geom::Matrix matrix);
+		::Dynamic _hx___hitTest_dyn();
+
+		void _hx___inflateBounds(Float x,Float y);
+		::Dynamic _hx___inflateBounds_dyn();
+
+		void _hx___readGraphicsData( ::openfl::_Vector::ObjectVector graphicsData);
+		::Dynamic _hx___readGraphicsData_dyn();
+
+		void _hx___update( ::openfl::geom::Matrix displayMatrix);
+		::Dynamic _hx___update_dyn();
+
+		bool set___dirty(bool value);
+		::Dynamic set___dirty_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Graphics */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsBitmapFill.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsBitmapFill
+#define INCLUDED_openfl_display_GraphicsBitmapFill
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsFill
+#include <openfl/display/IGraphicsFill.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,GraphicsBitmapFill)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsBitmapFill_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsBitmapFill_obj OBJ_;
+		GraphicsBitmapFill_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0b8262ab };
+
+		void __construct( ::openfl::display::BitmapData bitmapData, ::openfl::geom::Matrix matrix,hx::Null< bool >  __o_repeat,hx::Null< bool >  __o_smooth);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsBitmapFill")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsBitmapFill"); }
+		static hx::ObjectPtr< GraphicsBitmapFill_obj > __new( ::openfl::display::BitmapData bitmapData, ::openfl::geom::Matrix matrix,hx::Null< bool >  __o_repeat,hx::Null< bool >  __o_smooth);
+		static hx::ObjectPtr< GraphicsBitmapFill_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::BitmapData bitmapData, ::openfl::geom::Matrix matrix,hx::Null< bool >  __o_repeat,hx::Null< bool >  __o_smooth);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsBitmapFill_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsBitmapFill",dd,5a,b9,40); }
+
+		 ::openfl::display::BitmapData bitmapData;
+		 ::openfl::geom::Matrix matrix;
+		bool repeat;
+		bool smooth;
+		int _hx___graphicsDataType;
+		int _hx___graphicsFillType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsBitmapFill */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsEndFill.h

@@ -0,0 +1,61 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsEndFill
+#define INCLUDED_openfl_display_GraphicsEndFill
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsFill
+#include <openfl/display/IGraphicsFill.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,GraphicsEndFill)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsEndFill_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsEndFill_obj OBJ_;
+		GraphicsEndFill_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c375961 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display.GraphicsEndFill")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display.GraphicsEndFill"); }
+		static hx::ObjectPtr< GraphicsEndFill_obj > __new();
+		static hx::ObjectPtr< GraphicsEndFill_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsEndFill_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsEndFill",53,3e,c5,a5); }
+
+		int _hx___graphicsDataType;
+		int _hx___graphicsFillType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsEndFill */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsGradientFill.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsGradientFill
+#define INCLUDED_openfl_display_GraphicsGradientFill
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsFill
+#include <openfl/display/IGraphicsFill.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,GraphicsGradientFill)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsGradientFill_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsGradientFill_obj OBJ_;
+		GraphicsGradientFill_obj();
+
+	public:
+		enum { _hx_ClassId = 0x79383450 };
+
+		void __construct( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,hx::Null< Float >  __o_focalPointRatio);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsGradientFill")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsGradientFill"); }
+		static hx::ObjectPtr< GraphicsGradientFill_obj > __new( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,hx::Null< Float >  __o_focalPointRatio);
+		static hx::ObjectPtr< GraphicsGradientFill_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,hx::Null< Float >  __o_focalPointRatio);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsGradientFill_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsGradientFill",1e,22,2d,41); }
+
+		::Array< Float > alphas;
+		::Array< int > colors;
+		Float focalPointRatio;
+		 ::Dynamic interpolationMethod;
+		 ::openfl::geom::Matrix matrix;
+		::Array< int > ratios;
+		 ::Dynamic spreadMethod;
+		 ::Dynamic type;
+		int _hx___graphicsDataType;
+		int _hx___graphicsFillType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsGradientFill */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsPath.h

@@ -0,0 +1,101 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsPath
+#define INCLUDED_openfl_display_GraphicsPath
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsPath
+#include <openfl/display/IGraphicsPath.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+HX_DECLARE_CLASS2(openfl,display,GraphicsPath)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsPath)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsPath_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsPath_obj OBJ_;
+		GraphicsPath_obj();
+
+	public:
+		enum { _hx_ClassId = 0x572da862 };
+
+		void __construct( ::openfl::_Vector::IntVector commands, ::openfl::_Vector::FloatVector data, ::Dynamic __o_winding);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsPath")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsPath"); }
+		static hx::ObjectPtr< GraphicsPath_obj > __new( ::openfl::_Vector::IntVector commands, ::openfl::_Vector::FloatVector data, ::Dynamic __o_winding);
+		static hx::ObjectPtr< GraphicsPath_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::_Vector::IntVector commands, ::openfl::_Vector::FloatVector data, ::Dynamic __o_winding);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsPath_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsPath",30,18,59,11); }
+
+		static void __boot();
+		static Float SIN45;
+		static Float TAN22;
+		 ::openfl::_Vector::IntVector commands;
+		 ::openfl::_Vector::FloatVector data;
+		 ::Dynamic winding;
+		int _hx___graphicsDataType;
+		void cubicCurveTo(Float controlX1,Float controlY1,Float controlX2,Float controlY2,Float anchorX,Float anchorY);
+		::Dynamic cubicCurveTo_dyn();
+
+		void curveTo(Float controlX,Float controlY,Float anchorX,Float anchorY);
+		::Dynamic curveTo_dyn();
+
+		void lineTo(Float x,Float y);
+		::Dynamic lineTo_dyn();
+
+		void moveTo(Float x,Float y);
+		::Dynamic moveTo_dyn();
+
+		void wideLineTo(Float x,Float y);
+		::Dynamic wideLineTo_dyn();
+
+		void wideMoveTo(Float x,Float y);
+		::Dynamic wideMoveTo_dyn();
+
+		void _hx___drawCircle(Float x,Float y,Float radius);
+		::Dynamic _hx___drawCircle_dyn();
+
+		void _hx___drawEllipse(Float x,Float y,Float width,Float height);
+		::Dynamic _hx___drawEllipse_dyn();
+
+		void _hx___drawRect(Float x,Float y,Float width,Float height);
+		::Dynamic _hx___drawRect_dyn();
+
+		void _hx___drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth,Float ellipseHeight);
+		::Dynamic _hx___drawRoundRect_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsPath */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsQuadPath.h

@@ -0,0 +1,68 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsQuadPath
+#define INCLUDED_openfl_display_GraphicsQuadPath
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsPath
+#include <openfl/display/IGraphicsPath.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+HX_DECLARE_CLASS2(openfl,display,GraphicsQuadPath)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsPath)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsQuadPath_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsQuadPath_obj OBJ_;
+		GraphicsQuadPath_obj();
+
+	public:
+		enum { _hx_ClassId = 0x780f1f49 };
+
+		void __construct( ::openfl::_Vector::FloatVector rects, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector transforms);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsQuadPath")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsQuadPath"); }
+		static hx::ObjectPtr< GraphicsQuadPath_obj > __new( ::openfl::_Vector::FloatVector rects, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector transforms);
+		static hx::ObjectPtr< GraphicsQuadPath_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::_Vector::FloatVector rects, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector transforms);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsQuadPath_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsQuadPath",17,8e,a9,3a); }
+
+		 ::openfl::_Vector::IntVector indices;
+		 ::openfl::_Vector::FloatVector rects;
+		 ::openfl::_Vector::FloatVector transforms;
+		int _hx___graphicsDataType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsQuadPath */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsShader.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsShader
+#define INCLUDED_openfl_display_GraphicsShader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_Shader
+#include <openfl/display/Shader.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(openfl,display,GraphicsShader)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS2(openfl,display,ShaderInput_openfl_display_BitmapData)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Bool)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Float)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsShader_obj : public  ::openfl::display::Shader_obj
+{
+	public:
+		typedef  ::openfl::display::Shader_obj super;
+		typedef GraphicsShader_obj OBJ_;
+		GraphicsShader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f21db8e };
+
+		void __construct( ::openfl::utils::ByteArrayData code);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsShader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsShader"); }
+		static hx::ObjectPtr< GraphicsShader_obj > __new( ::openfl::utils::ByteArrayData code);
+		static hx::ObjectPtr< GraphicsShader_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::utils::ByteArrayData code);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsShader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("GraphicsShader",70,ea,41,1a); }
+
+		 ::openfl::display::ShaderParameter_Float openfl_Alpha;
+		 ::openfl::display::ShaderParameter_Float openfl_ColorMultiplier;
+		 ::openfl::display::ShaderParameter_Float openfl_ColorOffset;
+		 ::openfl::display::ShaderParameter_Float openfl_Position;
+		 ::openfl::display::ShaderParameter_Float openfl_TextureCoord;
+		 ::openfl::display::ShaderParameter_Float openfl_Matrix;
+		 ::openfl::display::ShaderParameter_Bool openfl_HasColorTransform;
+		 ::openfl::display::ShaderParameter_Float openfl_TextureSize;
+		 ::openfl::display::ShaderInput_openfl_display_BitmapData bitmap;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsShader */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsShaderFill.h

@@ -0,0 +1,67 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsShaderFill
+#define INCLUDED_openfl_display_GraphicsShaderFill
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsFill
+#include <openfl/display/IGraphicsFill.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,GraphicsShaderFill)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsShaderFill_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsShaderFill_obj OBJ_;
+		GraphicsShaderFill_obj();
+
+	public:
+		enum { _hx_ClassId = 0x08bde4e1 };
+
+		void __construct( ::openfl::display::Shader shader, ::openfl::geom::Matrix matrix);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsShaderFill")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsShaderFill"); }
+		static hx::ObjectPtr< GraphicsShaderFill_obj > __new( ::openfl::display::Shader shader, ::openfl::geom::Matrix matrix);
+		static hx::ObjectPtr< GraphicsShaderFill_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::Shader shader, ::openfl::geom::Matrix matrix);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsShaderFill_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsShaderFill",13,dd,f4,3d); }
+
+		 ::openfl::geom::Matrix matrix;
+		 ::openfl::display::Shader shader;
+		int _hx___graphicsDataType;
+		int _hx___graphicsFillType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsShaderFill */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsSolidFill.h

@@ -0,0 +1,63 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsSolidFill
+#define INCLUDED_openfl_display_GraphicsSolidFill
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsFill
+#include <openfl/display/IGraphicsFill.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,GraphicsSolidFill)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsSolidFill_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsSolidFill_obj OBJ_;
+		GraphicsSolidFill_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1f37d071 };
+
+		void __construct(hx::Null< int >  __o_color,hx::Null< Float >  __o_alpha);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display.GraphicsSolidFill")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display.GraphicsSolidFill"); }
+		static hx::ObjectPtr< GraphicsSolidFill_obj > __new(hx::Null< int >  __o_color,hx::Null< Float >  __o_alpha);
+		static hx::ObjectPtr< GraphicsSolidFill_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_color,hx::Null< Float >  __o_alpha);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsSolidFill_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsSolidFill",e3,55,be,a3); }
+
+		Float alpha;
+		int color;
+		int _hx___graphicsDataType;
+		int _hx___graphicsFillType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsSolidFill */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsStroke.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsStroke
+#define INCLUDED_openfl_display_GraphicsStroke
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsStroke
+#include <openfl/display/IGraphicsStroke.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,GraphicsStroke)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsStroke)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsStroke_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsStroke_obj OBJ_;
+		GraphicsStroke_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7fc28725 };
+
+		void __construct( ::Dynamic thickness,hx::Null< bool >  __o_pixelHinting, ::Dynamic __o_scaleMode, ::Dynamic __o_caps, ::Dynamic __o_joints,hx::Null< Float >  __o_miterLimit,::Dynamic fill);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsStroke")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsStroke"); }
+		static hx::ObjectPtr< GraphicsStroke_obj > __new( ::Dynamic thickness,hx::Null< bool >  __o_pixelHinting, ::Dynamic __o_scaleMode, ::Dynamic __o_caps, ::Dynamic __o_joints,hx::Null< Float >  __o_miterLimit,::Dynamic fill);
+		static hx::ObjectPtr< GraphicsStroke_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic thickness,hx::Null< bool >  __o_pixelHinting, ::Dynamic __o_scaleMode, ::Dynamic __o_caps, ::Dynamic __o_joints,hx::Null< Float >  __o_miterLimit,::Dynamic fill);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsStroke_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsStroke",03,df,55,0e); }
+
+		 ::Dynamic caps;
+		::Dynamic fill;
+		 ::Dynamic joints;
+		Float miterLimit;
+		bool pixelHinting;
+		 ::Dynamic scaleMode;
+		Float thickness;
+		int _hx___graphicsDataType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsStroke */ 

hGameTest/bin/linux/obj/include/openfl/display/GraphicsTrianglePath.h

@@ -0,0 +1,69 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_GraphicsTrianglePath
+#define INCLUDED_openfl_display_GraphicsTrianglePath
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_IGraphicsPath
+#include <openfl/display/IGraphicsPath.h>
+#endif
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#include <openfl/display/IGraphicsData.h>
+#endif
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+HX_DECLARE_CLASS2(openfl,display,GraphicsTrianglePath)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+HX_DECLARE_CLASS2(openfl,display,IGraphicsPath)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsTrianglePath_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsTrianglePath_obj OBJ_;
+		GraphicsTrianglePath_obj();
+
+	public:
+		enum { _hx_ClassId = 0x61741c4a };
+
+		void __construct( ::openfl::_Vector::FloatVector vertices, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector uvtData, ::Dynamic __o_culling);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsTrianglePath")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsTrianglePath"); }
+		static hx::ObjectPtr< GraphicsTrianglePath_obj > __new( ::openfl::_Vector::FloatVector vertices, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector uvtData, ::Dynamic __o_culling);
+		static hx::ObjectPtr< GraphicsTrianglePath_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::_Vector::FloatVector vertices, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector uvtData, ::Dynamic __o_culling);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsTrianglePath_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("GraphicsTrianglePath",18,0a,69,29); }
+
+		 ::Dynamic culling;
+		 ::openfl::_Vector::IntVector indices;
+		 ::openfl::_Vector::FloatVector uvtData;
+		 ::openfl::_Vector::FloatVector vertices;
+		int _hx___graphicsDataType;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_GraphicsTrianglePath */ 

hGameTest/bin/linux/obj/include/openfl/display/IBitmapDrawable.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_IBitmapDrawable
+#define INCLUDED_openfl_display_IBitmapDrawable
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES IBitmapDrawable_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (hx::Object :: *_hx__hx___getBounds)( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix); 
+		static inline void _hx___getBounds( ::Dynamic _hx_, ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix matrix) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___getBounds)(rect,matrix);
+		}
+		void (hx::Object :: *_hx__hx___renderCairo)( ::openfl::display::CairoRenderer renderer); 
+		static inline void _hx___renderCairo( ::Dynamic _hx_, ::openfl::display::CairoRenderer renderer) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___renderCairo)(renderer);
+		}
+		void (hx::Object :: *_hx__hx___renderCairoMask)( ::openfl::display::CairoRenderer renderer); 
+		static inline void _hx___renderCairoMask( ::Dynamic _hx_, ::openfl::display::CairoRenderer renderer) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___renderCairoMask)(renderer);
+		}
+		void (hx::Object :: *_hx__hx___renderCanvas)( ::openfl::display::CanvasRenderer renderer); 
+		static inline void _hx___renderCanvas( ::Dynamic _hx_, ::openfl::display::CanvasRenderer renderer) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___renderCanvas)(renderer);
+		}
+		void (hx::Object :: *_hx__hx___renderCanvasMask)( ::openfl::display::CanvasRenderer renderer); 
+		static inline void _hx___renderCanvasMask( ::Dynamic _hx_, ::openfl::display::CanvasRenderer renderer) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___renderCanvasMask)(renderer);
+		}
+		void (hx::Object :: *_hx__hx___renderDOM)( ::openfl::display::DOMRenderer renderer); 
+		static inline void _hx___renderDOM( ::Dynamic _hx_, ::openfl::display::DOMRenderer renderer) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___renderDOM)(renderer);
+		}
+		void (hx::Object :: *_hx__hx___renderGL)( ::openfl::display::OpenGLRenderer renderer); 
+		static inline void _hx___renderGL( ::Dynamic _hx_, ::openfl::display::OpenGLRenderer renderer) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___renderGL)(renderer);
+		}
+		void (hx::Object :: *_hx__hx___renderGLMask)( ::openfl::display::OpenGLRenderer renderer); 
+		static inline void _hx___renderGLMask( ::Dynamic _hx_, ::openfl::display::OpenGLRenderer renderer) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___renderGLMask)(renderer);
+		}
+		void (hx::Object :: *_hx__hx___update)(bool transformOnly,bool updateChildren); 
+		static inline void _hx___update( ::Dynamic _hx_,bool transformOnly,bool updateChildren) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___update)(transformOnly,updateChildren);
+		}
+		void (hx::Object :: *_hx__hx___updateTransforms)( ::openfl::geom::Matrix overrideTransform); 
+		static inline void _hx___updateTransforms( ::Dynamic _hx_, ::openfl::geom::Matrix overrideTransform) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::display::IBitmapDrawable_obj *>(_hx_.mPtr->_hx_getInterface(0xc1c6fbe4)))->_hx__hx___updateTransforms)(overrideTransform);
+		}
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_IBitmapDrawable */ 

hGameTest/bin/linux/obj/include/openfl/display/IGraphicsData.h

@@ -0,0 +1,25 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_IGraphicsData
+#define INCLUDED_openfl_display_IGraphicsData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES IGraphicsData_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_IGraphicsData */ 

hGameTest/bin/linux/obj/include/openfl/display/IGraphicsFill.h

@@ -0,0 +1,25 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_IGraphicsFill
+#define INCLUDED_openfl_display_IGraphicsFill
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES IGraphicsFill_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_IGraphicsFill */ 

hGameTest/bin/linux/obj/include/openfl/display/IGraphicsPath.h

@@ -0,0 +1,25 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_IGraphicsPath
+#define INCLUDED_openfl_display_IGraphicsPath
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,IGraphicsPath)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES IGraphicsPath_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_IGraphicsPath */ 

hGameTest/bin/linux/obj/include/openfl/display/IGraphicsStroke.h

@@ -0,0 +1,25 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_IGraphicsStroke
+#define INCLUDED_openfl_display_IGraphicsStroke
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,IGraphicsStroke)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES IGraphicsStroke_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_IGraphicsStroke */ 

hGameTest/bin/linux/obj/include/openfl/display/InteractiveObject.h

@@ -0,0 +1,92 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_InteractiveObject
+#define INCLUDED_openfl_display_InteractiveObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObject
+#include <openfl/display/DisplayObject.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES InteractiveObject_obj : public  ::openfl::display::DisplayObject_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObject_obj super;
+		typedef InteractiveObject_obj OBJ_;
+		InteractiveObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3f2b00af };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.InteractiveObject")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.InteractiveObject"); }
+		static hx::ObjectPtr< InteractiveObject_obj > __new();
+		static hx::ObjectPtr< InteractiveObject_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~InteractiveObject_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("InteractiveObject",21,86,b1,c3); }
+
+		bool doubleClickEnabled;
+		 ::Dynamic focusRect;
+		bool mouseEnabled;
+		bool needsSoftKeyboard;
+		 ::openfl::geom::Rectangle softKeyboardInputAreaOfInterest;
+		 ::Dynamic _hx___tabEnabled;
+		int _hx___tabIndex;
+		bool requestSoftKeyboard();
+		::Dynamic requestSoftKeyboard_dyn();
+
+		bool _hx___allowMouseFocus();
+		::Dynamic _hx___allowMouseFocus_dyn();
+
+		virtual bool _hx___getInteractive(::Array< ::Dynamic> stack);
+
+		virtual bool _hx___hitTest(Float x,Float y,bool shapeFlag,::Array< ::Dynamic> stack,bool interactiveOnly, ::openfl::display::DisplayObject hitObject);
+
+		virtual void _hx___tabTest(::Array< ::Dynamic> stack);
+		::Dynamic _hx___tabTest_dyn();
+
+		virtual bool get_tabEnabled();
+		::Dynamic get_tabEnabled_dyn();
+
+		virtual bool set_tabEnabled(bool value);
+		::Dynamic set_tabEnabled_dyn();
+
+		virtual int get_tabIndex();
+		::Dynamic get_tabIndex_dyn();
+
+		virtual int set_tabIndex(int value);
+		::Dynamic set_tabIndex_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_InteractiveObject */ 

hGameTest/bin/linux/obj/include/openfl/display/JPEGEncoderOptions.h

@@ -0,0 +1,69 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_JPEGEncoderOptions
+#define INCLUDED_openfl_display_JPEGEncoderOptions
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_05e3536633e8ac7b_14_new)
+HX_DECLARE_CLASS2(openfl,display,JPEGEncoderOptions)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES JPEGEncoderOptions_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JPEGEncoderOptions_obj OBJ_;
+		JPEGEncoderOptions_obj();
+
+	public:
+		enum { _hx_ClassId = 0x08ab8b9c };
+
+		void __construct(hx::Null< int >  __o_quality);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display.JPEGEncoderOptions")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display.JPEGEncoderOptions"); }
+
+		inline static hx::ObjectPtr< JPEGEncoderOptions_obj > __new(hx::Null< int >  __o_quality) {
+			hx::ObjectPtr< JPEGEncoderOptions_obj > __this = new JPEGEncoderOptions_obj();
+			__this->__construct(__o_quality);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< JPEGEncoderOptions_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_quality) {
+			JPEGEncoderOptions_obj *__this = (JPEGEncoderOptions_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(JPEGEncoderOptions_obj), false, "openfl.display.JPEGEncoderOptions"));
+			*(void **)__this = JPEGEncoderOptions_obj::_hx_vtable;
+{
+            		int quality = __o_quality.Default(80);
+            	HX_STACKFRAME(&_hx_pos_05e3536633e8ac7b_14_new)
+HXDLIN(  14)		( ( ::openfl::display::JPEGEncoderOptions)(__this) )->quality = quality;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JPEGEncoderOptions_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JPEGEncoderOptions",ea,c9,d9,79); }
+
+		int quality;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_JPEGEncoderOptions */ 

hGameTest/bin/linux/obj/include/openfl/display/Loader.h

@@ -0,0 +1,124 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Loader
+#define INCLUDED_openfl_display_Loader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObjectContainer
+#include <openfl/display/DisplayObjectContainer.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,AssetLibrary)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Loader)
+HX_DECLARE_CLASS2(openfl,display,LoaderInfo)
+HX_DECLARE_CLASS2(openfl,events,ErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IOErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,ProgressEvent)
+HX_DECLARE_CLASS2(openfl,events,TextEvent)
+HX_DECLARE_CLASS2(openfl,events,UncaughtErrorEvents)
+HX_DECLARE_CLASS2(openfl,net,URLRequest)
+HX_DECLARE_CLASS2(openfl,_hx_system,LoaderContext)
+HX_DECLARE_CLASS2(openfl,utils,AssetLibrary)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Loader_obj : public  ::openfl::display::DisplayObjectContainer_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObjectContainer_obj super;
+		typedef Loader_obj OBJ_;
+		Loader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3248531d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Loader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Loader"); }
+		static hx::ObjectPtr< Loader_obj > __new();
+		static hx::ObjectPtr< Loader_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Loader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Loader",33,bc,03,8d); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::openfl::display::DisplayObject content;
+		 ::openfl::display::LoaderInfo contentLoaderInfo;
+		 ::openfl::events::UncaughtErrorEvents uncaughtErrorEvents;
+		 ::openfl::utils::AssetLibrary _hx___library;
+		::String _hx___path;
+		bool _hx___unloaded;
+		void close();
+		::Dynamic close_dyn();
+
+		void load( ::openfl::net::URLRequest request, ::openfl::_hx_system::LoaderContext context);
+		::Dynamic load_dyn();
+
+		void loadBytes( ::openfl::utils::ByteArrayData buffer, ::openfl::_hx_system::LoaderContext context);
+		::Dynamic loadBytes_dyn();
+
+		void unload();
+		::Dynamic unload_dyn();
+
+		void unloadAndStop(hx::Null< bool >  gc);
+		::Dynamic unloadAndStop_dyn();
+
+		void _hx___dispatchError(::String text);
+		::Dynamic _hx___dispatchError_dyn();
+
+		void _hx___setContent( ::openfl::display::DisplayObject content,int width,int height);
+		::Dynamic _hx___setContent_dyn();
+
+		void BitmapData_onError( ::Dynamic error);
+		::Dynamic BitmapData_onError_dyn();
+
+		void BitmapData_onLoad( ::openfl::display::BitmapData bitmapData);
+		::Dynamic BitmapData_onLoad_dyn();
+
+		void BitmapData_onProgress(int bytesLoaded,int bytesTotal);
+		::Dynamic BitmapData_onProgress_dyn();
+
+		void loader_onComplete( ::openfl::events::Event event);
+		::Dynamic loader_onComplete_dyn();
+
+		void loader_onError( ::openfl::events::IOErrorEvent event);
+		::Dynamic loader_onError_dyn();
+
+		void loader_onProgress( ::openfl::events::ProgressEvent event);
+		::Dynamic loader_onProgress_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Loader */ 

hGameTest/bin/linux/obj/include/openfl/display/LoaderInfo.h

@@ -0,0 +1,101 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_LoaderInfo
+#define INCLUDED_openfl_display_LoaderInfo
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_EventDispatcher
+#include <openfl/events/EventDispatcher.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Loader)
+HX_DECLARE_CLASS2(openfl,display,LoaderInfo)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,UncaughtErrorEvents)
+HX_DECLARE_CLASS2(openfl,_hx_system,ApplicationDomain)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES LoaderInfo_obj : public  ::openfl::events::EventDispatcher_obj
+{
+	public:
+		typedef  ::openfl::events::EventDispatcher_obj super;
+		typedef LoaderInfo_obj OBJ_;
+		LoaderInfo_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3c3575f3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.LoaderInfo")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.LoaderInfo"); }
+		static hx::ObjectPtr< LoaderInfo_obj > __new();
+		static hx::ObjectPtr< LoaderInfo_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~LoaderInfo_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("LoaderInfo",41,b6,95,ad); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static ::String _hx___rootURL;
+		static  ::openfl::display::LoaderInfo create( ::openfl::display::Loader loader);
+		static ::Dynamic create_dyn();
+
+		 ::openfl::_hx_system::ApplicationDomain applicationDomain;
+		 ::openfl::utils::ByteArrayData bytes;
+		int bytesLoaded;
+		int bytesTotal;
+		bool childAllowsParent;
+		 ::openfl::display::DisplayObject content;
+		::String contentType;
+		Float frameRate;
+		int height;
+		 ::openfl::display::Loader loader;
+		::String loaderURL;
+		 ::Dynamic parameters;
+		bool parentAllowsChild;
+		bool sameDomain;
+		 ::openfl::events::EventDispatcher sharedEvents;
+		 ::openfl::events::UncaughtErrorEvents uncaughtErrorEvents;
+		::String url;
+		int width;
+		bool _hx___completed;
+		void _hx___complete();
+		::Dynamic _hx___complete_dyn();
+
+		void _hx___update(int bytesLoaded,int bytesTotal);
+		::Dynamic _hx___update_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_LoaderInfo */ 

hGameTest/bin/linux/obj/include/openfl/display/MovieClip.h

@@ -0,0 +1,164 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_MovieClip
+#define INCLUDED_openfl_display_MovieClip
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_Sprite
+#include <openfl/display/Sprite.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,FrameLabel)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,MovieClip)
+HX_DECLARE_CLASS2(openfl,display,Scene)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,display,Timeline)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,MouseEvent)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES MovieClip_obj : public  ::openfl::display::Sprite_obj
+{
+	public:
+		typedef  ::openfl::display::Sprite_obj super;
+		typedef MovieClip_obj OBJ_;
+		MovieClip_obj();
+
+	public:
+		enum { _hx_ClassId = 0x21e31f0e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.MovieClip")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.MovieClip"); }
+		static hx::ObjectPtr< MovieClip_obj > __new();
+		static hx::ObjectPtr< MovieClip_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~MovieClip_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MovieClip",80,e2,ed,b9); }
+
+		static  ::Dynamic _hx___constructor;
+		static Dynamic _hx___constructor_dyn() { return _hx___constructor;}
+		static  ::openfl::display::MovieClip fromTimeline( ::openfl::display::Timeline timeline);
+		static ::Dynamic fromTimeline_dyn();
+
+		bool _hx___enabled;
+		bool _hx___hasDown;
+		bool _hx___hasOver;
+		bool _hx___hasUp;
+		bool _hx___mouseIsDown;
+		 ::openfl::display::Scene _hx___scene;
+		 ::openfl::display::Timeline _hx___timeline;
+		void addFrameScript(int index, ::Dynamic method);
+		::Dynamic addFrameScript_dyn();
+
+		void attachTimeline( ::openfl::display::Timeline timeline);
+		::Dynamic attachTimeline_dyn();
+
+		void gotoAndPlay( ::Dynamic frame,::String scene);
+		::Dynamic gotoAndPlay_dyn();
+
+		void gotoAndStop( ::Dynamic frame,::String scene);
+		::Dynamic gotoAndStop_dyn();
+
+		void nextFrame();
+		::Dynamic nextFrame_dyn();
+
+		void nextScene();
+		::Dynamic nextScene_dyn();
+
+		void play();
+		::Dynamic play_dyn();
+
+		void prevFrame();
+		::Dynamic prevFrame_dyn();
+
+		void prevScene();
+		::Dynamic prevScene_dyn();
+
+		void stop();
+		::Dynamic stop_dyn();
+
+		void _hx___enterFrame(int deltaTime);
+
+		void _hx___stopAllMovieClips();
+
+		void _hx___tabTest(::Array< ::Dynamic> stack);
+
+		void _hx___onMouseDown( ::openfl::events::MouseEvent event);
+		::Dynamic _hx___onMouseDown_dyn();
+
+		void _hx___onMouseUp( ::openfl::events::MouseEvent event);
+		::Dynamic _hx___onMouseUp_dyn();
+
+		void _hx___onRollOut( ::openfl::events::MouseEvent event);
+		::Dynamic _hx___onRollOut_dyn();
+
+		void _hx___onRollOver( ::openfl::events::MouseEvent event);
+		::Dynamic _hx___onRollOver_dyn();
+
+		bool set_buttonMode(bool value);
+
+		int get_currentFrame();
+		::Dynamic get_currentFrame_dyn();
+
+		::String get_currentFrameLabel();
+		::Dynamic get_currentFrameLabel_dyn();
+
+		::String get_currentLabel();
+		::Dynamic get_currentLabel_dyn();
+
+		::Array< ::Dynamic> get_currentLabels();
+		::Dynamic get_currentLabels_dyn();
+
+		 ::openfl::display::Scene get_currentScene();
+		::Dynamic get_currentScene_dyn();
+
+		bool get_enabled();
+		::Dynamic get_enabled_dyn();
+
+		bool set_enabled(bool value);
+		::Dynamic set_enabled_dyn();
+
+		int get_framesLoaded();
+		::Dynamic get_framesLoaded_dyn();
+
+		bool get_isPlaying();
+		::Dynamic get_isPlaying_dyn();
+
+		::Array< ::Dynamic> get_scenes();
+		::Dynamic get_scenes_dyn();
+
+		int get_totalFrames();
+		::Dynamic get_totalFrames_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_MovieClip */ 

hGameTest/bin/linux/obj/include/openfl/display/OpenGLRenderer.h

@@ -0,0 +1,217 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_OpenGLRenderer
+#define INCLUDED_openfl_display_OpenGLRenderer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObjectRenderer
+#include <openfl/display/DisplayObjectRenderer.h>
+#endif
+HX_DECLARE_CLASS4(lime,_internal,backend,native,NativeOpenGLRenderContext)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(lime,utils,ObjectPool)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectShader)
+HX_DECLARE_CLASS2(openfl,display,GraphicsShader)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DMaskShader)
+HX_DECLARE_CLASS3(openfl,display,_internal,ShaderBuffer)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES OpenGLRenderer_obj : public  ::openfl::display::DisplayObjectRenderer_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObjectRenderer_obj super;
+		typedef OpenGLRenderer_obj OBJ_;
+		OpenGLRenderer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x38ea65a4 };
+
+		void __construct( ::openfl::display3D::Context3D context, ::openfl::display::BitmapData defaultRenderTarget);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.OpenGLRenderer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.OpenGLRenderer"); }
+		static hx::ObjectPtr< OpenGLRenderer_obj > __new( ::openfl::display3D::Context3D context, ::openfl::display::BitmapData defaultRenderTarget);
+		static hx::ObjectPtr< OpenGLRenderer_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display3D::Context3D context, ::openfl::display::BitmapData defaultRenderTarget);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~OpenGLRenderer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("OpenGLRenderer",f2,e4,ab,68); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static ::Array< Float > _hx___alphaValue;
+		static ::Array< Float > _hx___colorMultipliersValue;
+		static ::Array< Float > _hx___colorOffsetsValue;
+		static ::Array< Float > _hx___defaultColorMultipliersValue;
+		static ::Array< Float > _hx___emptyColorValue;
+		static ::Array< Float > _hx___emptyAlphaValue;
+		static ::Array< bool > _hx___hasColorTransformValue;
+		static  ::openfl::geom::Rectangle _hx___scissorRectangle;
+		static ::Array< Float > _hx___textureSizeValue;
+		 ::lime::_internal::backend::native::NativeOpenGLRenderContext gl;
+		 ::openfl::display3D::Context3D _hx___context3D;
+		::Array< ::Dynamic> _hx___clipRects;
+		 ::openfl::display::Shader _hx___currentDisplayShader;
+		 ::openfl::display::Shader _hx___currentGraphicsShader;
+		 ::openfl::display::BitmapData _hx___currentRenderTarget;
+		 ::openfl::display::Shader _hx___currentShader;
+		 ::openfl::display::_internal::ShaderBuffer _hx___currentShaderBuffer;
+		 ::openfl::display::DisplayObjectShader _hx___defaultDisplayShader;
+		 ::openfl::display::GraphicsShader _hx___defaultGraphicsShader;
+		 ::openfl::display::BitmapData _hx___defaultRenderTarget;
+		 ::openfl::display::Shader _hx___defaultShader;
+		int _hx___displayHeight;
+		int _hx___displayWidth;
+		bool _hx___flipped;
+		 ::lime::_internal::backend::native::NativeOpenGLRenderContext _hx___gl;
+		int _hx___height;
+		 ::openfl::display::_internal::Context3DMaskShader _hx___maskShader;
+		 ::lime::utils::ArrayBufferView _hx___matrix;
+		::Array< ::Dynamic> _hx___maskObjects;
+		int _hx___numClipRects;
+		int _hx___offsetX;
+		int _hx___offsetY;
+		 ::lime::utils::ArrayBufferView _hx___projection;
+		 ::lime::utils::ArrayBufferView _hx___projectionFlipped;
+		 ::lime::utils::ObjectPool _hx___scrollRectMasks;
+		 ::openfl::display::DisplayObjectRenderer _hx___softwareRenderer;
+		int _hx___stencilReference;
+		 ::openfl::geom::Rectangle _hx___tempRect;
+		bool _hx___updatedStencil;
+		bool _hx___upscaled;
+		::Array< Float > _hx___values;
+		int _hx___width;
+		void applyAlpha(Float alpha);
+		::Dynamic applyAlpha_dyn();
+
+		void applyBitmapData( ::openfl::display::BitmapData bitmapData,bool smooth,hx::Null< bool >  repeat);
+		::Dynamic applyBitmapData_dyn();
+
+		void applyColorTransform( ::openfl::geom::ColorTransform colorTransform);
+		::Dynamic applyColorTransform_dyn();
+
+		void applyHasColorTransform(bool enabled);
+		::Dynamic applyHasColorTransform_dyn();
+
+		void applyMatrix(::Array< Float > matrix);
+		::Dynamic applyMatrix_dyn();
+
+		 ::lime::utils::ArrayBufferView getMatrix( ::openfl::geom::Matrix transform);
+		::Dynamic getMatrix_dyn();
+
+		void setShader( ::openfl::display::Shader shader);
+		::Dynamic setShader_dyn();
+
+		void setViewport();
+		::Dynamic setViewport_dyn();
+
+		void updateShader();
+		::Dynamic updateShader_dyn();
+
+		void useAlphaArray();
+		::Dynamic useAlphaArray_dyn();
+
+		void useColorTransformArray();
+		::Dynamic useColorTransformArray_dyn();
+
+		void _hx___cleanup();
+		::Dynamic _hx___cleanup_dyn();
+
+		void _hx___clear();
+
+		void _hx___clearShader();
+		::Dynamic _hx___clearShader_dyn();
+
+		void _hx___copyShader( ::openfl::display::OpenGLRenderer other);
+		::Dynamic _hx___copyShader_dyn();
+
+		::Array< Float > _hx___getMatrix( ::openfl::geom::Matrix transform, ::Dynamic pixelSnapping);
+		::Dynamic _hx___getMatrix_dyn();
+
+		 ::openfl::display::Shader _hx___initShader( ::openfl::display::Shader shader);
+		::Dynamic _hx___initShader_dyn();
+
+		 ::openfl::display::Shader _hx___initDisplayShader( ::openfl::display::Shader shader);
+		::Dynamic _hx___initDisplayShader_dyn();
+
+		 ::openfl::display::Shader _hx___initGraphicsShader( ::openfl::display::Shader shader);
+		::Dynamic _hx___initGraphicsShader_dyn();
+
+		 ::openfl::display::Shader _hx___initShaderBuffer( ::openfl::display::_internal::ShaderBuffer shaderBuffer);
+		::Dynamic _hx___initShaderBuffer_dyn();
+
+		void _hx___popMask();
+
+		void _hx___popMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___popMaskRect();
+
+		void _hx___pushMask( ::openfl::display::DisplayObject mask);
+
+		void _hx___pushMaskObject( ::openfl::display::DisplayObject object,hx::Null< bool >  handleScrollRect);
+
+		void _hx___pushMaskRect( ::openfl::geom::Rectangle rect, ::openfl::geom::Matrix transform);
+
+		void _hx___render(::Dynamic object);
+
+		void _hx___renderFilterPass( ::openfl::display::BitmapData source, ::openfl::display::Shader shader,bool smooth,hx::Null< bool >  clear);
+		::Dynamic _hx___renderFilterPass_dyn();
+
+		void _hx___resize(int width,int height);
+
+		void _hx___resumeClipAndMask( ::openfl::display::OpenGLRenderer childRenderer);
+		::Dynamic _hx___resumeClipAndMask_dyn();
+
+		void _hx___scissorRect( ::openfl::geom::Rectangle clipRect);
+		::Dynamic _hx___scissorRect_dyn();
+
+		void _hx___setBlendMode( ::Dynamic value);
+
+		void _hx___setRenderTarget( ::openfl::display::BitmapData renderTarget);
+		::Dynamic _hx___setRenderTarget_dyn();
+
+		void _hx___setShaderBuffer( ::openfl::display::_internal::ShaderBuffer shaderBuffer);
+		::Dynamic _hx___setShaderBuffer_dyn();
+
+		void _hx___suspendClipAndMask();
+		::Dynamic _hx___suspendClipAndMask_dyn();
+
+		void _hx___updateShaderBuffer(int bufferOffset);
+		::Dynamic _hx___updateShaderBuffer_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_OpenGLRenderer */ 

hGameTest/bin/linux/obj/include/openfl/display/PNGEncoderOptions.h

@@ -0,0 +1,69 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_PNGEncoderOptions
+#define INCLUDED_openfl_display_PNGEncoderOptions
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_3a64445735a88117_14_new)
+HX_DECLARE_CLASS2(openfl,display,PNGEncoderOptions)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES PNGEncoderOptions_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef PNGEncoderOptions_obj OBJ_;
+		PNGEncoderOptions_obj();
+
+	public:
+		enum { _hx_ClassId = 0x06198ce1 };
+
+		void __construct(hx::Null< bool >  __o_fastCompression);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display.PNGEncoderOptions")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display.PNGEncoderOptions"); }
+
+		inline static hx::ObjectPtr< PNGEncoderOptions_obj > __new(hx::Null< bool >  __o_fastCompression) {
+			hx::ObjectPtr< PNGEncoderOptions_obj > __this = new PNGEncoderOptions_obj();
+			__this->__construct(__o_fastCompression);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< PNGEncoderOptions_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< bool >  __o_fastCompression) {
+			PNGEncoderOptions_obj *__this = (PNGEncoderOptions_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(PNGEncoderOptions_obj), false, "openfl.display.PNGEncoderOptions"));
+			*(void **)__this = PNGEncoderOptions_obj::_hx_vtable;
+{
+            		bool fastCompression = __o_fastCompression.Default(false);
+            	HX_STACKFRAME(&_hx_pos_3a64445735a88117_14_new)
+HXDLIN(  14)		( ( ::openfl::display::PNGEncoderOptions)(__this) )->fastCompression = fastCompression;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~PNGEncoderOptions_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PNGEncoderOptions",8b,2f,a8,29); }
+
+		bool fastCompression;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_PNGEncoderOptions */ 

hGameTest/bin/linux/obj/include/openfl/display/Preloader.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Preloader
+#define INCLUDED_openfl_display_Preloader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Void_Void)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Preloader)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Preloader_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Preloader_obj OBJ_;
+		Preloader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0d31c910 };
+
+		void __construct( ::openfl::display::Sprite display);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Preloader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Preloader"); }
+		static hx::ObjectPtr< Preloader_obj > __new( ::openfl::display::Sprite display);
+		static hx::ObjectPtr< Preloader_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::Sprite display);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Preloader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Preloader",56,c4,4e,24); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::lime::app::_Event_Void_Void onComplete;
+		bool complete;
+		 ::openfl::display::Sprite display;
+		bool ready;
+		void start();
+		::Dynamic start_dyn();
+
+		void update(int loaded,int total);
+		::Dynamic update_dyn();
+
+		void display_onUnload( ::openfl::events::Event event);
+		::Dynamic display_onUnload_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Preloader */ 

hGameTest/bin/linux/obj/include/openfl/display/Scene.h

@@ -0,0 +1,58 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Scene
+#define INCLUDED_openfl_display_Scene
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,FrameLabel)
+HX_DECLARE_CLASS2(openfl,display,Scene)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Scene_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Scene_obj OBJ_;
+		Scene_obj();
+
+	public:
+		enum { _hx_ClassId = 0x124bbfae };
+
+		void __construct(::String name,::Array< ::Dynamic> labels,int numFrames);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Scene")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Scene"); }
+		static hx::ObjectPtr< Scene_obj > __new(::String name,::Array< ::Dynamic> labels,int numFrames);
+		static hx::ObjectPtr< Scene_obj > __alloc(hx::Ctx *_hx_ctx,::String name,::Array< ::Dynamic> labels,int numFrames);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Scene_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Scene",2c,49,ff,0b); }
+
+		::Array< ::Dynamic> labels;
+		::String name;
+		int numFrames;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Scene */ 

hGameTest/bin/linux/obj/include/openfl/display/Shader.h

@@ -0,0 +1,153 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Shader
+#define INCLUDED_openfl_display_Shader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS3(lime,graphics,opengl,GLObject)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS2(openfl,display,ShaderInput_openfl_display_BitmapData)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Bool)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Float)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Int)
+HX_DECLARE_CLASS3(openfl,display,_internal,ShaderBuffer)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,display3D,Program3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Shader_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Shader_obj OBJ_;
+		Shader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x676ab1f7 };
+
+		void __construct( ::openfl::utils::ByteArrayData code);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Shader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Shader"); }
+		static hx::ObjectPtr< Shader_obj > __new( ::openfl::utils::ByteArrayData code);
+		static hx::ObjectPtr< Shader_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::utils::ByteArrayData code);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Shader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Shader",45,33,b5,51); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::openfl::utils::ByteArrayData byteCode;
+		 ::lime::graphics::opengl::GLObject glProgram;
+		 ::Dynamic precisionHint;
+		 ::openfl::display3D::Program3D program;
+		 ::openfl::display::ShaderParameter_Float _hx___alpha;
+		 ::openfl::display::ShaderInput_openfl_display_BitmapData _hx___bitmap;
+		 ::openfl::display::ShaderParameter_Float _hx___colorMultiplier;
+		 ::openfl::display::ShaderParameter_Float _hx___colorOffset;
+		 ::openfl::display3D::Context3D _hx___context;
+		 ::Dynamic _hx___data;
+		::String _hx___glFragmentSource;
+		bool _hx___glSourceDirty;
+		::String _hx___glVertexSource;
+		 ::openfl::display::ShaderParameter_Bool _hx___hasColorTransform;
+		::Array< ::Dynamic> _hx___inputBitmapData;
+		bool _hx___isGenerated;
+		 ::openfl::display::ShaderParameter_Float _hx___matrix;
+		int _hx___numPasses;
+		::Array< ::Dynamic> _hx___paramBool;
+		::Array< ::Dynamic> _hx___paramFloat;
+		::Array< ::Dynamic> _hx___paramInt;
+		 ::openfl::display::ShaderParameter_Float _hx___position;
+		 ::openfl::display::ShaderParameter_Float _hx___textureCoord;
+		 ::openfl::display::ShaderInput_openfl_display_BitmapData _hx___texture;
+		 ::openfl::display::ShaderParameter_Float _hx___textureSize;
+		void _hx___clearUseArray();
+		::Dynamic _hx___clearUseArray_dyn();
+
+		 ::lime::graphics::opengl::GLObject _hx___createGLShader(::String source,int type);
+		::Dynamic _hx___createGLShader_dyn();
+
+		 ::lime::graphics::opengl::GLObject _hx___createGLProgram(::String vertexSource,::String fragmentSource);
+		::Dynamic _hx___createGLProgram_dyn();
+
+		void _hx___disable();
+		::Dynamic _hx___disable_dyn();
+
+		void _hx___disableGL();
+		::Dynamic _hx___disableGL_dyn();
+
+		void _hx___enable();
+		::Dynamic _hx___enable_dyn();
+
+		void _hx___enableGL();
+		::Dynamic _hx___enableGL_dyn();
+
+		void _hx___init();
+		::Dynamic _hx___init_dyn();
+
+		void _hx___initGL();
+		::Dynamic _hx___initGL_dyn();
+
+		void _hx___processGLData(::String source,::String storageType);
+		::Dynamic _hx___processGLData_dyn();
+
+		void _hx___update();
+		::Dynamic _hx___update_dyn();
+
+		void _hx___updateFromBuffer( ::openfl::display::_internal::ShaderBuffer shaderBuffer,int bufferOffset);
+		::Dynamic _hx___updateFromBuffer_dyn();
+
+		void _hx___updateGL();
+		::Dynamic _hx___updateGL_dyn();
+
+		void _hx___updateGLFromBuffer( ::openfl::display::_internal::ShaderBuffer shaderBuffer,int bufferOffset);
+		::Dynamic _hx___updateGLFromBuffer_dyn();
+
+		 ::Dynamic get_data();
+		::Dynamic get_data_dyn();
+
+		 ::Dynamic set_data( ::Dynamic value);
+		::Dynamic set_data_dyn();
+
+		::String get_glFragmentSource();
+		::Dynamic get_glFragmentSource_dyn();
+
+		::String set_glFragmentSource(::String value);
+		::Dynamic set_glFragmentSource_dyn();
+
+		::String get_glVertexSource();
+		::Dynamic get_glVertexSource_dyn();
+
+		::String set_glVertexSource(::String value);
+		::Dynamic set_glVertexSource_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Shader */ 

hGameTest/bin/linux/obj/include/openfl/display/ShaderInput.h

@@ -0,0 +1,73 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_ShaderInput
+#define INCLUDED_openfl_display_ShaderInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,ShaderInput)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderInput_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderInput_obj OBJ_;
+		ShaderInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x060010f7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.ShaderInput")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.ShaderInput"); }
+		static hx::ObjectPtr< ShaderInput_obj > __new();
+		static hx::ObjectPtr< ShaderInput_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderInput_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderInput",85,06,7d,79); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		int channels;
+		 ::Dynamic filter;
+		int height;
+		 ::Dynamic index;
+		 ::Dynamic input;
+		 ::Dynamic mipFilter;
+		::String name;
+		int width;
+		 ::Dynamic wrap;
+		bool _hx___isUniform;
+		void _hx___disableGL( ::openfl::display3D::Context3D context,int id);
+		::Dynamic _hx___disableGL_dyn();
+
+		void _hx___updateGL( ::openfl::display3D::Context3D context,int id, ::Dynamic overrideInput, ::Dynamic overrideFilter, ::Dynamic overrideMipFilter, ::Dynamic overrideWrap);
+		::Dynamic _hx___updateGL_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_ShaderInput */ 

hGameTest/bin/linux/obj/include/openfl/display/ShaderInput_openfl_display_BitmapData.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_ShaderInput_openfl_display_BitmapData
+#define INCLUDED_openfl_display_ShaderInput_openfl_display_BitmapData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,ShaderInput_openfl_display_BitmapData)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderInput_openfl_display_BitmapData_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderInput_openfl_display_BitmapData_obj OBJ_;
+		ShaderInput_openfl_display_BitmapData_obj();
+
+	public:
+		enum { _hx_ClassId = 0x15de7699 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.ShaderInput_openfl_display_BitmapData")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.ShaderInput_openfl_display_BitmapData"); }
+		static hx::ObjectPtr< ShaderInput_openfl_display_BitmapData_obj > __new();
+		static hx::ObjectPtr< ShaderInput_openfl_display_BitmapData_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderInput_openfl_display_BitmapData_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderInput_openfl_display_BitmapData",0b,21,f9,6b); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		int channels;
+		 ::Dynamic filter;
+		int height;
+		 ::Dynamic index;
+		 ::openfl::display::BitmapData input;
+		 ::Dynamic mipFilter;
+		::String name;
+		int width;
+		 ::Dynamic wrap;
+		bool _hx___isUniform;
+		void _hx___disableGL( ::openfl::display3D::Context3D context,int id);
+		::Dynamic _hx___disableGL_dyn();
+
+		void _hx___updateGL( ::openfl::display3D::Context3D context,int id, ::openfl::display::BitmapData overrideInput, ::Dynamic overrideFilter, ::Dynamic overrideMipFilter, ::Dynamic overrideWrap);
+		::Dynamic _hx___updateGL_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_ShaderInput_openfl_display_BitmapData */ 

hGameTest/bin/linux/obj/include/openfl/display/ShaderParameter.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_ShaderParameter
+#define INCLUDED_openfl_display_ShaderParameter
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderParameter_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderParameter_obj OBJ_;
+		ShaderParameter_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4a93ecb2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.ShaderParameter")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.ShaderParameter"); }
+		static hx::ObjectPtr< ShaderParameter_obj > __new();
+		static hx::ObjectPtr< ShaderParameter_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderParameter_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderParameter",a4,d1,21,e4); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic index;
+		::String name;
+		 ::Dynamic type;
+		::cpp::VirtualArray value;
+		int _hx___arrayLength;
+		bool _hx___internal;
+		bool _hx___isBool;
+		bool _hx___isFloat;
+		bool _hx___isInt;
+		bool _hx___isUniform;
+		int __length;
+		 ::lime::utils::ArrayBufferView _hx___uniformMatrix;
+		bool _hx___useArray;
+		void _hx___disableGL( ::openfl::display3D::Context3D context);
+		::Dynamic _hx___disableGL_dyn();
+
+		void _hx___updateGL( ::openfl::display3D::Context3D context,::cpp::VirtualArray overrideValue);
+		::Dynamic _hx___updateGL_dyn();
+
+		void _hx___updateGLFromBuffer( ::openfl::display3D::Context3D context, ::lime::utils::ArrayBufferView buffer,int position,int length,int bufferOffset);
+		::Dynamic _hx___updateGLFromBuffer_dyn();
+
+		::String set_name(::String value);
+		::Dynamic set_name_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_ShaderParameter */ 

hGameTest/bin/linux/obj/include/openfl/display/ShaderParameter_Bool.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_ShaderParameter_Bool
+#define INCLUDED_openfl_display_ShaderParameter_Bool
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Bool)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderParameter_Bool_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderParameter_Bool_obj OBJ_;
+		ShaderParameter_Bool_obj();
+
+	public:
+		enum { _hx_ClassId = 0x612a9f53 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.ShaderParameter_Bool")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.ShaderParameter_Bool"); }
+		static hx::ObjectPtr< ShaderParameter_Bool_obj > __new();
+		static hx::ObjectPtr< ShaderParameter_Bool_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderParameter_Bool_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderParameter_Bool",05,88,35,8c); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic index;
+		::String name;
+		 ::Dynamic type;
+		::Array< bool > value;
+		int _hx___arrayLength;
+		bool _hx___internal;
+		bool _hx___isBool;
+		bool _hx___isFloat;
+		bool _hx___isInt;
+		bool _hx___isUniform;
+		int __length;
+		 ::lime::utils::ArrayBufferView _hx___uniformMatrix;
+		bool _hx___useArray;
+		void _hx___disableGL( ::openfl::display3D::Context3D context);
+		::Dynamic _hx___disableGL_dyn();
+
+		void _hx___updateGL( ::openfl::display3D::Context3D context,::Array< bool > overrideValue);
+		::Dynamic _hx___updateGL_dyn();
+
+		void _hx___updateGLFromBuffer( ::openfl::display3D::Context3D context, ::lime::utils::ArrayBufferView buffer,int position,int length,int bufferOffset);
+		::Dynamic _hx___updateGLFromBuffer_dyn();
+
+		::String set_name(::String value);
+		::Dynamic set_name_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_ShaderParameter_Bool */ 

hGameTest/bin/linux/obj/include/openfl/display/ShaderParameter_Float.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_ShaderParameter_Float
+#define INCLUDED_openfl_display_ShaderParameter_Float
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Float)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderParameter_Float_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderParameter_Float_obj OBJ_;
+		ShaderParameter_Float_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3fe4faef };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.ShaderParameter_Float")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.ShaderParameter_Float"); }
+		static hx::ObjectPtr< ShaderParameter_Float_obj > __new();
+		static hx::ObjectPtr< ShaderParameter_Float_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderParameter_Float_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderParameter_Float",61,21,40,6e); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic index;
+		::String name;
+		 ::Dynamic type;
+		::Array< Float > value;
+		int _hx___arrayLength;
+		bool _hx___internal;
+		bool _hx___isBool;
+		bool _hx___isFloat;
+		bool _hx___isInt;
+		bool _hx___isUniform;
+		int __length;
+		 ::lime::utils::ArrayBufferView _hx___uniformMatrix;
+		bool _hx___useArray;
+		void _hx___disableGL( ::openfl::display3D::Context3D context);
+		::Dynamic _hx___disableGL_dyn();
+
+		void _hx___updateGL( ::openfl::display3D::Context3D context,::Array< Float > overrideValue);
+		::Dynamic _hx___updateGL_dyn();
+
+		void _hx___updateGLFromBuffer( ::openfl::display3D::Context3D context, ::lime::utils::ArrayBufferView buffer,int position,int length,int bufferOffset);
+		::Dynamic _hx___updateGLFromBuffer_dyn();
+
+		::String set_name(::String value);
+		::Dynamic set_name_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_ShaderParameter_Float */ 

hGameTest/bin/linux/obj/include/openfl/display/ShaderParameter_Int.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_ShaderParameter_Int
+#define INCLUDED_openfl_display_ShaderParameter_Int
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Int)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderParameter_Int_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderParameter_Int_obj OBJ_;
+		ShaderParameter_Int_obj();
+
+	public:
+		enum { _hx_ClassId = 0x19b649e6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.ShaderParameter_Int")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.ShaderParameter_Int"); }
+		static hx::ObjectPtr< ShaderParameter_Int_obj > __new();
+		static hx::ObjectPtr< ShaderParameter_Int_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderParameter_Int_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderParameter_Int",74,7d,98,74); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic index;
+		::String name;
+		 ::Dynamic type;
+		::Array< int > value;
+		int _hx___arrayLength;
+		bool _hx___internal;
+		bool _hx___isBool;
+		bool _hx___isFloat;
+		bool _hx___isInt;
+		bool _hx___isUniform;
+		int __length;
+		 ::lime::utils::ArrayBufferView _hx___uniformMatrix;
+		bool _hx___useArray;
+		void _hx___disableGL( ::openfl::display3D::Context3D context);
+		::Dynamic _hx___disableGL_dyn();
+
+		void _hx___updateGL( ::openfl::display3D::Context3D context,::Array< int > overrideValue);
+		::Dynamic _hx___updateGL_dyn();
+
+		void _hx___updateGLFromBuffer( ::openfl::display3D::Context3D context, ::lime::utils::ArrayBufferView buffer,int position,int length,int bufferOffset);
+		::Dynamic _hx___updateGLFromBuffer_dyn();
+
+		::String set_name(::String value);
+		::Dynamic set_name_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_ShaderParameter_Int */ 

hGameTest/bin/linux/obj/include/openfl/display/Shape.h

@@ -0,0 +1,60 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Shape
+#define INCLUDED_openfl_display_Shape
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObject
+#include <openfl/display/DisplayObject.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,Graphics)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,Shape)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Shape_obj : public  ::openfl::display::DisplayObject_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObject_obj super;
+		typedef Shape_obj OBJ_;
+		Shape_obj();
+
+	public:
+		enum { _hx_ClassId = 0x01c05e1f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Shape")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Shape"); }
+		static hx::ObjectPtr< Shape_obj > __new();
+		static hx::ObjectPtr< Shape_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Shape_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Shape",01,53,4a,0f); }
+
+		 ::openfl::display::Graphics get_graphics();
+		::Dynamic get_graphics_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Shape */ 

hGameTest/bin/linux/obj/include/openfl/display/Sprite.h

@@ -0,0 +1,93 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Sprite
+#define INCLUDED_openfl_display_Sprite
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObjectContainer
+#include <openfl/display/DisplayObjectContainer.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,Graphics)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sprite_obj : public  ::openfl::display::DisplayObjectContainer_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObjectContainer_obj super;
+		typedef Sprite_obj OBJ_;
+		Sprite_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0ddfced7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Sprite")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Sprite"); }
+		static hx::ObjectPtr< Sprite_obj > __new();
+		static hx::ObjectPtr< Sprite_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Sprite_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sprite",25,50,2a,f8); }
+
+		 ::openfl::display::DisplayObject dropTarget;
+		 ::openfl::display::Sprite hitArea;
+		bool useHandCursor;
+		bool _hx___buttonMode;
+		void startDrag(hx::Null< bool >  lockCenter, ::openfl::geom::Rectangle bounds);
+		::Dynamic startDrag_dyn();
+
+		void stopDrag();
+		::Dynamic stopDrag_dyn();
+
+		::String _hx___getCursor();
+
+		bool _hx___hitTest(Float x,Float y,bool shapeFlag,::Array< ::Dynamic> stack,bool interactiveOnly, ::openfl::display::DisplayObject hitObject);
+
+		bool _hx___hitTestHitArea(Float x,Float y,bool shapeFlag,::Array< ::Dynamic> stack,bool interactiveOnly, ::openfl::display::DisplayObject hitObject);
+		::Dynamic _hx___hitTestHitArea_dyn();
+
+		bool _hx___hitTestMask(Float x,Float y);
+
+		 ::openfl::display::Graphics get_graphics();
+		::Dynamic get_graphics_dyn();
+
+		bool get_tabEnabled();
+
+		bool get_buttonMode();
+		::Dynamic get_buttonMode_dyn();
+
+		virtual bool set_buttonMode(bool value);
+		::Dynamic set_buttonMode_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Sprite */ 

hGameTest/bin/linux/obj/include/openfl/display/Stage.h

@@ -0,0 +1,404 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Stage
+#define INCLUDED_openfl_display_Stage
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_DisplayObjectContainer
+#include <openfl/display/DisplayObjectContainer.h>
+#endif
+#ifndef INCLUDED_lime_app_IModule
+#include <lime/app/IModule.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+HX_DECLARE_CLASS2(lime,graphics,RenderContext)
+HX_DECLARE_CLASS2(lime,ui,Gamepad)
+HX_DECLARE_CLASS2(lime,ui,MouseWheelMode)
+HX_DECLARE_CLASS2(lime,ui,Touch)
+HX_DECLARE_CLASS2(lime,ui,Window)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,ObjectVector)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,display,Stage)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Point)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+HX_DECLARE_CLASS2(openfl,geom,Transform)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stage_obj : public  ::openfl::display::DisplayObjectContainer_obj
+{
+	public:
+		typedef  ::openfl::display::DisplayObjectContainer_obj super;
+		typedef Stage_obj OBJ_;
+		Stage_obj();
+
+	public:
+		enum { _hx_ClassId = 0x09aee5bc };
+
+		void __construct( ::lime::ui::Window window, ::Dynamic color);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Stage")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Stage"); }
+		static hx::ObjectPtr< Stage_obj > __new( ::lime::ui::Window window, ::Dynamic color);
+		static hx::ObjectPtr< Stage_obj > __alloc(hx::Ctx *_hx_ctx, ::lime::ui::Window window, ::Dynamic color);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Stage_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("Stage",9e,da,38,17); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic align;
+		bool allowsFullScreen;
+		bool allowsFullScreenInteractive;
+		 ::lime::app::Application application;
+		 ::openfl::display3D::Context3D context3D;
+		bool showDefaultContextMenu;
+		 ::openfl::geom::Rectangle softKeyboardRect;
+		 ::openfl::_Vector::ObjectVector stage3Ds;
+		bool stageFocusRect;
+		int stageHeight;
+		int stageWidth;
+		 ::lime::ui::Window window;
+		 ::openfl::display::InteractiveObject _hx___cacheFocus;
+		bool _hx___clearBeforeRender;
+		int _hx___color;
+		::Array< Float > _hx___colorSplit;
+		::String _hx___colorString;
+		Float _hx___contentsScaleFactor;
+		int _hx___currentTabOrderIndex;
+		int _hx___deltaTime;
+		bool _hx___dirty;
+		 ::openfl::geom::Matrix _hx___displayMatrix;
+		 ::openfl::geom::Rectangle _hx___displayRect;
+		 ::Dynamic _hx___displayState;
+		 ::openfl::geom::Rectangle _hx___dragBounds;
+		 ::openfl::display::Sprite _hx___dragObject;
+		Float _hx___dragOffsetX;
+		Float _hx___dragOffsetY;
+		 ::openfl::display::InteractiveObject _hx___focus;
+		bool _hx___forceRender;
+		bool _hx___fullscreen;
+		 ::openfl::geom::Rectangle _hx___fullScreenSourceRect;
+		bool _hx___invalidated;
+		int _hx___lastClickTime;
+		int _hx___logicalWidth;
+		int _hx___logicalHeight;
+		bool _hx___macKeyboard;
+		 ::openfl::display::InteractiveObject _hx___mouseDownLeft;
+		 ::openfl::display::InteractiveObject _hx___mouseDownMiddle;
+		 ::openfl::display::InteractiveObject _hx___mouseDownRight;
+		::Array< ::Dynamic> _hx___mouseOutStack;
+		 ::openfl::display::InteractiveObject _hx___mouseOverTarget;
+		Float _hx___mouseX;
+		Float _hx___mouseY;
+		bool _hx___pendingMouseEvent;
+		int _hx___pendingMouseX;
+		int _hx___pendingMouseY;
+		 ::Dynamic _hx___quality;
+		 ::openfl::display::DisplayObjectRenderer _hx___renderer;
+		bool _hx___rendering;
+		::Array< ::Dynamic> _hx___rollOutStack;
+		 ::Dynamic _hx___scaleMode;
+		::Array< ::Dynamic> _hx___stack;
+		 ::haxe::ds::IntMap _hx___touchData;
+		bool _hx___transparent;
+		bool _hx___wasDirty;
+		bool _hx___wasFullscreen;
+		 ::lime::ui::Touch _hx___primaryTouch;
+		void invalidate();
+
+		 ::openfl::geom::Point localToGlobal( ::openfl::geom::Point pos);
+
+		void _hx___broadcastEvent( ::openfl::events::Event event);
+		::Dynamic _hx___broadcastEvent_dyn();
+
+		void _hx___createRenderer();
+		::Dynamic _hx___createRenderer_dyn();
+
+		bool _hx___dispatchEvent( ::openfl::events::Event event);
+
+		void _hx___dispatchPendingMouseEvent();
+		::Dynamic _hx___dispatchPendingMouseEvent_dyn();
+
+		void _hx___dispatchStack( ::openfl::events::Event event,::Array< ::Dynamic> stack);
+		::Dynamic _hx___dispatchStack_dyn();
+
+		bool _hx___dispatchTarget( ::openfl::events::EventDispatcher target, ::openfl::events::Event event);
+		::Dynamic _hx___dispatchTarget_dyn();
+
+		void _hx___drag( ::openfl::geom::Point mouse);
+		::Dynamic _hx___drag_dyn();
+
+		bool _hx___getInteractive(::Array< ::Dynamic> stack);
+
+		 ::openfl::geom::Point _hx___globalToLocal( ::openfl::geom::Point global, ::openfl::geom::Point local);
+
+		void _hx___handleError( ::Dynamic e);
+		::Dynamic _hx___handleError_dyn();
+
+		void _hx___onKey(::String type,int keyCode,int modifier);
+		::Dynamic _hx___onKey_dyn();
+
+		void _hx___onLimeCreateWindow( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeCreateWindow_dyn();
+
+		void _hx___onLimeGamepadAxisMove( ::lime::ui::Gamepad gamepad,int axis,Float value);
+		::Dynamic _hx___onLimeGamepadAxisMove_dyn();
+
+		void _hx___onLimeGamepadButtonDown( ::lime::ui::Gamepad gamepad,int button);
+		::Dynamic _hx___onLimeGamepadButtonDown_dyn();
+
+		void _hx___onLimeGamepadButtonUp( ::lime::ui::Gamepad gamepad,int button);
+		::Dynamic _hx___onLimeGamepadButtonUp_dyn();
+
+		void _hx___onLimeGamepadConnect( ::lime::ui::Gamepad gamepad);
+		::Dynamic _hx___onLimeGamepadConnect_dyn();
+
+		void _hx___onLimeGamepadDisconnect( ::lime::ui::Gamepad gamepad);
+		::Dynamic _hx___onLimeGamepadDisconnect_dyn();
+
+		void _hx___onLimeKeyDown( ::lime::ui::Window window,int keyCode,int modifier);
+		::Dynamic _hx___onLimeKeyDown_dyn();
+
+		void _hx___onLimeKeyUp( ::lime::ui::Window window,int keyCode,int modifier);
+		::Dynamic _hx___onLimeKeyUp_dyn();
+
+		void _hx___onLimeModuleExit(int code);
+		::Dynamic _hx___onLimeModuleExit_dyn();
+
+		void _hx___onLimeMouseDown( ::lime::ui::Window window,Float x,Float y,int button);
+		::Dynamic _hx___onLimeMouseDown_dyn();
+
+		void _hx___onLimeMouseMove( ::lime::ui::Window window,Float x,Float y);
+		::Dynamic _hx___onLimeMouseMove_dyn();
+
+		void _hx___onLimeMouseMoveRelative( ::lime::ui::Window window,Float x,Float y);
+		::Dynamic _hx___onLimeMouseMoveRelative_dyn();
+
+		void _hx___onLimeMouseUp( ::lime::ui::Window window,Float x,Float y,int button);
+		::Dynamic _hx___onLimeMouseUp_dyn();
+
+		void _hx___onLimeMouseWheel( ::lime::ui::Window window,Float deltaX,Float deltaY, ::lime::ui::MouseWheelMode deltaMode);
+		::Dynamic _hx___onLimeMouseWheel_dyn();
+
+		void _hx___onLimeRender( ::lime::graphics::RenderContext context);
+		::Dynamic _hx___onLimeRender_dyn();
+
+		void _hx___onLimeRenderContextLost();
+		::Dynamic _hx___onLimeRenderContextLost_dyn();
+
+		void _hx___onLimeRenderContextRestored( ::lime::graphics::RenderContext context);
+		::Dynamic _hx___onLimeRenderContextRestored_dyn();
+
+		void _hx___onLimeTextEdit( ::lime::ui::Window window,::String text,int start,int length);
+		::Dynamic _hx___onLimeTextEdit_dyn();
+
+		void _hx___onLimeTextInput( ::lime::ui::Window window,::String text);
+		::Dynamic _hx___onLimeTextInput_dyn();
+
+		void _hx___onLimeTouchCancel( ::lime::ui::Touch touch);
+		::Dynamic _hx___onLimeTouchCancel_dyn();
+
+		void _hx___onLimeTouchMove( ::lime::ui::Touch touch);
+		::Dynamic _hx___onLimeTouchMove_dyn();
+
+		void _hx___onLimeTouchEnd( ::lime::ui::Touch touch);
+		::Dynamic _hx___onLimeTouchEnd_dyn();
+
+		void _hx___onLimeTouchStart( ::lime::ui::Touch touch);
+		::Dynamic _hx___onLimeTouchStart_dyn();
+
+		void _hx___onLimeUpdate(int deltaTime);
+		::Dynamic _hx___onLimeUpdate_dyn();
+
+		void _hx___onLimeWindowActivate( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowActivate_dyn();
+
+		void _hx___onLimeWindowClose( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowClose_dyn();
+
+		void _hx___onLimeWindowCreate( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowCreate_dyn();
+
+		void _hx___onLimeWindowDeactivate( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowDeactivate_dyn();
+
+		void _hx___onLimeWindowDropFile( ::lime::ui::Window window,::String file);
+		::Dynamic _hx___onLimeWindowDropFile_dyn();
+
+		void _hx___onLimeWindowEnter( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowEnter_dyn();
+
+		void _hx___onLimeWindowExpose( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowExpose_dyn();
+
+		void _hx___onLimeWindowFocusIn( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowFocusIn_dyn();
+
+		void _hx___onLimeWindowFocusOut( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowFocusOut_dyn();
+
+		void _hx___onLimeWindowFullscreen( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowFullscreen_dyn();
+
+		void _hx___onLimeWindowLeave( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowLeave_dyn();
+
+		void _hx___onLimeWindowMinimize( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowMinimize_dyn();
+
+		void _hx___onLimeWindowMove( ::lime::ui::Window window,Float x,Float y);
+		::Dynamic _hx___onLimeWindowMove_dyn();
+
+		void _hx___onLimeWindowResize( ::lime::ui::Window window,int width,int height);
+		::Dynamic _hx___onLimeWindowResize_dyn();
+
+		void _hx___onLimeWindowRestore( ::lime::ui::Window window);
+		::Dynamic _hx___onLimeWindowRestore_dyn();
+
+		void _hx___onMouse(::String type,Float x,Float y,int button);
+		::Dynamic _hx___onMouse_dyn();
+
+		void _hx___onMouseWheel(Float deltaX,Float deltaY, ::lime::ui::MouseWheelMode deltaMode);
+		::Dynamic _hx___onMouseWheel_dyn();
+
+		void _hx___onTouch(::String type, ::lime::ui::Touch touch,bool isPrimaryTouchPoint);
+		::Dynamic _hx___onTouch_dyn();
+
+		void _hx___registerLimeModule( ::lime::app::Application application);
+		::Dynamic _hx___registerLimeModule_dyn();
+
+		void _hx___resize();
+		::Dynamic _hx___resize_dyn();
+
+		void _hx___setLogicalSize(int width,int height);
+		::Dynamic _hx___setLogicalSize_dyn();
+
+		void _hx___startDrag( ::openfl::display::Sprite sprite,bool lockCenter, ::openfl::geom::Rectangle bounds);
+		::Dynamic _hx___startDrag_dyn();
+
+		void _hx___stopDrag( ::openfl::display::Sprite sprite);
+		::Dynamic _hx___stopDrag_dyn();
+
+		void _hx___unregisterLimeModule( ::lime::app::Application application);
+		::Dynamic _hx___unregisterLimeModule_dyn();
+
+		void _hx___update(bool transformOnly,bool updateChildren);
+
+		 ::Dynamic get_color();
+		::Dynamic get_color_dyn();
+
+		 ::Dynamic set_color( ::Dynamic value);
+		::Dynamic set_color_dyn();
+
+		Float get_contentsScaleFactor();
+		::Dynamic get_contentsScaleFactor_dyn();
+
+		 ::Dynamic get_displayState();
+		::Dynamic get_displayState_dyn();
+
+		 ::Dynamic set_displayState( ::Dynamic value);
+		::Dynamic set_displayState_dyn();
+
+		 ::openfl::display::InteractiveObject get_focus();
+		::Dynamic get_focus_dyn();
+
+		 ::openfl::display::InteractiveObject set_focus( ::openfl::display::InteractiveObject value);
+		::Dynamic set_focus_dyn();
+
+		Float get_frameRate();
+		::Dynamic get_frameRate_dyn();
+
+		Float set_frameRate(Float value);
+		::Dynamic set_frameRate_dyn();
+
+		int get_fullScreenHeight();
+		::Dynamic get_fullScreenHeight_dyn();
+
+		 ::openfl::geom::Rectangle get_fullScreenSourceRect();
+		::Dynamic get_fullScreenSourceRect_dyn();
+
+		 ::openfl::geom::Rectangle set_fullScreenSourceRect( ::openfl::geom::Rectangle value);
+		::Dynamic set_fullScreenSourceRect_dyn();
+
+		int get_fullScreenWidth();
+		::Dynamic get_fullScreenWidth_dyn();
+
+		Float set_height(Float value);
+
+		Float get_mouseX();
+
+		Float get_mouseY();
+
+		 ::Dynamic get_quality();
+		::Dynamic get_quality_dyn();
+
+		 ::Dynamic set_quality( ::Dynamic value);
+		::Dynamic set_quality_dyn();
+
+		Float set_rotation(Float value);
+
+		 ::Dynamic get_scaleMode();
+		::Dynamic get_scaleMode_dyn();
+
+		 ::Dynamic set_scaleMode( ::Dynamic value);
+		::Dynamic set_scaleMode_dyn();
+
+		Float set_scaleX(Float value);
+
+		Float set_scaleY(Float value);
+
+		bool get_tabEnabled();
+
+		bool set_tabEnabled(bool value);
+
+		int get_tabIndex();
+
+		int set_tabIndex(int value);
+
+		 ::openfl::geom::Transform set_transform( ::openfl::geom::Transform value);
+
+		Float set_width(Float value);
+
+		Float set_x(Float value);
+
+		Float set_y(Float value);
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Stage */ 

hGameTest/bin/linux/obj/include/openfl/display/Stage3D.h

@@ -0,0 +1,121 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Stage3D
+#define INCLUDED_openfl_display_Stage3D
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_EventDispatcher
+#include <openfl/events/EventDispatcher.h>
+#endif
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,ObjectVector)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,Stage)
+HX_DECLARE_CLASS2(openfl,display,Stage3D)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,display3D,IndexBuffer3D)
+HX_DECLARE_CLASS2(openfl,display3D,VertexBuffer3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix3D)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Stage3D_obj : public  ::openfl::events::EventDispatcher_obj
+{
+	public:
+		typedef  ::openfl::events::EventDispatcher_obj super;
+		typedef Stage3D_obj OBJ_;
+		Stage3D_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6b07d441 };
+
+		void __construct( ::openfl::display::Stage stage);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Stage3D")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Stage3D"); }
+		static hx::ObjectPtr< Stage3D_obj > __new( ::openfl::display::Stage stage);
+		static hx::ObjectPtr< Stage3D_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::Stage stage);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Stage3D_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Stage3D",cf,6a,1b,fb); }
+
+		static bool _hx___active;
+		 ::openfl::display3D::Context3D context3D;
+		bool visible;
+		bool _hx___contextLost;
+		bool _hx___contextRequested;
+		int _hx___height;
+		 ::openfl::display3D::IndexBuffer3D _hx___indexBuffer;
+		 ::openfl::geom::Matrix3D _hx___projectionTransform;
+		 ::openfl::geom::Matrix3D _hx___renderTransform;
+		 ::openfl::display::Stage _hx___stage;
+		 ::openfl::display3D::VertexBuffer3D _hx___vertexBuffer;
+		int _hx___width;
+		Float _hx___x;
+		Float _hx___y;
+		void requestContext3D( ::Dynamic context3DRenderMode, ::Dynamic profile);
+		::Dynamic requestContext3D_dyn();
+
+		void requestContext3DMatchingProfiles( ::openfl::_Vector::ObjectVector profiles);
+		::Dynamic requestContext3DMatchingProfiles_dyn();
+
+		void _hx___createContext();
+		::Dynamic _hx___createContext_dyn();
+
+		void _hx___dispatchError();
+		::Dynamic _hx___dispatchError_dyn();
+
+		void _hx___dispatchCreate();
+		::Dynamic _hx___dispatchCreate_dyn();
+
+		void _hx___lostContext();
+		::Dynamic _hx___lostContext_dyn();
+
+		void _hx___resize(int width,int height);
+		::Dynamic _hx___resize_dyn();
+
+		void _hx___restoreContext();
+		::Dynamic _hx___restoreContext_dyn();
+
+		Float get_x();
+		::Dynamic get_x_dyn();
+
+		Float set_x(Float value);
+		::Dynamic set_x_dyn();
+
+		Float get_y();
+		::Dynamic get_y_dyn();
+
+		Float set_y(Float value);
+		::Dynamic set_y_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Stage3D */ 

hGameTest/bin/linux/obj/include/openfl/display/Timeline.h

@@ -0,0 +1,139 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Timeline
+#define INCLUDED_openfl_display_Timeline
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,FrameLabel)
+HX_DECLARE_CLASS2(openfl,display,FrameScript)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,MovieClip)
+HX_DECLARE_CLASS2(openfl,display,Scene)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,display,Timeline)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Timeline_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Timeline_obj OBJ_;
+		Timeline_obj();
+
+	public:
+		enum { _hx_ClassId = 0x55dd04ef };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Timeline")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Timeline"); }
+		static hx::ObjectPtr< Timeline_obj > __new();
+		static hx::ObjectPtr< Timeline_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Timeline_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Timeline",a1,2a,ed,d6); }
+
+		 ::Dynamic frameRate;
+		::Array< ::Dynamic> scenes;
+		::Array< ::Dynamic> scripts;
+		int _hx___currentFrame;
+		::String _hx___currentFrameLabel;
+		::String _hx___currentLabel;
+		::Array< ::Dynamic> _hx___currentLabels;
+		 ::openfl::display::Scene _hx___currentScene;
+		 ::haxe::ds::IntMap _hx___frameScripts;
+		int _hx___framesLoaded;
+		int _hx___frameTime;
+		bool _hx___isPlaying;
+		int _hx___lastFrameScriptEval;
+		int _hx___lastFrameUpdate;
+		 ::openfl::display::MovieClip _hx___scope;
+		int _hx___timeElapsed;
+		int _hx___totalFrames;
+		void attachMovieClip( ::openfl::display::MovieClip movieClip);
+		::Dynamic attachMovieClip_dyn();
+
+		void enterFrame(int frame);
+		::Dynamic enterFrame_dyn();
+
+		void _hx___addFrameScript(int index, ::Dynamic method);
+		::Dynamic _hx___addFrameScript_dyn();
+
+		void _hx___attachMovieClip( ::openfl::display::MovieClip movieClip);
+		::Dynamic _hx___attachMovieClip_dyn();
+
+		void _hx___enterFrame(int deltaTime);
+		::Dynamic _hx___enterFrame_dyn();
+
+		bool _hx___evaluateFrameScripts(int advanceToFrame);
+		::Dynamic _hx___evaluateFrameScripts_dyn();
+
+		int _hx___getNextFrame(int deltaTime);
+		::Dynamic _hx___getNextFrame_dyn();
+
+		void _hx___goto(int frame);
+		::Dynamic _hx___goto_dyn();
+
+		void _hx___gotoAndPlay( ::Dynamic frame,::String scene);
+		::Dynamic _hx___gotoAndPlay_dyn();
+
+		void _hx___gotoAndStop( ::Dynamic frame,::String scene);
+		::Dynamic _hx___gotoAndStop_dyn();
+
+		void _hx___nextFrame();
+		::Dynamic _hx___nextFrame_dyn();
+
+		void _hx___nextScene();
+		::Dynamic _hx___nextScene_dyn();
+
+		void _hx___play();
+		::Dynamic _hx___play_dyn();
+
+		void _hx___prevFrame();
+		::Dynamic _hx___prevFrame_dyn();
+
+		void _hx___prevScene();
+		::Dynamic _hx___prevScene_dyn();
+
+		void _hx___stop();
+		::Dynamic _hx___stop_dyn();
+
+		int _hx___resolveFrameReference( ::Dynamic frame);
+		::Dynamic _hx___resolveFrameReference_dyn();
+
+		void _hx___updateFrameLabel();
+		::Dynamic _hx___updateFrameLabel_dyn();
+
+		void _hx___updateSymbol(int targetFrame);
+		::Dynamic _hx___updateSymbol_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Timeline */ 

hGameTest/bin/linux/obj/include/openfl/display/Window.h

@@ -0,0 +1,56 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display_Window
+#define INCLUDED_openfl_display_Window
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_lime_ui_Window
+#include <lime/ui/Window.h>
+#endif
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+HX_DECLARE_CLASS2(lime,ui,Window)
+HX_DECLARE_CLASS2(openfl,display,Window)
+
+namespace openfl{
+namespace display{
+
+
+class HXCPP_CLASS_ATTRIBUTES Window_obj : public  ::lime::ui::Window_obj
+{
+	public:
+		typedef  ::lime::ui::Window_obj super;
+		typedef Window_obj OBJ_;
+		Window_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2c659efa };
+
+		void __construct( ::lime::app::Application application, ::Dynamic attributes);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.Window")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display.Window"); }
+		static hx::ObjectPtr< Window_obj > __new( ::lime::app::Application application, ::Dynamic attributes);
+		static hx::ObjectPtr< Window_obj > __alloc(hx::Ctx *_hx_ctx, ::lime::app::Application application, ::Dynamic attributes);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Window_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Window",10,08,21,87); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+};
+
+} // end namespace openfl
+} // end namespace display
+
+#endif /* INCLUDED_openfl_display_Window */ 

hGameTest/bin/linux/obj/include/openfl/display/_BlendMode/BlendMode_Impl_.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__BlendMode_BlendMode_Impl_
+#define INCLUDED_openfl_display__BlendMode_BlendMode_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_BlendMode,BlendMode_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _BlendMode{
+
+
+class HXCPP_CLASS_ATTRIBUTES BlendMode_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BlendMode_Impl__obj OBJ_;
+		BlendMode_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x19ec0ff1 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._BlendMode.BlendMode_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._BlendMode.BlendMode_Impl_"); }
+
+		inline static hx::ObjectPtr< BlendMode_Impl__obj > __new() {
+			hx::ObjectPtr< BlendMode_Impl__obj > __this = new BlendMode_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< BlendMode_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			BlendMode_Impl__obj *__this = (BlendMode_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(BlendMode_Impl__obj), false, "openfl.display._BlendMode.BlendMode_Impl_"));
+			*(void **)__this = BlendMode_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BlendMode_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BlendMode_Impl_",d4,1f,5b,ff); }
+
+		static void __boot();
+		static  ::Dynamic ADD;
+		static  ::Dynamic ALPHA;
+		static  ::Dynamic DARKEN;
+		static  ::Dynamic DIFFERENCE;
+		static  ::Dynamic ERASE;
+		static  ::Dynamic HARDLIGHT;
+		static  ::Dynamic INVERT;
+		static  ::Dynamic LAYER;
+		static  ::Dynamic LIGHTEN;
+		static  ::Dynamic MULTIPLY;
+		static  ::Dynamic NORMAL;
+		static  ::Dynamic OVERLAY;
+		static  ::Dynamic SCREEN;
+		static  ::Dynamic SHADER;
+		static  ::Dynamic SUBTRACT;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _BlendMode
+
+#endif /* INCLUDED_openfl_display__BlendMode_BlendMode_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_CapsStyle/CapsStyle_Impl_.h

@@ -0,0 +1,77 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__CapsStyle_CapsStyle_Impl_
+#define INCLUDED_openfl_display__CapsStyle_CapsStyle_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_CapsStyle,CapsStyle_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _CapsStyle{
+
+
+class HXCPP_CLASS_ATTRIBUTES CapsStyle_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CapsStyle_Impl__obj OBJ_;
+		CapsStyle_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x7cd0830d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._CapsStyle.CapsStyle_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._CapsStyle.CapsStyle_Impl_"); }
+
+		inline static hx::ObjectPtr< CapsStyle_Impl__obj > __new() {
+			hx::ObjectPtr< CapsStyle_Impl__obj > __this = new CapsStyle_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CapsStyle_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			CapsStyle_Impl__obj *__this = (CapsStyle_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CapsStyle_Impl__obj), false, "openfl.display._CapsStyle.CapsStyle_Impl_"));
+			*(void **)__this = CapsStyle_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CapsStyle_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CapsStyle_Impl_",d0,81,7b,42); }
+
+		static void __boot();
+		static  ::Dynamic NONE;
+		static  ::Dynamic ROUND;
+		static  ::Dynamic SQUARE;
+		static  ::Dynamic fromInt( ::Dynamic value);
+		static ::Dynamic fromInt_dyn();
+
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static  ::Dynamic toInt( ::Dynamic this1);
+		static ::Dynamic toInt_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _CapsStyle
+
+#endif /* INCLUDED_openfl_display__CapsStyle_CapsStyle_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_GradientType/GradientType_Impl_.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__GradientType_GradientType_Impl_
+#define INCLUDED_openfl_display__GradientType_GradientType_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_GradientType,GradientType_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _GradientType{
+
+
+class HXCPP_CLASS_ATTRIBUTES GradientType_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GradientType_Impl__obj OBJ_;
+		GradientType_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x778edb69 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._GradientType.GradientType_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._GradientType.GradientType_Impl_"); }
+
+		inline static hx::ObjectPtr< GradientType_Impl__obj > __new() {
+			hx::ObjectPtr< GradientType_Impl__obj > __this = new GradientType_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< GradientType_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			GradientType_Impl__obj *__this = (GradientType_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(GradientType_Impl__obj), false, "openfl.display._GradientType.GradientType_Impl_"));
+			*(void **)__this = GradientType_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GradientType_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("GradientType_Impl_",0a,25,04,a0); }
+
+		static void __boot();
+		static  ::Dynamic LINEAR;
+		static  ::Dynamic RADIAL;
+		static  ::Dynamic fromInt( ::Dynamic value);
+		static ::Dynamic fromInt_dyn();
+
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static  ::Dynamic toInt( ::Dynamic this1);
+		static ::Dynamic toInt_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _GradientType
+
+#endif /* INCLUDED_openfl_display__GradientType_GradientType_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_GraphicsPathWinding/GraphicsPathWinding_Impl_.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__GraphicsPathWinding_GraphicsPathWinding_Impl_
+#define INCLUDED_openfl_display__GraphicsPathWinding_GraphicsPathWinding_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_GraphicsPathWinding,GraphicsPathWinding_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _GraphicsPathWinding{
+
+
+class HXCPP_CLASS_ATTRIBUTES GraphicsPathWinding_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef GraphicsPathWinding_Impl__obj OBJ_;
+		GraphicsPathWinding_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f492dfd };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._GraphicsPathWinding.GraphicsPathWinding_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._GraphicsPathWinding.GraphicsPathWinding_Impl_"); }
+
+		inline static hx::ObjectPtr< GraphicsPathWinding_Impl__obj > __new() {
+			hx::ObjectPtr< GraphicsPathWinding_Impl__obj > __this = new GraphicsPathWinding_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< GraphicsPathWinding_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			GraphicsPathWinding_Impl__obj *__this = (GraphicsPathWinding_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(GraphicsPathWinding_Impl__obj), false, "openfl.display._GraphicsPathWinding.GraphicsPathWinding_Impl_"));
+			*(void **)__this = GraphicsPathWinding_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GraphicsPathWinding_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("GraphicsPathWinding_Impl_",ea,2e,4c,54); }
+
+		static void __boot();
+		static  ::Dynamic EVEN_ODD;
+		static  ::Dynamic NON_ZERO;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _GraphicsPathWinding
+
+#endif /* INCLUDED_openfl_display__GraphicsPathWinding_GraphicsPathWinding_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_InterpolationMethod/InterpolationMethod_Impl_.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__InterpolationMethod_InterpolationMethod_Impl_
+#define INCLUDED_openfl_display__InterpolationMethod_InterpolationMethod_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_InterpolationMethod,InterpolationMethod_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _InterpolationMethod{
+
+
+class HXCPP_CLASS_ATTRIBUTES InterpolationMethod_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef InterpolationMethod_Impl__obj OBJ_;
+		InterpolationMethod_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x705fa56d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._InterpolationMethod.InterpolationMethod_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._InterpolationMethod.InterpolationMethod_Impl_"); }
+
+		inline static hx::ObjectPtr< InterpolationMethod_Impl__obj > __new() {
+			hx::ObjectPtr< InterpolationMethod_Impl__obj > __this = new InterpolationMethod_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< InterpolationMethod_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			InterpolationMethod_Impl__obj *__this = (InterpolationMethod_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(InterpolationMethod_Impl__obj), false, "openfl.display._InterpolationMethod.InterpolationMethod_Impl_"));
+			*(void **)__this = InterpolationMethod_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~InterpolationMethod_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("InterpolationMethod_Impl_",65,d5,85,a3); }
+
+		static void __boot();
+		static  ::Dynamic LINEAR_RGB;
+		static  ::Dynamic RGB;
+		static  ::Dynamic fromInt( ::Dynamic value);
+		static ::Dynamic fromInt_dyn();
+
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static  ::Dynamic toInt( ::Dynamic this1);
+		static ::Dynamic toInt_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _InterpolationMethod
+
+#endif /* INCLUDED_openfl_display__InterpolationMethod_InterpolationMethod_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_JointStyle/JointStyle_Impl_.h

@@ -0,0 +1,77 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__JointStyle_JointStyle_Impl_
+#define INCLUDED_openfl_display__JointStyle_JointStyle_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_JointStyle,JointStyle_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _JointStyle{
+
+
+class HXCPP_CLASS_ATTRIBUTES JointStyle_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JointStyle_Impl__obj OBJ_;
+		JointStyle_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f13e873 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._JointStyle.JointStyle_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._JointStyle.JointStyle_Impl_"); }
+
+		inline static hx::ObjectPtr< JointStyle_Impl__obj > __new() {
+			hx::ObjectPtr< JointStyle_Impl__obj > __this = new JointStyle_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< JointStyle_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			JointStyle_Impl__obj *__this = (JointStyle_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(JointStyle_Impl__obj), false, "openfl.display._JointStyle.JointStyle_Impl_"));
+			*(void **)__this = JointStyle_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JointStyle_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JointStyle_Impl_",87,e7,4f,3d); }
+
+		static void __boot();
+		static  ::Dynamic BEVEL;
+		static  ::Dynamic MITER;
+		static  ::Dynamic ROUND;
+		static  ::Dynamic fromInt( ::Dynamic value);
+		static ::Dynamic fromInt_dyn();
+
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static  ::Dynamic toInt( ::Dynamic this1);
+		static ::Dynamic toInt_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _JointStyle
+
+#endif /* INCLUDED_openfl_display__JointStyle_JointStyle_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_LineScaleMode/LineScaleMode_Impl_.h

@@ -0,0 +1,78 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__LineScaleMode_LineScaleMode_Impl_
+#define INCLUDED_openfl_display__LineScaleMode_LineScaleMode_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_LineScaleMode,LineScaleMode_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _LineScaleMode{
+
+
+class HXCPP_CLASS_ATTRIBUTES LineScaleMode_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef LineScaleMode_Impl__obj OBJ_;
+		LineScaleMode_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x39628e2d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._LineScaleMode.LineScaleMode_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._LineScaleMode.LineScaleMode_Impl_"); }
+
+		inline static hx::ObjectPtr< LineScaleMode_Impl__obj > __new() {
+			hx::ObjectPtr< LineScaleMode_Impl__obj > __this = new LineScaleMode_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< LineScaleMode_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			LineScaleMode_Impl__obj *__this = (LineScaleMode_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(LineScaleMode_Impl__obj), false, "openfl.display._LineScaleMode.LineScaleMode_Impl_"));
+			*(void **)__this = LineScaleMode_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~LineScaleMode_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("LineScaleMode_Impl_",b9,d9,f9,d7); }
+
+		static void __boot();
+		static  ::Dynamic HORIZONTAL;
+		static  ::Dynamic NONE;
+		static  ::Dynamic NORMAL;
+		static  ::Dynamic VERTICAL;
+		static  ::Dynamic fromInt( ::Dynamic value);
+		static ::Dynamic fromInt_dyn();
+
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static  ::Dynamic toInt( ::Dynamic this1);
+		static ::Dynamic toInt_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _LineScaleMode
+
+#endif /* INCLUDED_openfl_display__LineScaleMode_LineScaleMode_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_PixelSnapping/PixelSnapping_Impl_.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__PixelSnapping_PixelSnapping_Impl_
+#define INCLUDED_openfl_display__PixelSnapping_PixelSnapping_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_PixelSnapping,PixelSnapping_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _PixelSnapping{
+
+
+class HXCPP_CLASS_ATTRIBUTES PixelSnapping_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef PixelSnapping_Impl__obj OBJ_;
+		PixelSnapping_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x2d23c379 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._PixelSnapping.PixelSnapping_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._PixelSnapping.PixelSnapping_Impl_"); }
+
+		inline static hx::ObjectPtr< PixelSnapping_Impl__obj > __new() {
+			hx::ObjectPtr< PixelSnapping_Impl__obj > __this = new PixelSnapping_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< PixelSnapping_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			PixelSnapping_Impl__obj *__this = (PixelSnapping_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(PixelSnapping_Impl__obj), false, "openfl.display._PixelSnapping.PixelSnapping_Impl_"));
+			*(void **)__this = PixelSnapping_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~PixelSnapping_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PixelSnapping_Impl_",62,58,36,94); }
+
+		static void __boot();
+		static  ::Dynamic ALWAYS;
+		static  ::Dynamic AUTO;
+		static  ::Dynamic NEVER;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _PixelSnapping
+
+#endif /* INCLUDED_openfl_display__PixelSnapping_PixelSnapping_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_ShaderData/ShaderData_Impl_.h

@@ -0,0 +1,68 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__ShaderData_ShaderData_Impl_
+#define INCLUDED_openfl_display__ShaderData_ShaderData_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS3(openfl,display,_ShaderData,ShaderData_Impl_)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace display{
+namespace _ShaderData{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderData_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderData_Impl__obj OBJ_;
+		ShaderData_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x2d0424eb };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._ShaderData.ShaderData_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._ShaderData.ShaderData_Impl_"); }
+
+		inline static hx::ObjectPtr< ShaderData_Impl__obj > __new() {
+			hx::ObjectPtr< ShaderData_Impl__obj > __this = new ShaderData_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ShaderData_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ShaderData_Impl__obj *__this = (ShaderData_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ShaderData_Impl__obj), false, "openfl.display._ShaderData.ShaderData_Impl_"));
+			*(void **)__this = ShaderData_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderData_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderData_Impl_",ef,6d,8d,6b); }
+
+		static  ::Dynamic _new( ::openfl::utils::ByteArrayData byteArray);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _ShaderData
+
+#endif /* INCLUDED_openfl_display__ShaderData_ShaderData_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_ShaderParameterType/ShaderParameterType_Impl_.h

@@ -0,0 +1,89 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__ShaderParameterType_ShaderParameterType_Impl_
+#define INCLUDED_openfl_display__ShaderParameterType_ShaderParameterType_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_ShaderParameterType,ShaderParameterType_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _ShaderParameterType{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderParameterType_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderParameterType_Impl__obj OBJ_;
+		ShaderParameterType_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x7e9fb7ed };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._ShaderParameterType.ShaderParameterType_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._ShaderParameterType.ShaderParameterType_Impl_"); }
+
+		inline static hx::ObjectPtr< ShaderParameterType_Impl__obj > __new() {
+			hx::ObjectPtr< ShaderParameterType_Impl__obj > __this = new ShaderParameterType_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ShaderParameterType_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ShaderParameterType_Impl__obj *__this = (ShaderParameterType_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ShaderParameterType_Impl__obj), false, "openfl.display._ShaderParameterType.ShaderParameterType_Impl_"));
+			*(void **)__this = ShaderParameterType_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderParameterType_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderParameterType_Impl_",9e,c1,8a,62); }
+
+		static void __boot();
+		static  ::Dynamic BOOL;
+		static  ::Dynamic BOOL2;
+		static  ::Dynamic BOOL3;
+		static  ::Dynamic BOOL4;
+		static  ::Dynamic FLOAT;
+		static  ::Dynamic FLOAT2;
+		static  ::Dynamic FLOAT3;
+		static  ::Dynamic FLOAT4;
+		static  ::Dynamic INT;
+		static  ::Dynamic INT2;
+		static  ::Dynamic INT3;
+		static  ::Dynamic INT4;
+		static  ::Dynamic MATRIX2X2;
+		static  ::Dynamic MATRIX2X3;
+		static  ::Dynamic MATRIX2X4;
+		static  ::Dynamic MATRIX3X2;
+		static  ::Dynamic MATRIX3X3;
+		static  ::Dynamic MATRIX3X4;
+		static  ::Dynamic MATRIX4X2;
+		static  ::Dynamic MATRIX4X3;
+		static  ::Dynamic MATRIX4X4;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _ShaderParameterType
+
+#endif /* INCLUDED_openfl_display__ShaderParameterType_ShaderParameterType_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_ShaderPrecision/ShaderPrecision_Impl_.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__ShaderPrecision_ShaderPrecision_Impl_
+#define INCLUDED_openfl_display__ShaderPrecision_ShaderPrecision_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_ShaderPrecision,ShaderPrecision_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _ShaderPrecision{
+
+
+class HXCPP_CLASS_ATTRIBUTES ShaderPrecision_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ShaderPrecision_Impl__obj OBJ_;
+		ShaderPrecision_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x195c0c6d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._ShaderPrecision.ShaderPrecision_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._ShaderPrecision.ShaderPrecision_Impl_"); }
+
+		inline static hx::ObjectPtr< ShaderPrecision_Impl__obj > __new() {
+			hx::ObjectPtr< ShaderPrecision_Impl__obj > __this = new ShaderPrecision_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ShaderPrecision_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ShaderPrecision_Impl__obj *__this = (ShaderPrecision_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ShaderPrecision_Impl__obj), false, "openfl.display._ShaderPrecision.ShaderPrecision_Impl_"));
+			*(void **)__this = ShaderPrecision_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ShaderPrecision_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ShaderPrecision_Impl_",99,de,34,15); }
+
+		static void __boot();
+		static  ::Dynamic FAST;
+		static  ::Dynamic FULL;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _ShaderPrecision
+
+#endif /* INCLUDED_openfl_display__ShaderPrecision_ShaderPrecision_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_SpreadMethod/SpreadMethod_Impl_.h

@@ -0,0 +1,77 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__SpreadMethod_SpreadMethod_Impl_
+#define INCLUDED_openfl_display__SpreadMethod_SpreadMethod_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_SpreadMethod,SpreadMethod_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _SpreadMethod{
+
+
+class HXCPP_CLASS_ATTRIBUTES SpreadMethod_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef SpreadMethod_Impl__obj OBJ_;
+		SpreadMethod_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x5d5c0859 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._SpreadMethod.SpreadMethod_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._SpreadMethod.SpreadMethod_Impl_"); }
+
+		inline static hx::ObjectPtr< SpreadMethod_Impl__obj > __new() {
+			hx::ObjectPtr< SpreadMethod_Impl__obj > __this = new SpreadMethod_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< SpreadMethod_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			SpreadMethod_Impl__obj *__this = (SpreadMethod_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(SpreadMethod_Impl__obj), false, "openfl.display._SpreadMethod.SpreadMethod_Impl_"));
+			*(void **)__this = SpreadMethod_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~SpreadMethod_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SpreadMethod_Impl_",74,a5,98,88); }
+
+		static void __boot();
+		static  ::Dynamic PAD;
+		static  ::Dynamic REFLECT;
+		static  ::Dynamic REPEAT;
+		static  ::Dynamic fromInt( ::Dynamic value);
+		static ::Dynamic fromInt_dyn();
+
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static  ::Dynamic toInt( ::Dynamic this1);
+		static ::Dynamic toInt_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _SpreadMethod
+
+#endif /* INCLUDED_openfl_display__SpreadMethod_SpreadMethod_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_StageAlign/StageAlign_Impl_.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__StageAlign_StageAlign_Impl_
+#define INCLUDED_openfl_display__StageAlign_StageAlign_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_StageAlign,StageAlign_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _StageAlign{
+
+
+class HXCPP_CLASS_ATTRIBUTES StageAlign_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef StageAlign_Impl__obj OBJ_;
+		StageAlign_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x43ce735b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._StageAlign.StageAlign_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._StageAlign.StageAlign_Impl_"); }
+
+		inline static hx::ObjectPtr< StageAlign_Impl__obj > __new() {
+			hx::ObjectPtr< StageAlign_Impl__obj > __this = new StageAlign_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< StageAlign_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			StageAlign_Impl__obj *__this = (StageAlign_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(StageAlign_Impl__obj), false, "openfl.display._StageAlign.StageAlign_Impl_"));
+			*(void **)__this = StageAlign_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~StageAlign_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StageAlign_Impl_",27,1b,3d,66); }
+
+		static void __boot();
+		static  ::Dynamic BOTTOM;
+		static  ::Dynamic BOTTOM_LEFT;
+		static  ::Dynamic BOTTOM_RIGHT;
+		static  ::Dynamic LEFT;
+		static  ::Dynamic RIGHT;
+		static  ::Dynamic TOP;
+		static  ::Dynamic TOP_LEFT;
+		static  ::Dynamic TOP_RIGHT;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _StageAlign
+
+#endif /* INCLUDED_openfl_display__StageAlign_StageAlign_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_StageDisplayState/StageDisplayState_Impl_.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__StageDisplayState_StageDisplayState_Impl_
+#define INCLUDED_openfl_display__StageDisplayState_StageDisplayState_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_StageDisplayState,StageDisplayState_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _StageDisplayState{
+
+
+class HXCPP_CLASS_ATTRIBUTES StageDisplayState_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef StageDisplayState_Impl__obj OBJ_;
+		StageDisplayState_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x645c03f5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._StageDisplayState.StageDisplayState_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._StageDisplayState.StageDisplayState_Impl_"); }
+
+		inline static hx::ObjectPtr< StageDisplayState_Impl__obj > __new() {
+			hx::ObjectPtr< StageDisplayState_Impl__obj > __this = new StageDisplayState_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< StageDisplayState_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			StageDisplayState_Impl__obj *__this = (StageDisplayState_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(StageDisplayState_Impl__obj), false, "openfl.display._StageDisplayState.StageDisplayState_Impl_"));
+			*(void **)__this = StageDisplayState_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~StageDisplayState_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StageDisplayState_Impl_",8d,04,09,e1); }
+
+		static void __boot();
+		static  ::Dynamic FULL_SCREEN;
+		static  ::Dynamic FULL_SCREEN_INTERACTIVE;
+		static  ::Dynamic NORMAL;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _StageDisplayState
+
+#endif /* INCLUDED_openfl_display__StageDisplayState_StageDisplayState_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_StageQuality/StageQuality_Impl_.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__StageQuality_StageQuality_Impl_
+#define INCLUDED_openfl_display__StageQuality_StageQuality_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_StageQuality,StageQuality_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _StageQuality{
+
+
+class HXCPP_CLASS_ATTRIBUTES StageQuality_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef StageQuality_Impl__obj OBJ_;
+		StageQuality_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x68fb030f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._StageQuality.StageQuality_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._StageQuality.StageQuality_Impl_"); }
+
+		inline static hx::ObjectPtr< StageQuality_Impl__obj > __new() {
+			hx::ObjectPtr< StageQuality_Impl__obj > __this = new StageQuality_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< StageQuality_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			StageQuality_Impl__obj *__this = (StageQuality_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(StageQuality_Impl__obj), false, "openfl.display._StageQuality.StageQuality_Impl_"));
+			*(void **)__this = StageQuality_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~StageQuality_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StageQuality_Impl_",21,85,e4,fb); }
+
+		static void __boot();
+		static  ::Dynamic BEST;
+		static  ::Dynamic HIGH;
+		static  ::Dynamic LOW;
+		static  ::Dynamic MEDIUM;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _StageQuality
+
+#endif /* INCLUDED_openfl_display__StageQuality_StageQuality_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_StageScaleMode/StageScaleMode_Impl_.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__StageScaleMode_StageScaleMode_Impl_
+#define INCLUDED_openfl_display__StageScaleMode_StageScaleMode_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_StageScaleMode,StageScaleMode_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _StageScaleMode{
+
+
+class HXCPP_CLASS_ATTRIBUTES StageScaleMode_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef StageScaleMode_Impl__obj OBJ_;
+		StageScaleMode_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x5ae04e6b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._StageScaleMode.StageScaleMode_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._StageScaleMode.StageScaleMode_Impl_"); }
+
+		inline static hx::ObjectPtr< StageScaleMode_Impl__obj > __new() {
+			hx::ObjectPtr< StageScaleMode_Impl__obj > __this = new StageScaleMode_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< StageScaleMode_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			StageScaleMode_Impl__obj *__this = (StageScaleMode_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(StageScaleMode_Impl__obj), false, "openfl.display._StageScaleMode.StageScaleMode_Impl_"));
+			*(void **)__this = StageScaleMode_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~StageScaleMode_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("StageScaleMode_Impl_",6f,2e,dc,ac); }
+
+		static void __boot();
+		static  ::Dynamic EXACT_FIT;
+		static  ::Dynamic NO_BORDER;
+		static  ::Dynamic NO_SCALE;
+		static  ::Dynamic SHOW_ALL;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _StageScaleMode
+
+#endif /* INCLUDED_openfl_display__StageScaleMode_StageScaleMode_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_TriangleCulling/TriangleCulling_Impl_.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__TriangleCulling_TriangleCulling_Impl_
+#define INCLUDED_openfl_display__TriangleCulling_TriangleCulling_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_TriangleCulling,TriangleCulling_Impl_)
+
+namespace openfl{
+namespace display{
+namespace _TriangleCulling{
+
+
+class HXCPP_CLASS_ATTRIBUTES TriangleCulling_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef TriangleCulling_Impl__obj OBJ_;
+		TriangleCulling_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x6f9d9f8d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._TriangleCulling.TriangleCulling_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._TriangleCulling.TriangleCulling_Impl_"); }
+
+		inline static hx::ObjectPtr< TriangleCulling_Impl__obj > __new() {
+			hx::ObjectPtr< TriangleCulling_Impl__obj > __this = new TriangleCulling_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< TriangleCulling_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			TriangleCulling_Impl__obj *__this = (TriangleCulling_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(TriangleCulling_Impl__obj), false, "openfl.display._TriangleCulling.TriangleCulling_Impl_"));
+			*(void **)__this = TriangleCulling_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~TriangleCulling_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("TriangleCulling_Impl_",08,b7,72,ec); }
+
+		static void __boot();
+		static  ::Dynamic NEGATIVE;
+		static  ::Dynamic NONE;
+		static  ::Dynamic POSITIVE;
+		static  ::Dynamic fromString(::String value);
+		static ::Dynamic fromString_dyn();
+
+		static ::String toString( ::Dynamic this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _TriangleCulling
+
+#endif /* INCLUDED_openfl_display__TriangleCulling_TriangleCulling_Impl_ */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/AbstractNoise.h

@@ -0,0 +1,99 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_AbstractNoise
+#define INCLUDED_openfl_display__internal_AbstractNoise
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,AbstractNoise)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES AbstractNoise_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AbstractNoise_obj OBJ_;
+		AbstractNoise_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2fc3b48e };
+
+		void __construct(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool >  __o_stitch,hx::Null< Float >  __o_stitch_threshold);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.AbstractNoise")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.AbstractNoise"); }
+		static hx::ObjectPtr< AbstractNoise_obj > __new(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool >  __o_stitch,hx::Null< Float >  __o_stitch_threshold);
+		static hx::ObjectPtr< AbstractNoise_obj > __alloc(hx::Ctx *_hx_ctx,int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool >  __o_stitch,hx::Null< Float >  __o_stitch_threshold);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AbstractNoise_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("AbstractNoise",38,1b,91,2b); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		int octaves;
+		bool stitch;
+		Float stitch_threshold;
+		int channels;
+		bool grayscale;
+		::Array< Float > octaves_frequencies;
+		::Array< Float > octaves_persistences;
+		Float persistence_max;
+		virtual void fill( ::openfl::display::BitmapData bitmap,Float _scale_x,Float _scale_y,Float _scale_z);
+		::Dynamic fill_dyn();
+
+		int stitching( ::openfl::display::BitmapData bitmap,int color,int px,int py,int stitch_w,int stitch_h,int width,int height);
+		::Dynamic stitching_dyn();
+
+		int color( ::Dynamic r_noise, ::Dynamic g_noise, ::Dynamic b_noise);
+		::Dynamic color_dyn();
+
+		int noiseToColor(Float noise);
+		::Dynamic noiseToColor_dyn();
+
+		Float fade(Float t);
+		::Dynamic fade_dyn();
+
+		int mixI(int x,int y,Float t);
+		::Dynamic mixI_dyn();
+
+		Float mix(Float x,Float y,Float t);
+		::Dynamic mix_dyn();
+
+		int fastfloor(Float x);
+		::Dynamic fastfloor_dyn();
+
+		Float dot2d(::Array< int > grad,Float x,Float y);
+		::Dynamic dot2d_dyn();
+
+		Float dot(::Array< int > grad,Float x,Float y,Float z);
+		::Dynamic dot_dyn();
+
+		void calculateOctaves(Float fPersistence);
+		::Dynamic calculateOctaves_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_AbstractNoise */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoBitmap.h

@@ -0,0 +1,73 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_CairoBitmap
+#define INCLUDED_openfl_display__internal_CairoBitmap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,Bitmap)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,CairoBitmap)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES CairoBitmap_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CairoBitmap_obj OBJ_;
+		CairoBitmap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x00e65e69 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoBitmap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoBitmap"); }
+
+		inline static hx::ObjectPtr< CairoBitmap_obj > __new() {
+			hx::ObjectPtr< CairoBitmap_obj > __this = new CairoBitmap_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CairoBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CairoBitmap_obj *__this = (CairoBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoBitmap_obj), false, "openfl.display._internal.CairoBitmap"));
+			*(void **)__this = CairoBitmap_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CairoBitmap_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CairoBitmap",77,62,57,c1); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::CairoRenderer renderer);
+		static ::Dynamic render_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_CairoBitmap */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoDisplayObject.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_CairoDisplayObject
+#define INCLUDED_openfl_display__internal_CairoDisplayObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,CairoDisplayObject)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES CairoDisplayObject_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CairoDisplayObject_obj OBJ_;
+		CairoDisplayObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x76d80f67 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoDisplayObject")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoDisplayObject"); }
+
+		inline static hx::ObjectPtr< CairoDisplayObject_obj > __new() {
+			hx::ObjectPtr< CairoDisplayObject_obj > __this = new CairoDisplayObject_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CairoDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CairoDisplayObject_obj *__this = (CairoDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoDisplayObject_obj), false, "openfl.display._internal.CairoDisplayObject"));
+			*(void **)__this = CairoDisplayObject_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CairoDisplayObject_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CairoDisplayObject",19,c9,11,01); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::CairoRenderer renderer);
+		static ::Dynamic render_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_CairoDisplayObject */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoGraphics.h

@@ -0,0 +1,137 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_CairoGraphics
+#define INCLUDED_openfl_display__internal_CairoGraphics
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,graphics,cairo,Cairo)
+HX_DECLARE_CLASS2(lime,math,Matrix3)
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,Graphics)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,CairoGraphics)
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES CairoGraphics_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CairoGraphics_obj OBJ_;
+		CairoGraphics_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0e4596a9 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoGraphics")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoGraphics"); }
+
+		inline static hx::ObjectPtr< CairoGraphics_obj > __new() {
+			hx::ObjectPtr< CairoGraphics_obj > __this = new CairoGraphics_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CairoGraphics_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CairoGraphics_obj *__this = (CairoGraphics_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoGraphics_obj), false, "openfl.display._internal.CairoGraphics"));
+			*(void **)__this = CairoGraphics_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CairoGraphics_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CairoGraphics",53,fd,12,0a); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static Float SIN45;
+		static Float TAN22;
+		static bool allowSmoothing;
+		static  ::openfl::display::BitmapData bitmapFill;
+		static bool bitmapRepeat;
+		static  ::openfl::geom::Rectangle bounds;
+		static  ::lime::graphics::cairo::Cairo cairo;
+		static  ::openfl::display::_internal::DrawCommandBuffer fillCommands;
+		static  ::Dynamic fillPattern;
+		static  ::openfl::geom::Matrix fillPatternMatrix;
+		static  ::openfl::display::Graphics graphics;
+		static bool hasFill;
+		static bool hasStroke;
+		static bool hitTesting;
+		static  ::openfl::geom::Matrix inversePendingMatrix;
+		static  ::openfl::geom::Matrix pendingMatrix;
+		static  ::openfl::display::_internal::DrawCommandBuffer strokeCommands;
+		static  ::Dynamic strokePattern;
+		static  ::lime::math::Matrix3 tempMatrix3;
+		static Float worldAlpha;
+		static void closePath(hx::Null< bool >  strokeBefore);
+		static ::Dynamic closePath_dyn();
+
+		static  ::Dynamic createGradientPattern( ::Dynamic type,::cpp::VirtualArray colors,::cpp::VirtualArray alphas,::cpp::VirtualArray ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
+		static ::Dynamic createGradientPattern_dyn();
+
+		static  ::Dynamic createImagePattern( ::openfl::display::BitmapData bitmapFill, ::openfl::geom::Matrix matrix,bool bitmapRepeat,bool smooth);
+		static ::Dynamic createImagePattern_dyn();
+
+		static void drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth, ::Dynamic ellipseHeight);
+		static ::Dynamic drawRoundRect_dyn();
+
+		static void endFill();
+		static ::Dynamic endFill_dyn();
+
+		static void endStroke();
+		static ::Dynamic endStroke_dyn();
+
+		static bool hitTest( ::openfl::display::Graphics graphics,Float x,Float y);
+		static ::Dynamic hitTest_dyn();
+
+		static bool isCCW(Float x1,Float y1,Float x2,Float y2,Float x3,Float y3);
+		static ::Dynamic isCCW_dyn();
+
+		static  ::Dynamic normalizeUVT( ::openfl::_Vector::FloatVector uvt,hx::Null< bool >  skipT);
+		static ::Dynamic normalizeUVT_dyn();
+
+		static void playCommands( ::openfl::display::_internal::DrawCommandBuffer commands,hx::Null< bool >  stroke);
+		static ::Dynamic playCommands_dyn();
+
+		static void quadraticCurveTo(Float cx,Float cy,Float x,Float y);
+		static ::Dynamic quadraticCurveTo_dyn();
+
+		static void render( ::openfl::display::Graphics graphics, ::openfl::display::CairoRenderer renderer);
+		static ::Dynamic render_dyn();
+
+		static void renderMask( ::openfl::display::Graphics graphics, ::openfl::display::CairoRenderer renderer);
+		static ::Dynamic renderMask_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_CairoGraphics */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/CairoShape.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_CairoShape
+#define INCLUDED_openfl_display__internal_CairoShape
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,math,Matrix3)
+HX_DECLARE_CLASS2(openfl,display,CairoRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,CairoShape)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES CairoShape_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CairoShape_obj OBJ_;
+		CairoShape_obj();
+
+	public:
+		enum { _hx_ClassId = 0x16f30e83 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CairoShape")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CairoShape"); }
+
+		inline static hx::ObjectPtr< CairoShape_obj > __new() {
+			hx::ObjectPtr< CairoShape_obj > __this = new CairoShape_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CairoShape_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CairoShape_obj *__this = (CairoShape_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CairoShape_obj), false, "openfl.display._internal.CairoShape"));
+			*(void **)__this = CairoShape_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CairoShape_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CairoShape",99,39,1d,ac); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::lime::math::Matrix3 sourceTransform;
+		static void render( ::openfl::display::DisplayObject shape, ::openfl::display::CairoRenderer renderer);
+		static ::Dynamic render_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_CairoShape */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/CanvasBitmap.h

@@ -0,0 +1,73 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_CanvasBitmap
+#define INCLUDED_openfl_display__internal_CanvasBitmap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,Bitmap)
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,CanvasBitmap)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES CanvasBitmap_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CanvasBitmap_obj OBJ_;
+		CanvasBitmap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x25e7f79d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CanvasBitmap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CanvasBitmap"); }
+
+		inline static hx::ObjectPtr< CanvasBitmap_obj > __new() {
+			hx::ObjectPtr< CanvasBitmap_obj > __this = new CanvasBitmap_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CanvasBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CanvasBitmap_obj *__this = (CanvasBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CanvasBitmap_obj), false, "openfl.display._internal.CanvasBitmap"));
+			*(void **)__this = CanvasBitmap_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CanvasBitmap_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CanvasBitmap",07,57,88,64); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::CanvasRenderer renderer);
+		static ::Dynamic render_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_CanvasBitmap */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/CanvasDisplayObject.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_CanvasDisplayObject
+#define INCLUDED_openfl_display__internal_CanvasDisplayObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,CanvasDisplayObject)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES CanvasDisplayObject_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CanvasDisplayObject_obj OBJ_;
+		CanvasDisplayObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1294c497 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CanvasDisplayObject")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CanvasDisplayObject"); }
+
+		inline static hx::ObjectPtr< CanvasDisplayObject_obj > __new() {
+			hx::ObjectPtr< CanvasDisplayObject_obj > __this = new CanvasDisplayObject_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CanvasDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CanvasDisplayObject_obj *__this = (CanvasDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CanvasDisplayObject_obj), false, "openfl.display._internal.CanvasDisplayObject"));
+			*(void **)__this = CanvasDisplayObject_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CanvasDisplayObject_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CanvasDisplayObject",89,86,07,65); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::CanvasRenderer renderer);
+		static ::Dynamic render_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_CanvasDisplayObject */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/CanvasGraphics.h

@@ -0,0 +1,135 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_CanvasGraphics
+#define INCLUDED_openfl_display__internal_CanvasGraphics
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,CanvasRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,Graphics)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,CanvasGraphics)
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+HX_DECLARE_CLASS2(openfl,geom,Rectangle)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES CanvasGraphics_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CanvasGraphics_obj OBJ_;
+		CanvasGraphics_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3ae9c7cd };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.CanvasGraphics")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.CanvasGraphics"); }
+
+		inline static hx::ObjectPtr< CanvasGraphics_obj > __new() {
+			hx::ObjectPtr< CanvasGraphics_obj > __this = new CanvasGraphics_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CanvasGraphics_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CanvasGraphics_obj *__this = (CanvasGraphics_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CanvasGraphics_obj), false, "openfl.display._internal.CanvasGraphics"));
+			*(void **)__this = CanvasGraphics_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CanvasGraphics_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CanvasGraphics",e3,35,d6,92); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static Float SIN45;
+		static Float TAN22;
+		static bool allowSmoothing;
+		static  ::openfl::display::BitmapData bitmapFill;
+		static  ::openfl::display::BitmapData bitmapStroke;
+		static bool bitmapRepeat;
+		static  ::openfl::geom::Rectangle bounds;
+		static  ::openfl::display::_internal::DrawCommandBuffer fillCommands;
+		static  ::openfl::display::Graphics graphics;
+		static bool hasFill;
+		static bool hasStroke;
+		static bool hitTesting;
+		static  ::openfl::geom::Matrix inversePendingMatrix;
+		static  ::openfl::geom::Matrix pendingMatrix;
+		static  ::openfl::display::_internal::DrawCommandBuffer strokeCommands;
+		static  ::Dynamic windingRule;
+		static Float worldAlpha;
+		static void closePath(hx::Null< bool >  strokeBefore);
+		static ::Dynamic closePath_dyn();
+
+		static  ::Dynamic createBitmapFill( ::openfl::display::BitmapData bitmap,bool bitmapRepeat,bool smooth);
+		static ::Dynamic createBitmapFill_dyn();
+
+		static void createGradientPattern( ::Dynamic type,::cpp::VirtualArray colors,::cpp::VirtualArray alphas,::cpp::VirtualArray ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
+		static ::Dynamic createGradientPattern_dyn();
+
+		static void createTempPatternCanvas( ::openfl::display::BitmapData bitmap,bool repeat,int width,int height);
+		static ::Dynamic createTempPatternCanvas_dyn();
+
+		static void drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth, ::Dynamic ellipseHeight);
+		static ::Dynamic drawRoundRect_dyn();
+
+		static void endFill();
+		static ::Dynamic endFill_dyn();
+
+		static void endStroke();
+		static ::Dynamic endStroke_dyn();
+
+		static bool hitTest( ::openfl::display::Graphics graphics,Float x,Float y);
+		static ::Dynamic hitTest_dyn();
+
+		static bool isCCW(Float x1,Float y1,Float x2,Float y2,Float x3,Float y3);
+		static ::Dynamic isCCW_dyn();
+
+		static  ::Dynamic normalizeUVT( ::openfl::_Vector::FloatVector uvt,hx::Null< bool >  skipT);
+		static ::Dynamic normalizeUVT_dyn();
+
+		static void playCommands( ::openfl::display::_internal::DrawCommandBuffer commands,hx::Null< bool >  stroke);
+		static ::Dynamic playCommands_dyn();
+
+		static void render( ::openfl::display::Graphics graphics, ::openfl::display::CanvasRenderer renderer);
+		static ::Dynamic render_dyn();
+
+		static void renderMask( ::openfl::display::Graphics graphics, ::openfl::display::CanvasRenderer renderer);
+		static ::Dynamic renderMask_dyn();
+
+		static void setSmoothing(bool smooth);
+		static ::Dynamic setSmoothing_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_CanvasGraphics */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DBitmap.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_Context3DBitmap
+#define INCLUDED_openfl_display__internal_Context3DBitmap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,Bitmap)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DBitmap)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES Context3DBitmap_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Context3DBitmap_obj OBJ_;
+		Context3DBitmap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5a034d41 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DBitmap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DBitmap"); }
+
+		inline static hx::ObjectPtr< Context3DBitmap_obj > __new() {
+			hx::ObjectPtr< Context3DBitmap_obj > __this = new Context3DBitmap_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Context3DBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Context3DBitmap_obj *__this = (Context3DBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DBitmap_obj), false, "openfl.display._internal.Context3DBitmap"));
+			*(void **)__this = Context3DBitmap_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Context3DBitmap_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Context3DBitmap",4f,70,e2,50); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic render_dyn();
+
+		static void renderMask( ::openfl::display::Bitmap bitmap, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic renderMask_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_Context3DBitmap */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DBuffer.h

@@ -0,0 +1,85 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_Context3DBuffer
+#define INCLUDED_openfl_display__internal_Context3DBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DBuffer)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DElementType)
+HX_DECLARE_CLASS2(openfl,display3D,Context3D)
+HX_DECLARE_CLASS2(openfl,display3D,IndexBuffer3D)
+HX_DECLARE_CLASS2(openfl,display3D,VertexBuffer3D)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES Context3DBuffer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Context3DBuffer_obj OBJ_;
+		Context3DBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x398bfa52 };
+
+		void __construct( ::openfl::display3D::Context3D context3D, ::openfl::display::_internal::Context3DElementType elementType,int elementCount,int dataPerVertex);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.Context3DBuffer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.Context3DBuffer"); }
+		static hx::ObjectPtr< Context3DBuffer_obj > __new( ::openfl::display3D::Context3D context3D, ::openfl::display::_internal::Context3DElementType elementType,int elementCount,int dataPerVertex);
+		static hx::ObjectPtr< Context3DBuffer_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display3D::Context3D context3D, ::openfl::display::_internal::Context3DElementType elementType,int elementCount,int dataPerVertex);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Context3DBuffer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Context3DBuffer",60,1d,6b,30); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static int MAX_INDEX_BUFFER_LENGTH;
+		static int MAX_QUADS_PER_INDEX_BUFFER;
+		static int MAX_QUAD_INDEX_BUFFER_LENGTH;
+		int dataPerVertex;
+		int elementCount;
+		 ::openfl::display::_internal::Context3DElementType elementType;
+		::Array< ::Dynamic> indexBufferData;
+		::Array< ::Dynamic> indexBuffers;
+		int indexCount;
+		 ::openfl::display3D::VertexBuffer3D vertexBuffer;
+		 ::lime::utils::ArrayBufferView vertexBufferData;
+		int vertexCount;
+		 ::openfl::display3D::Context3D context3D;
+		void drawElements(int start,hx::Null< int >  length);
+		::Dynamic drawElements_dyn();
+
+		void flushVertexBufferData();
+		::Dynamic flushVertexBufferData_dyn();
+
+		void resize(int elementCount,hx::Null< int >  dataPerVertex);
+		::Dynamic resize_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_Context3DBuffer */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DDisplayObject.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_Context3DDisplayObject
+#define INCLUDED_openfl_display__internal_Context3DDisplayObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DDisplayObject)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES Context3DDisplayObject_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Context3DDisplayObject_obj OBJ_;
+		Context3DDisplayObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1b79322b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DDisplayObject")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DDisplayObject"); }
+
+		inline static hx::ObjectPtr< Context3DDisplayObject_obj > __new() {
+			hx::ObjectPtr< Context3DDisplayObject_obj > __this = new Context3DDisplayObject_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Context3DDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Context3DDisplayObject_obj *__this = (Context3DDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DDisplayObject_obj), false, "openfl.display._internal.Context3DDisplayObject"));
+			*(void **)__this = Context3DDisplayObject_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Context3DDisplayObject_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Context3DDisplayObject",41,a6,42,1b); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic render_dyn();
+
+		static void renderMask( ::openfl::display::DisplayObject displayObject, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic renderMask_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_Context3DDisplayObject */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DElementType.h

@@ -0,0 +1,41 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_Context3DElementType
+#define INCLUDED_openfl_display__internal_Context3DElementType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DElementType)
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class Context3DElementType_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef Context3DElementType_obj OBJ_;
+
+	public:
+		Context3DElementType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("openfl.display._internal.Context3DElementType",12,f8,d9,53); }
+		::String __ToString() const { return HX_("Context3DElementType.",38,30,f0,03) + _hx_tag; }
+
+		static ::openfl::display::_internal::Context3DElementType QUADS;
+		static inline ::openfl::display::_internal::Context3DElementType QUADS_dyn() { return QUADS; }
+		static ::openfl::display::_internal::Context3DElementType TRIANGLES;
+		static inline ::openfl::display::_internal::Context3DElementType TRIANGLES_dyn() { return TRIANGLES; }
+		static ::openfl::display::_internal::Context3DElementType TRIANGLE_INDICES;
+		static inline ::openfl::display::_internal::Context3DElementType TRIANGLE_INDICES_dyn() { return TRIANGLE_INDICES; }
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_Context3DElementType */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DGraphics.h

@@ -0,0 +1,93 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_Context3DGraphics
+#define INCLUDED_openfl_display__internal_Context3DGraphics
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,Graphics)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DGraphics)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES Context3DGraphics_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Context3DGraphics_obj OBJ_;
+		Context3DGraphics_obj();
+
+	public:
+		enum { _hx_ClassId = 0x15a6ae9d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DGraphics")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DGraphics"); }
+
+		inline static hx::ObjectPtr< Context3DGraphics_obj > __new() {
+			hx::ObjectPtr< Context3DGraphics_obj > __this = new Context3DGraphics_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Context3DGraphics_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Context3DGraphics_obj *__this = (Context3DGraphics_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DGraphics_obj), false, "openfl.display._internal.Context3DGraphics"));
+			*(void **)__this = Context3DGraphics_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Context3DGraphics_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Context3DGraphics",2b,31,df,dc); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::openfl::display::BitmapData blankBitmapData;
+		static bool maskRender;
+		static  ::openfl::geom::ColorTransform tempColorTransform;
+		static void buildBuffer( ::openfl::display::Graphics graphics, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic buildBuffer_dyn();
+
+		static bool isCompatible( ::openfl::display::Graphics graphics);
+		static ::Dynamic isCompatible_dyn();
+
+		static void render( ::openfl::display::Graphics graphics, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic render_dyn();
+
+		static void renderMask( ::openfl::display::Graphics graphics, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic renderMask_dyn();
+
+		static void resizeIndexBuffer( ::openfl::display::Graphics graphics,bool isQuad,int length);
+		static ::Dynamic resizeIndexBuffer_dyn();
+
+		static void resizeVertexBuffer( ::openfl::display::Graphics graphics,bool hasUVTData,int length);
+		static ::Dynamic resizeVertexBuffer_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_Context3DGraphics */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DMaskShader.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_Context3DMaskShader
+#define INCLUDED_openfl_display__internal_Context3DMaskShader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display_Shader
+#include <openfl/display/Shader.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,Shader)
+HX_DECLARE_CLASS2(openfl,display,ShaderInput_openfl_display_BitmapData)
+HX_DECLARE_CLASS2(openfl,display,ShaderParameter_Float)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DMaskShader)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES Context3DMaskShader_obj : public  ::openfl::display::Shader_obj
+{
+	public:
+		typedef  ::openfl::display::Shader_obj super;
+		typedef Context3DMaskShader_obj OBJ_;
+		Context3DMaskShader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x74e43b67 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.Context3DMaskShader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.Context3DMaskShader"); }
+		static hx::ObjectPtr< Context3DMaskShader_obj > __new();
+		static hx::ObjectPtr< Context3DMaskShader_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Context3DMaskShader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Context3DMaskShader",91,fd,02,f3); }
+
+		static void __boot();
+		static  ::openfl::display::BitmapData opaqueBitmapData;
+		 ::openfl::display::ShaderParameter_Float openfl_Position;
+		 ::openfl::display::ShaderParameter_Float openfl_TextureCoord;
+		 ::openfl::display::ShaderParameter_Float openfl_Matrix;
+		 ::openfl::display::ShaderInput_openfl_display_BitmapData openfl_Texture;
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_Context3DMaskShader */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/Context3DShape.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_Context3DShape
+#define INCLUDED_openfl_display__internal_Context3DShape
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,OpenGLRenderer)
+HX_DECLARE_CLASS3(openfl,display,_internal,Context3DShape)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES Context3DShape_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Context3DShape_obj OBJ_;
+		Context3DShape_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4bf02b73 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.Context3DShape")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.Context3DShape"); }
+
+		inline static hx::ObjectPtr< Context3DShape_obj > __new() {
+			hx::ObjectPtr< Context3DShape_obj > __this = new Context3DShape_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Context3DShape_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Context3DShape_obj *__this = (Context3DShape_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Context3DShape_obj), false, "openfl.display._internal.Context3DShape"));
+			*(void **)__this = Context3DShape_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Context3DShape_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Context3DShape",c1,ae,98,08); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void render( ::openfl::display::DisplayObject shape, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic render_dyn();
+
+		static void renderMask( ::openfl::display::DisplayObject shape, ::openfl::display::OpenGLRenderer renderer);
+		static ::Dynamic renderMask_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_Context3DShape */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/DOMBitmap.h

@@ -0,0 +1,82 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_DOMBitmap
+#define INCLUDED_openfl_display__internal_DOMBitmap
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,Bitmap)
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,DOMBitmap)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES DOMBitmap_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DOMBitmap_obj OBJ_;
+		DOMBitmap_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5ff00e47 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.DOMBitmap")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.DOMBitmap"); }
+
+		inline static hx::ObjectPtr< DOMBitmap_obj > __new() {
+			hx::ObjectPtr< DOMBitmap_obj > __this = new DOMBitmap_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< DOMBitmap_obj > __alloc(hx::Ctx *_hx_ctx) {
+			DOMBitmap_obj *__this = (DOMBitmap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DOMBitmap_obj), false, "openfl.display._internal.DOMBitmap"));
+			*(void **)__this = DOMBitmap_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DOMBitmap_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DOMBitmap",f1,57,46,56); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void clear( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
+		static ::Dynamic clear_dyn();
+
+		static void render( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
+		static ::Dynamic render_dyn();
+
+		static void renderCanvas( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
+		static ::Dynamic renderCanvas_dyn();
+
+		static void renderImage( ::openfl::display::Bitmap bitmap, ::openfl::display::DOMRenderer renderer);
+		static ::Dynamic renderImage_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_DOMBitmap */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/DOMDisplayObject.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_DOMDisplayObject
+#define INCLUDED_openfl_display__internal_DOMDisplayObject
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,display,DOMRenderer)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,DOMDisplayObject)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES DOMDisplayObject_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DOMDisplayObject_obj OBJ_;
+		DOMDisplayObject_obj();
+
+	public:
+		enum { _hx_ClassId = 0x10b13749 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.display._internal.DOMDisplayObject")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.display._internal.DOMDisplayObject"); }
+
+		inline static hx::ObjectPtr< DOMDisplayObject_obj > __new() {
+			hx::ObjectPtr< DOMDisplayObject_obj > __this = new DOMDisplayObject_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< DOMDisplayObject_obj > __alloc(hx::Ctx *_hx_ctx) {
+			DOMDisplayObject_obj *__this = (DOMDisplayObject_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DOMDisplayObject_obj), false, "openfl.display._internal.DOMDisplayObject"));
+			*(void **)__this = DOMDisplayObject_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DOMDisplayObject_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DOMDisplayObject",df,d6,25,8f); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static void clear( ::openfl::display::DisplayObject displayObject, ::openfl::display::DOMRenderer renderer);
+		static ::Dynamic clear_dyn();
+
+		static void render( ::openfl::display::DisplayObject displayObject, ::openfl::display::DOMRenderer renderer);
+		static ::Dynamic render_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_DOMDisplayObject */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/DrawCommandBuffer.h

@@ -0,0 +1,159 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_DrawCommandBuffer
+#define INCLUDED_openfl_display__internal_DrawCommandBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,_Vector,FloatVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IVector)
+HX_DECLARE_CLASS2(openfl,_Vector,IntVector)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandType)
+HX_DECLARE_CLASS3(openfl,display,_internal,ShaderBuffer)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES DrawCommandBuffer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DrawCommandBuffer_obj OBJ_;
+		DrawCommandBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4dc0dc75 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.DrawCommandBuffer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.DrawCommandBuffer"); }
+		static hx::ObjectPtr< DrawCommandBuffer_obj > __new();
+		static hx::ObjectPtr< DrawCommandBuffer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DrawCommandBuffer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DrawCommandBuffer",e7,dd,9a,b4); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static  ::openfl::display::_internal::DrawCommandBuffer empty;
+		::Array< ::Dynamic> types;
+		::Array< bool > b;
+		bool copyOnWrite;
+		::Array< Float > f;
+		::Array< ::Dynamic> ff;
+		::Array< int > i;
+		::Array< ::Dynamic> ii;
+		::cpp::VirtualArray o;
+		 ::openfl::display::_internal::DrawCommandBuffer append( ::openfl::display::_internal::DrawCommandBuffer other);
+		::Dynamic append_dyn();
+
+		void beginBitmapFill( ::openfl::display::BitmapData bitmap, ::openfl::geom::Matrix matrix,bool repeat,bool smooth);
+		::Dynamic beginBitmapFill_dyn();
+
+		void beginFill(int color,Float alpha);
+		::Dynamic beginFill_dyn();
+
+		void beginGradientFill( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
+		::Dynamic beginGradientFill_dyn();
+
+		void beginShaderFill( ::openfl::display::_internal::ShaderBuffer shaderBuffer);
+		::Dynamic beginShaderFill_dyn();
+
+		void clear();
+		::Dynamic clear_dyn();
+
+		 ::openfl::display::_internal::DrawCommandBuffer copy();
+		::Dynamic copy_dyn();
+
+		void cubicCurveTo(Float controlX1,Float controlY1,Float controlX2,Float controlY2,Float anchorX,Float anchorY);
+		::Dynamic cubicCurveTo_dyn();
+
+		void curveTo(Float controlX,Float controlY,Float anchorX,Float anchorY);
+		::Dynamic curveTo_dyn();
+
+		void destroy();
+		::Dynamic destroy_dyn();
+
+		void drawCircle(Float x,Float y,Float radius);
+		::Dynamic drawCircle_dyn();
+
+		void drawEllipse(Float x,Float y,Float width,Float height);
+		::Dynamic drawEllipse_dyn();
+
+		void drawQuads( ::openfl::_Vector::FloatVector rects, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector transforms);
+		::Dynamic drawQuads_dyn();
+
+		void drawRect(Float x,Float y,Float width,Float height);
+		::Dynamic drawRect_dyn();
+
+		void drawRoundRect(Float x,Float y,Float width,Float height,Float ellipseWidth, ::Dynamic ellipseHeight);
+		::Dynamic drawRoundRect_dyn();
+
+		void drawTriangles( ::openfl::_Vector::FloatVector vertices, ::openfl::_Vector::IntVector indices, ::openfl::_Vector::FloatVector uvtData, ::Dynamic culling);
+		::Dynamic drawTriangles_dyn();
+
+		void endFill();
+		::Dynamic endFill_dyn();
+
+		void lineBitmapStyle( ::openfl::display::BitmapData bitmap, ::openfl::geom::Matrix matrix,bool repeat,bool smooth);
+		::Dynamic lineBitmapStyle_dyn();
+
+		void lineGradientStyle( ::Dynamic type,::Array< int > colors,::Array< Float > alphas,::Array< int > ratios, ::openfl::geom::Matrix matrix, ::Dynamic spreadMethod, ::Dynamic interpolationMethod,Float focalPointRatio);
+		::Dynamic lineGradientStyle_dyn();
+
+		void lineStyle( ::Dynamic thickness,int color,Float alpha,bool pixelHinting, ::Dynamic scaleMode, ::Dynamic caps, ::Dynamic joints,Float miterLimit);
+		::Dynamic lineStyle_dyn();
+
+		void lineTo(Float x,Float y);
+		::Dynamic lineTo_dyn();
+
+		void moveTo(Float x,Float y);
+		::Dynamic moveTo_dyn();
+
+		void prepareWrite();
+		::Dynamic prepareWrite_dyn();
+
+		void overrideBlendMode( ::Dynamic blendMode);
+		::Dynamic overrideBlendMode_dyn();
+
+		void overrideMatrix( ::openfl::geom::Matrix matrix);
+		::Dynamic overrideMatrix_dyn();
+
+		void windingEvenOdd();
+		::Dynamic windingEvenOdd_dyn();
+
+		void windingNonZero();
+		::Dynamic windingNonZero_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_DrawCommandBuffer */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/DrawCommandReader.h

@@ -0,0 +1,163 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_DrawCommandReader
+#define INCLUDED_openfl_display__internal_DrawCommandReader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandBuffer)
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandReader)
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandType)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES DrawCommandReader_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DrawCommandReader_obj OBJ_;
+		DrawCommandReader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x195f439c };
+
+		void __construct( ::openfl::display::_internal::DrawCommandBuffer buffer);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.DrawCommandReader")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.DrawCommandReader"); }
+		static hx::ObjectPtr< DrawCommandReader_obj > __new( ::openfl::display::_internal::DrawCommandBuffer buffer);
+		static hx::ObjectPtr< DrawCommandReader_obj > __alloc(hx::Ctx *_hx_ctx, ::openfl::display::_internal::DrawCommandBuffer buffer);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DrawCommandReader_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DrawCommandReader",2a,c6,97,e0); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::openfl::display::_internal::DrawCommandBuffer buffer;
+		int bPos;
+		int iiPos;
+		int iPos;
+		int ffPos;
+		int fPos;
+		int oPos;
+		 ::openfl::display::_internal::DrawCommandType prev;
+		int tsPos;
+		void advance();
+		::Dynamic advance_dyn();
+
+		bool _hx_bool(int index);
+		::Dynamic _hx_bool_dyn();
+
+		void destroy();
+		::Dynamic destroy_dyn();
+
+		::Array< Float > fArr(int index);
+		::Dynamic fArr_dyn();
+
+		Float _hx_float(int index);
+		::Dynamic _hx_float_dyn();
+
+		::Array< int > iArr(int index);
+		::Dynamic iArr_dyn();
+
+		int _hx_int(int index);
+		::Dynamic _hx_int_dyn();
+
+		 ::Dynamic obj(int index);
+		::Dynamic obj_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readBeginBitmapFill();
+		::Dynamic readBeginBitmapFill_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readBeginFill();
+		::Dynamic readBeginFill_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readBeginGradientFill();
+		::Dynamic readBeginGradientFill_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readBeginShaderFill();
+		::Dynamic readBeginShaderFill_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readCubicCurveTo();
+		::Dynamic readCubicCurveTo_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readCurveTo();
+		::Dynamic readCurveTo_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readDrawCircle();
+		::Dynamic readDrawCircle_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readDrawEllipse();
+		::Dynamic readDrawEllipse_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readDrawQuads();
+		::Dynamic readDrawQuads_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readDrawRect();
+		::Dynamic readDrawRect_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readDrawRoundRect();
+		::Dynamic readDrawRoundRect_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readDrawTriangles();
+		::Dynamic readDrawTriangles_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readEndFill();
+		::Dynamic readEndFill_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readLineBitmapStyle();
+		::Dynamic readLineBitmapStyle_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readLineGradientStyle();
+		::Dynamic readLineGradientStyle_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readLineStyle();
+		::Dynamic readLineStyle_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readLineTo();
+		::Dynamic readLineTo_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readMoveTo();
+		::Dynamic readMoveTo_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readOverrideBlendMode();
+		::Dynamic readOverrideBlendMode_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readOverrideMatrix();
+		::Dynamic readOverrideMatrix_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readWindingEvenOdd();
+		::Dynamic readWindingEvenOdd_dyn();
+
+		 ::openfl::display::_internal::DrawCommandReader readWindingNonZero();
+		::Dynamic readWindingNonZero_dyn();
+
+		void reset();
+		::Dynamic reset_dyn();
+
+		void skip( ::openfl::display::_internal::DrawCommandType type);
+		::Dynamic skip_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_DrawCommandReader */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/DrawCommandType.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_DrawCommandType
+#define INCLUDED_openfl_display__internal_DrawCommandType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,display,_internal,DrawCommandType)
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class DrawCommandType_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef DrawCommandType_obj OBJ_;
+
+	public:
+		DrawCommandType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("openfl.display._internal.DrawCommandType",85,10,25,e2); }
+		::String __ToString() const { return HX_("DrawCommandType.",2d,29,07,6b) + _hx_tag; }
+
+		static ::openfl::display::_internal::DrawCommandType BEGIN_BITMAP_FILL;
+		static inline ::openfl::display::_internal::DrawCommandType BEGIN_BITMAP_FILL_dyn() { return BEGIN_BITMAP_FILL; }
+		static ::openfl::display::_internal::DrawCommandType BEGIN_FILL;
+		static inline ::openfl::display::_internal::DrawCommandType BEGIN_FILL_dyn() { return BEGIN_FILL; }
+		static ::openfl::display::_internal::DrawCommandType BEGIN_GRADIENT_FILL;
+		static inline ::openfl::display::_internal::DrawCommandType BEGIN_GRADIENT_FILL_dyn() { return BEGIN_GRADIENT_FILL; }
+		static ::openfl::display::_internal::DrawCommandType BEGIN_SHADER_FILL;
+		static inline ::openfl::display::_internal::DrawCommandType BEGIN_SHADER_FILL_dyn() { return BEGIN_SHADER_FILL; }
+		static ::openfl::display::_internal::DrawCommandType CUBIC_CURVE_TO;
+		static inline ::openfl::display::_internal::DrawCommandType CUBIC_CURVE_TO_dyn() { return CUBIC_CURVE_TO; }
+		static ::openfl::display::_internal::DrawCommandType CURVE_TO;
+		static inline ::openfl::display::_internal::DrawCommandType CURVE_TO_dyn() { return CURVE_TO; }
+		static ::openfl::display::_internal::DrawCommandType DRAW_CIRCLE;
+		static inline ::openfl::display::_internal::DrawCommandType DRAW_CIRCLE_dyn() { return DRAW_CIRCLE; }
+		static ::openfl::display::_internal::DrawCommandType DRAW_ELLIPSE;
+		static inline ::openfl::display::_internal::DrawCommandType DRAW_ELLIPSE_dyn() { return DRAW_ELLIPSE; }
+		static ::openfl::display::_internal::DrawCommandType DRAW_QUADS;
+		static inline ::openfl::display::_internal::DrawCommandType DRAW_QUADS_dyn() { return DRAW_QUADS; }
+		static ::openfl::display::_internal::DrawCommandType DRAW_RECT;
+		static inline ::openfl::display::_internal::DrawCommandType DRAW_RECT_dyn() { return DRAW_RECT; }
+		static ::openfl::display::_internal::DrawCommandType DRAW_ROUND_RECT;
+		static inline ::openfl::display::_internal::DrawCommandType DRAW_ROUND_RECT_dyn() { return DRAW_ROUND_RECT; }
+		static ::openfl::display::_internal::DrawCommandType DRAW_TILES;
+		static inline ::openfl::display::_internal::DrawCommandType DRAW_TILES_dyn() { return DRAW_TILES; }
+		static ::openfl::display::_internal::DrawCommandType DRAW_TRIANGLES;
+		static inline ::openfl::display::_internal::DrawCommandType DRAW_TRIANGLES_dyn() { return DRAW_TRIANGLES; }
+		static ::openfl::display::_internal::DrawCommandType END_FILL;
+		static inline ::openfl::display::_internal::DrawCommandType END_FILL_dyn() { return END_FILL; }
+		static ::openfl::display::_internal::DrawCommandType LINE_BITMAP_STYLE;
+		static inline ::openfl::display::_internal::DrawCommandType LINE_BITMAP_STYLE_dyn() { return LINE_BITMAP_STYLE; }
+		static ::openfl::display::_internal::DrawCommandType LINE_GRADIENT_STYLE;
+		static inline ::openfl::display::_internal::DrawCommandType LINE_GRADIENT_STYLE_dyn() { return LINE_GRADIENT_STYLE; }
+		static ::openfl::display::_internal::DrawCommandType LINE_STYLE;
+		static inline ::openfl::display::_internal::DrawCommandType LINE_STYLE_dyn() { return LINE_STYLE; }
+		static ::openfl::display::_internal::DrawCommandType LINE_TO;
+		static inline ::openfl::display::_internal::DrawCommandType LINE_TO_dyn() { return LINE_TO; }
+		static ::openfl::display::_internal::DrawCommandType MOVE_TO;
+		static inline ::openfl::display::_internal::DrawCommandType MOVE_TO_dyn() { return MOVE_TO; }
+		static ::openfl::display::_internal::DrawCommandType OVERRIDE_BLEND_MODE;
+		static inline ::openfl::display::_internal::DrawCommandType OVERRIDE_BLEND_MODE_dyn() { return OVERRIDE_BLEND_MODE; }
+		static ::openfl::display::_internal::DrawCommandType OVERRIDE_MATRIX;
+		static inline ::openfl::display::_internal::DrawCommandType OVERRIDE_MATRIX_dyn() { return OVERRIDE_MATRIX; }
+		static ::openfl::display::_internal::DrawCommandType UNKNOWN;
+		static inline ::openfl::display::_internal::DrawCommandType UNKNOWN_dyn() { return UNKNOWN; }
+		static ::openfl::display::_internal::DrawCommandType WINDING_EVEN_ODD;
+		static inline ::openfl::display::_internal::DrawCommandType WINDING_EVEN_ODD_dyn() { return WINDING_EVEN_ODD; }
+		static ::openfl::display::_internal::DrawCommandType WINDING_NON_ZERO;
+		static inline ::openfl::display::_internal::DrawCommandType WINDING_NON_ZERO_dyn() { return WINDING_NON_ZERO; }
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_DrawCommandType */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/PerlinNoise.h

@@ -0,0 +1,78 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_PerlinNoise
+#define INCLUDED_openfl_display__internal_PerlinNoise
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_display__internal_AbstractNoise
+#include <openfl/display/_internal/AbstractNoise.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS3(openfl,display,_internal,AbstractNoise)
+HX_DECLARE_CLASS3(openfl,display,_internal,PerlinNoise)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES PerlinNoise_obj : public  ::openfl::display::_internal::AbstractNoise_obj
+{
+	public:
+		typedef  ::openfl::display::_internal::AbstractNoise_obj super;
+		typedef PerlinNoise_obj OBJ_;
+		PerlinNoise_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0e4f2070 };
+
+		void __construct(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool >  __o_stitch,hx::Null< Float >  __o_stitch_threshold);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.PerlinNoise")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.PerlinNoise"); }
+		static hx::ObjectPtr< PerlinNoise_obj > __new(int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool >  __o_stitch,hx::Null< Float >  __o_stitch_threshold);
+		static hx::ObjectPtr< PerlinNoise_obj > __alloc(hx::Ctx *_hx_ctx,int seed,int octaves,int channels,bool grayScale,Float falloff,hx::Null< bool >  __o_stitch,hx::Null< Float >  __o_stitch_threshold);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~PerlinNoise_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("PerlinNoise",46,1c,2b,70); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static ::Array< int > P;
+		::Array< int > p_perm;
+		Float x_offset;
+		Float y_offset;
+		Float z_offset;
+		Float base_factor;
+		void fill( ::openfl::display::BitmapData bitmap,Float _scale_x,Float _scale_y,Float _scale_z);
+
+		Float noise(Float x,Float y,Float z);
+		::Dynamic noise_dyn();
+
+		void setSeed(int seed);
+		::Dynamic setSeed_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_PerlinNoise */ 

hGameTest/bin/linux/obj/include/openfl/display/_internal/SamplerState.h

@@ -0,0 +1,106 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_display__internal_SamplerState
+#define INCLUDED_openfl_display__internal_SamplerState
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_2927c9d004f07aab_25_new)
+HX_DECLARE_CLASS3(openfl,display,_internal,SamplerState)
+
+namespace openfl{
+namespace display{
+namespace _internal{
+
+
+class HXCPP_CLASS_ATTRIBUTES SamplerState_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef SamplerState_obj OBJ_;
+		SamplerState_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1348bc3b };
+
+		void __construct( ::Dynamic __o_wrap, ::Dynamic __o_filter, ::Dynamic __o_mipfilter,hx::Null< Float >  __o_lodBias,hx::Null< bool >  __o_ignoreSampler,hx::Null< bool >  __o_centroid,hx::Null< bool >  __o_textureAlpha);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display._internal.SamplerState")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"openfl.display._internal.SamplerState"); }
+
+		inline static hx::ObjectPtr< SamplerState_obj > __new( ::Dynamic __o_wrap, ::Dynamic __o_filter, ::Dynamic __o_mipfilter,hx::Null< Float >  __o_lodBias,hx::Null< bool >  __o_ignoreSampler,hx::Null< bool >  __o_centroid,hx::Null< bool >  __o_textureAlpha) {
+			hx::ObjectPtr< SamplerState_obj > __this = new SamplerState_obj();
+			__this->__construct(__o_wrap,__o_filter,__o_mipfilter,__o_lodBias,__o_ignoreSampler,__o_centroid,__o_textureAlpha);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< SamplerState_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic __o_wrap, ::Dynamic __o_filter, ::Dynamic __o_mipfilter,hx::Null< Float >  __o_lodBias,hx::Null< bool >  __o_ignoreSampler,hx::Null< bool >  __o_centroid,hx::Null< bool >  __o_textureAlpha) {
+			SamplerState_obj *__this = (SamplerState_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(SamplerState_obj), true, "openfl.display._internal.SamplerState"));
+			*(void **)__this = SamplerState_obj::_hx_vtable;
+{
+            		 ::Dynamic wrap = __o_wrap;
+            		if (hx::IsNull(__o_wrap)) wrap = 0;
+            		 ::Dynamic filter = __o_filter;
+            		if (hx::IsNull(__o_filter)) filter = 5;
+            		 ::Dynamic mipfilter = __o_mipfilter;
+            		if (hx::IsNull(__o_mipfilter)) mipfilter = 2;
+            		Float lodBias = __o_lodBias.Default(((Float)0.0));
+            		bool ignoreSampler = __o_ignoreSampler.Default(false);
+            		bool centroid = __o_centroid.Default(false);
+            		bool textureAlpha = __o_textureAlpha.Default(false);
+            	HX_STACKFRAME(&_hx_pos_2927c9d004f07aab_25_new)
+HXLINE(  26)		( ( ::openfl::display::_internal::SamplerState)(__this) )->wrap = wrap;
+HXLINE(  27)		( ( ::openfl::display::_internal::SamplerState)(__this) )->filter = filter;
+HXLINE(  28)		( ( ::openfl::display::_internal::SamplerState)(__this) )->mipfilter = mipfilter;
+HXLINE(  29)		( ( ::openfl::display::_internal::SamplerState)(__this) )->lodBias = lodBias;
+HXLINE(  30)		( ( ::openfl::display::_internal::SamplerState)(__this) )->ignoreSampler = ignoreSampler;
+HXLINE(  31)		( ( ::openfl::display::_internal::SamplerState)(__this) )->centroid = centroid;
+HXLINE(  32)		( ( ::openfl::display::_internal::SamplerState)(__this) )->textureAlpha = textureAlpha;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~SamplerState_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SamplerState",09,30,d2,83); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool centroid;
+		 ::Dynamic filter;
+		bool ignoreSampler;
+		Float lodBias;
+		 ::Dynamic mipfilter;
+		bool mipmapGenerated;
+		bool textureAlpha;
+		 ::Dynamic wrap;
+		 ::openfl::display::_internal::SamplerState clone();
+		::Dynamic clone_dyn();
+
+		void copyFrom( ::openfl::display::_internal::SamplerState other);
+		::Dynamic copyFrom_dyn();
+
+		bool equals( ::openfl::display::_internal::SamplerState other);
+		::Dynamic equals_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace display
+} // end namespace _internal
+
+#endif /* INCLUDED_openfl_display__internal_SamplerState */