First commit

hGameTest/bin/linux/obj/include/lime/utils/ArrayBufferIO.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_ArrayBufferIO
+#define INCLUDED_lime_utils_ArrayBufferIO
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferIO)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES ArrayBufferIO_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ArrayBufferIO_obj OBJ_;
+		ArrayBufferIO_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6294e343 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils.ArrayBufferIO")
+			{ 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,"lime.utils.ArrayBufferIO"); }
+
+		inline static hx::ObjectPtr< ArrayBufferIO_obj > __new() {
+			hx::ObjectPtr< ArrayBufferIO_obj > __this = new ArrayBufferIO_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ArrayBufferIO_obj > __alloc(hx::Ctx *_hx_ctx) {
+			ArrayBufferIO_obj *__this = (ArrayBufferIO_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ArrayBufferIO_obj), false, "lime.utils.ArrayBufferIO"));
+			*(void **)__this = ArrayBufferIO_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ArrayBufferIO_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_("ArrayBufferIO",7f,77,2c,77); }
+
+		static int getInt16( ::haxe::io::Bytes buffer,int byteOffset);
+		static ::Dynamic getInt16_dyn();
+
+		static int getInt16_BE( ::haxe::io::Bytes buffer,int byteOffset);
+		static ::Dynamic getInt16_BE_dyn();
+
+		static void setInt16( ::haxe::io::Bytes buffer,int byteOffset,int value);
+		static ::Dynamic setInt16_dyn();
+
+		static void setInt16_BE( ::haxe::io::Bytes buffer,int byteOffset,int value);
+		static ::Dynamic setInt16_BE_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_ArrayBufferIO */ 

hGameTest/bin/linux/obj/include/lime/utils/ArrayBufferView.h

@@ -0,0 +1,113 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_ArrayBufferView
+#define INCLUDED_lime_utils_ArrayBufferView
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES ArrayBufferView_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ArrayBufferView_obj OBJ_;
+		ArrayBufferView_obj();
+
+	public:
+		enum { _hx_ClassId = 0x340d6186 };
+
+		void __construct( ::Dynamic elements,int in_type);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.ArrayBufferView")
+			{ 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,"lime.utils.ArrayBufferView"); }
+		static hx::ObjectPtr< ArrayBufferView_obj > __new( ::Dynamic elements,int in_type);
+		static hx::ObjectPtr< ArrayBufferView_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic elements,int in_type);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ArrayBufferView_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_("ArrayBufferView",5e,6e,84,fd); }
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_Float64Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_Float64Array_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_Int16Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_Int16Array_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_Int8Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_Int8Array_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_UInt8ClampedArray(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_UInt8ClampedArray_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_UInt16Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_UInt16Array_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_Int32Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_Int32Array_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_UInt32Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_UInt32Array_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_UInt8Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_UInt8Array_dyn();
+
+		 ::lime::utils::ArrayBufferView subarray_lime_utils_Float32Array(int begin, ::Dynamic end);
+		::Dynamic subarray_lime_utils_Float32Array_dyn();
+
+		int type;
+		 ::haxe::io::Bytes buffer;
+		int byteOffset;
+		int byteLength;
+		int length;
+		int bytesPerElement;
+		 ::lime::utils::ArrayBufferView initTypedArray( ::lime::utils::ArrayBufferView view);
+		::Dynamic initTypedArray_dyn();
+
+		 ::lime::utils::ArrayBufferView initBuffer( ::haxe::io::Bytes in_buffer,hx::Null< int >  in_byteOffset, ::Dynamic len);
+		::Dynamic initBuffer_dyn();
+
+		 ::lime::utils::ArrayBufferView initArray(::cpp::VirtualArray array);
+		::Dynamic initArray_dyn();
+
+		void set( ::lime::utils::ArrayBufferView view,::cpp::VirtualArray array,hx::Null< int >  offset);
+		::Dynamic set_dyn();
+
+		void cloneBuffer( ::haxe::io::Bytes src,hx::Null< int >  srcByteOffset);
+		::Dynamic cloneBuffer_dyn();
+
+		int bytesForType(int type);
+		::Dynamic bytesForType_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		int toByteLength(int elemCount);
+		::Dynamic toByteLength_dyn();
+
+		void copyFromArray(::Array< Float > array,hx::Null< int >  offset);
+		::Dynamic copyFromArray_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_ArrayBufferView */ 

hGameTest/bin/linux/obj/include/lime/utils/AssetBundle.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_AssetBundle
+#define INCLUDED_lime_utils_AssetBundle
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Input)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,utils,AssetBundle)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES AssetBundle_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AssetBundle_obj OBJ_;
+		AssetBundle_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0594b036 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.AssetBundle")
+			{ 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,"lime.utils.AssetBundle"); }
+		static hx::ObjectPtr< AssetBundle_obj > __new();
+		static hx::ObjectPtr< AssetBundle_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AssetBundle_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);
+		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_("AssetBundle",72,7d,71,4f); }
+
+		static  ::lime::utils::AssetBundle fromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::lime::utils::AssetBundle fromFile(::String path);
+		static ::Dynamic fromFile_dyn();
+
+		static  ::lime::app::Future loadFromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic loadFromBytes_dyn();
+
+		static  ::lime::app::Future loadFromFile(::String path);
+		static ::Dynamic loadFromFile_dyn();
+
+		static  ::lime::utils::AssetBundle _hx___extractBundle( ::haxe::io::Input input);
+		static ::Dynamic _hx___extractBundle_dyn();
+
+		 ::haxe::ds::StringMap data;
+		::Array< ::String > paths;
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_AssetBundle */ 

hGameTest/bin/linux/obj/include/lime/utils/AssetCache.h

@@ -0,0 +1,68 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_AssetCache
+#define INCLUDED_lime_utils_AssetCache
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,utils,AssetCache)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES AssetCache_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AssetCache_obj OBJ_;
+		AssetCache_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2dd70846 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.AssetCache")
+			{ 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,"lime.utils.AssetCache"); }
+		static hx::ObjectPtr< AssetCache_obj > __new();
+		static hx::ObjectPtr< AssetCache_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AssetCache_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_("AssetCache",52,9e,a3,e4); }
+
+		 ::haxe::ds::StringMap audio;
+		bool enabled;
+		 ::haxe::ds::StringMap image;
+		 ::haxe::ds::StringMap font;
+		int version;
+		bool exists(::String id,::String type);
+		::Dynamic exists_dyn();
+
+		void set(::String id,::String type, ::Dynamic asset);
+		::Dynamic set_dyn();
+
+		void clear(::String prefix);
+		::Dynamic clear_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_AssetCache */ 

hGameTest/bin/linux/obj/include/lime/utils/AssetLibrary.h

@@ -0,0 +1,197 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_AssetLibrary
+#define INCLUDED_lime_utils_AssetLibrary
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_lime_utils_AssetLibrary)
+HX_DECLARE_CLASS2(lime,app,_Event_Void_Void)
+HX_DECLARE_CLASS2(lime,graphics,Image)
+HX_DECLARE_CLASS2(lime,media,AudioBuffer)
+HX_DECLARE_CLASS2(lime,text,Font)
+HX_DECLARE_CLASS2(lime,utils,AssetBundle)
+HX_DECLARE_CLASS2(lime,utils,AssetLibrary)
+HX_DECLARE_CLASS2(lime,utils,AssetManifest)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES AssetLibrary_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AssetLibrary_obj OBJ_;
+		AssetLibrary_obj();
+
+	public:
+		enum { _hx_ClassId = 0x425552e3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.AssetLibrary")
+			{ 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,"lime.utils.AssetLibrary"); }
+		static hx::ObjectPtr< AssetLibrary_obj > __new();
+		static hx::ObjectPtr< AssetLibrary_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AssetLibrary_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);
+		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_("AssetLibrary",0b,4f,d4,27); }
+
+		static  ::lime::utils::AssetLibrary fromBytes( ::haxe::io::Bytes bytes,::String rootPath);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::lime::utils::AssetLibrary fromFile(::String path,::String rootPath);
+		static ::Dynamic fromFile_dyn();
+
+		static  ::lime::utils::AssetLibrary fromBundle( ::lime::utils::AssetBundle bundle);
+		static ::Dynamic fromBundle_dyn();
+
+		static  ::lime::utils::AssetLibrary fromManifest( ::lime::utils::AssetManifest manifest);
+		static ::Dynamic fromManifest_dyn();
+
+		static  ::lime::app::Future loadFromBytes( ::haxe::io::Bytes bytes,::String rootPath);
+		static ::Dynamic loadFromBytes_dyn();
+
+		static  ::lime::app::Future loadFromFile(::String path,::String rootPath);
+		static ::Dynamic loadFromFile_dyn();
+
+		static  ::lime::app::Future loadFromManifest( ::lime::utils::AssetManifest manifest);
+		static ::Dynamic loadFromManifest_dyn();
+
+		 ::lime::app::_Event_Void_Void onChange;
+		int assetsLoaded;
+		int assetsTotal;
+		int bytesLoaded;
+		 ::haxe::ds::StringMap bytesLoadedCache;
+		int bytesTotal;
+		 ::haxe::ds::StringMap cachedAudioBuffers;
+		 ::haxe::ds::StringMap cachedBytes;
+		 ::haxe::ds::StringMap cachedFonts;
+		 ::haxe::ds::StringMap cachedImages;
+		 ::haxe::ds::StringMap cachedText;
+		 ::haxe::ds::StringMap classTypes;
+		bool loaded;
+		 ::haxe::ds::StringMap pathGroups;
+		 ::haxe::ds::StringMap paths;
+		 ::haxe::ds::StringMap preload;
+		 ::lime::app::Promise_lime_utils_AssetLibrary promise;
+		 ::haxe::ds::StringMap sizes;
+		 ::haxe::ds::StringMap types;
+		virtual bool exists(::String id,::String type);
+		::Dynamic exists_dyn();
+
+		virtual  ::Dynamic getAsset(::String id,::String type);
+		::Dynamic getAsset_dyn();
+
+		virtual  ::lime::media::AudioBuffer getAudioBuffer(::String id);
+		::Dynamic getAudioBuffer_dyn();
+
+		virtual  ::haxe::io::Bytes getBytes(::String id);
+		::Dynamic getBytes_dyn();
+
+		virtual  ::lime::text::Font getFont(::String id);
+		::Dynamic getFont_dyn();
+
+		virtual  ::lime::graphics::Image getImage(::String id);
+		::Dynamic getImage_dyn();
+
+		virtual ::String getPath(::String id);
+		::Dynamic getPath_dyn();
+
+		virtual ::String getText(::String id);
+		::Dynamic getText_dyn();
+
+		virtual bool isLocal(::String id,::String type);
+		::Dynamic isLocal_dyn();
+
+		virtual ::Array< ::String > list(::String type);
+		::Dynamic list_dyn();
+
+		virtual  ::lime::app::Future loadAsset(::String id,::String type);
+		::Dynamic loadAsset_dyn();
+
+		virtual  ::lime::app::Future load();
+		::Dynamic load_dyn();
+
+		virtual  ::lime::app::Future loadAudioBuffer(::String id);
+		::Dynamic loadAudioBuffer_dyn();
+
+		virtual  ::lime::app::Future loadBytes(::String id);
+		::Dynamic loadBytes_dyn();
+
+		virtual  ::lime::app::Future loadFont(::String id);
+		::Dynamic loadFont_dyn();
+
+		virtual  ::lime::app::Future loadImage(::String id);
+		::Dynamic loadImage_dyn();
+
+		virtual  ::lime::app::Future loadText(::String id);
+		::Dynamic loadText_dyn();
+
+		virtual void unload();
+		::Dynamic unload_dyn();
+
+		void _hx___assetLoaded(::String id);
+		::Dynamic _hx___assetLoaded_dyn();
+
+		::String _hx___cacheBreak(::String path);
+		::Dynamic _hx___cacheBreak_dyn();
+
+		void _hx___fromBundle( ::lime::utils::AssetBundle bundle, ::lime::utils::AssetManifest manifest);
+		::Dynamic _hx___fromBundle_dyn();
+
+		void _hx___fromManifest( ::lime::utils::AssetManifest manifest);
+		::Dynamic _hx___fromManifest_dyn();
+
+		::String _hx___resolvePath(::String path);
+		::Dynamic _hx___resolvePath_dyn();
+
+		void loadAudioBuffer_onComplete(::String id, ::lime::media::AudioBuffer audioBuffer);
+		::Dynamic loadAudioBuffer_onComplete_dyn();
+
+		void loadAudioBuffer_onError(::String id, ::Dynamic message);
+		::Dynamic loadAudioBuffer_onError_dyn();
+
+		void loadBytes_onComplete(::String id, ::haxe::io::Bytes bytes);
+		::Dynamic loadBytes_onComplete_dyn();
+
+		void loadFont_onComplete(::String id, ::lime::text::Font font);
+		::Dynamic loadFont_onComplete_dyn();
+
+		void loadImage_onComplete(::String id, ::lime::graphics::Image image);
+		::Dynamic loadImage_onComplete_dyn();
+
+		void loadText_onComplete(::String id,::String text);
+		::Dynamic loadText_onComplete_dyn();
+
+		void load_onError(::String id, ::Dynamic message);
+		::Dynamic load_onError_dyn();
+
+		void load_onProgress(::String id,int bytesLoaded,int bytesTotal);
+		::Dynamic load_onProgress_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_AssetLibrary */ 

hGameTest/bin/linux/obj/include/lime/utils/AssetManifest.h

@@ -0,0 +1,85 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_AssetManifest
+#define INCLUDED_lime_utils_AssetManifest
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,utils,AssetManifest)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES AssetManifest_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AssetManifest_obj OBJ_;
+		AssetManifest_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2ad14d63 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.AssetManifest")
+			{ 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,"lime.utils.AssetManifest"); }
+		static hx::ObjectPtr< AssetManifest_obj > __new();
+		static hx::ObjectPtr< AssetManifest_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AssetManifest_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);
+		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_("AssetManifest",9f,e1,68,3f); }
+
+		static  ::lime::utils::AssetManifest fromBytes( ::haxe::io::Bytes bytes,::String rootPath);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::lime::utils::AssetManifest fromFile(::String path,::String rootPath);
+		static ::Dynamic fromFile_dyn();
+
+		static  ::lime::app::Future loadFromBytes( ::haxe::io::Bytes bytes,::String rootPath);
+		static ::Dynamic loadFromBytes_dyn();
+
+		static  ::lime::app::Future loadFromFile(::String path,::String rootPath);
+		static ::Dynamic loadFromFile_dyn();
+
+		static  ::lime::utils::AssetManifest parse(::String data,::String rootPath);
+		static ::Dynamic parse_dyn();
+
+		static ::String _hx___resolvePath(::String path);
+		static ::Dynamic _hx___resolvePath_dyn();
+
+		static ::String _hx___resolveRootPath(::String rootPath,::String path);
+		static ::Dynamic _hx___resolveRootPath_dyn();
+
+		::cpp::VirtualArray assets;
+		::Array< ::String > libraryArgs;
+		::String libraryType;
+		::String name;
+		::String rootPath;
+		int version;
+		::String serialize();
+		::Dynamic serialize_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_AssetManifest */ 

hGameTest/bin/linux/obj/include/lime/utils/Assets.h

@@ -0,0 +1,154 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_Assets
+#define INCLUDED_lime_utils_Assets
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,_Event_Void_Void)
+HX_DECLARE_CLASS2(lime,graphics,Image)
+HX_DECLARE_CLASS2(lime,media,AudioBuffer)
+HX_DECLARE_CLASS2(lime,text,Font)
+HX_DECLARE_CLASS2(lime,utils,AssetCache)
+HX_DECLARE_CLASS2(lime,utils,AssetLibrary)
+HX_DECLARE_CLASS2(lime,utils,Assets)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES Assets_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Assets_obj OBJ_;
+		Assets_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2b49805f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils.Assets")
+			{ 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,"lime.utils.Assets"); }
+
+		inline static hx::ObjectPtr< Assets_obj > __new() {
+			hx::ObjectPtr< Assets_obj > __this = new Assets_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Assets_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Assets_obj *__this = (Assets_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Assets_obj), false, "lime.utils.Assets"));
+			*(void **)__this = Assets_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Assets_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_("Assets",a3,bc,97,80); }
+
+		static void __boot();
+		static  ::lime::utils::AssetCache cache;
+		static  ::lime::app::_Event_Void_Void onChange;
+		static  ::haxe::ds::StringMap bundlePaths;
+		static  ::haxe::ds::StringMap libraries;
+		static  ::haxe::ds::StringMap libraryPaths;
+		static bool exists(::String id,::String type);
+		static ::Dynamic exists_dyn();
+
+		static  ::Dynamic getAsset(::String id,::String type,bool useCache);
+		static ::Dynamic getAsset_dyn();
+
+		static  ::lime::media::AudioBuffer getAudioBuffer(::String id,hx::Null< bool >  useCache);
+		static ::Dynamic getAudioBuffer_dyn();
+
+		static  ::haxe::io::Bytes getBytes(::String id);
+		static ::Dynamic getBytes_dyn();
+
+		static  ::lime::text::Font getFont(::String id,hx::Null< bool >  useCache);
+		static ::Dynamic getFont_dyn();
+
+		static  ::lime::graphics::Image getImage(::String id,hx::Null< bool >  useCache);
+		static ::Dynamic getImage_dyn();
+
+		static  ::lime::utils::AssetLibrary getLibrary(::String name);
+		static ::Dynamic getLibrary_dyn();
+
+		static ::String getPath(::String id);
+		static ::Dynamic getPath_dyn();
+
+		static ::String getText(::String id);
+		static ::Dynamic getText_dyn();
+
+		static bool hasLibrary(::String name);
+		static ::Dynamic hasLibrary_dyn();
+
+		static bool isLocal(::String id,::String type,hx::Null< bool >  useCache);
+		static ::Dynamic isLocal_dyn();
+
+		static bool isValidAudio( ::lime::media::AudioBuffer buffer);
+		static ::Dynamic isValidAudio_dyn();
+
+		static bool isValidImage( ::lime::graphics::Image image);
+		static ::Dynamic isValidImage_dyn();
+
+		static ::Array< ::String > list(::String type);
+		static ::Dynamic list_dyn();
+
+		static  ::lime::app::Future loadAsset(::String id,::String type,bool useCache);
+		static ::Dynamic loadAsset_dyn();
+
+		static  ::lime::app::Future loadAudioBuffer(::String id,hx::Null< bool >  useCache);
+		static ::Dynamic loadAudioBuffer_dyn();
+
+		static  ::lime::app::Future loadBytes(::String id);
+		static ::Dynamic loadBytes_dyn();
+
+		static  ::lime::app::Future loadFont(::String id,hx::Null< bool >  useCache);
+		static ::Dynamic loadFont_dyn();
+
+		static  ::lime::app::Future loadImage(::String id,hx::Null< bool >  useCache);
+		static ::Dynamic loadImage_dyn();
+
+		static  ::lime::app::Future loadLibrary(::String id);
+		static ::Dynamic loadLibrary_dyn();
+
+		static  ::lime::app::Future loadText(::String id);
+		static ::Dynamic loadText_dyn();
+
+		static void registerLibrary(::String name, ::lime::utils::AssetLibrary library);
+		static ::Dynamic registerLibrary_dyn();
+
+		static void unloadLibrary(::String name);
+		static ::Dynamic unloadLibrary_dyn();
+
+		static ::String _hx___cacheBreak(::String path);
+		static ::Dynamic _hx___cacheBreak_dyn();
+
+		static ::String _hx___libraryNotFound(::String name);
+		static ::Dynamic _hx___libraryNotFound_dyn();
+
+		static void library_onChange();
+		static ::Dynamic library_onChange_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_Assets */ 

hGameTest/bin/linux/obj/include/lime/utils/BytePointerData.h

@@ -0,0 +1,55 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_BytePointerData
+#define INCLUDED_lime_utils_BytePointerData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,BytePointerData)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytePointerData_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BytePointerData_obj OBJ_;
+		BytePointerData_obj();
+
+	public:
+		enum { _hx_ClassId = 0x479b34cb };
+
+		void __construct( ::haxe::io::Bytes bytes,int offset);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.BytePointerData")
+			{ 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,"lime.utils.BytePointerData"); }
+		static hx::ObjectPtr< BytePointerData_obj > __new( ::haxe::io::Bytes bytes,int offset);
+		static hx::ObjectPtr< BytePointerData_obj > __alloc(hx::Ctx *_hx_ctx, ::haxe::io::Bytes bytes,int offset);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BytePointerData_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_("BytePointerData",3f,33,b7,c1); }
+
+		 ::haxe::io::Bytes bytes;
+		int offset;
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_BytePointerData */ 

hGameTest/bin/linux/obj/include/lime/utils/CompressionAlgorithm.h

@@ -0,0 +1,41 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_CompressionAlgorithm
+#define INCLUDED_lime_utils_CompressionAlgorithm
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,CompressionAlgorithm)
+namespace lime{
+namespace utils{
+
+
+class CompressionAlgorithm_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef CompressionAlgorithm_obj OBJ_;
+
+	public:
+		CompressionAlgorithm_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_("lime.utils.CompressionAlgorithm",5f,30,48,ca); }
+		::String __ToString() const { return HX_("CompressionAlgorithm.",c5,9b,61,8f) + _hx_tag; }
+
+		static ::lime::utils::CompressionAlgorithm DEFLATE;
+		static inline ::lime::utils::CompressionAlgorithm DEFLATE_dyn() { return DEFLATE; }
+		static ::lime::utils::CompressionAlgorithm GZIP;
+		static inline ::lime::utils::CompressionAlgorithm GZIP_dyn() { return GZIP; }
+		static ::lime::utils::CompressionAlgorithm LZMA;
+		static inline ::lime::utils::CompressionAlgorithm LZMA_dyn() { return LZMA; }
+		static ::lime::utils::CompressionAlgorithm ZLIB;
+		static inline ::lime::utils::CompressionAlgorithm ZLIB_dyn() { return ZLIB; }
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_CompressionAlgorithm */ 

hGameTest/bin/linux/obj/include/lime/utils/Log.h

@@ -0,0 +1,87 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_Log
+#define INCLUDED_lime_utils_Log
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS0(Sys)
+HX_DECLARE_CLASS2(lime,utils,Log)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES Log_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Log_obj OBJ_;
+		Log_obj();
+
+	public:
+		enum { _hx_ClassId = 0x18c4f454 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils.Log")
+			{ 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,"lime.utils.Log"); }
+
+		inline static hx::ObjectPtr< Log_obj > __new() {
+			hx::ObjectPtr< Log_obj > __this = new Log_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Log_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Log_obj *__this = (Log_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Log_obj), false, "lime.utils.Log"));
+			*(void **)__this = Log_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Log_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);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Log",64,0c,3a,00); }
+
+		static void __boot();
+		static int level;
+		static bool throwErrors;
+		static void debug( ::Dynamic message, ::Dynamic info);
+		static ::Dynamic debug_dyn();
+
+		static void error( ::Dynamic message, ::Dynamic info);
+		static ::Dynamic error_dyn();
+
+		static void info( ::Dynamic message, ::Dynamic info);
+		static ::Dynamic info_dyn();
+
+		static void print( ::Dynamic message);
+		static ::Dynamic print_dyn();
+
+		static void println( ::Dynamic message);
+		static ::Dynamic println_dyn();
+
+		static void verbose( ::Dynamic message, ::Dynamic info);
+		static ::Dynamic verbose_dyn();
+
+		static void warn( ::Dynamic message, ::Dynamic info);
+		static ::Dynamic warn_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_Log */ 

hGameTest/bin/linux/obj/include/lime/utils/ObjectPool.h

@@ -0,0 +1,98 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_ObjectPool
+#define INCLUDED_lime_utils_ObjectPool
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,List)
+HX_DECLARE_CLASS2(lime,utils,ObjectPool)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES ObjectPool_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ObjectPool_obj OBJ_;
+		ObjectPool_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7cea4d17 };
+
+		void __construct( ::Dynamic create, ::Dynamic clean, ::Dynamic size);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.ObjectPool")
+			{ 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,"lime.utils.ObjectPool"); }
+		static hx::ObjectPtr< ObjectPool_obj > __new( ::Dynamic create, ::Dynamic clean, ::Dynamic size);
+		static hx::ObjectPtr< ObjectPool_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic create, ::Dynamic clean, ::Dynamic size);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		static void __alloc_dynamic_functions(hx::Ctx *_hx_alloc,ObjectPool_obj *_hx_obj);
+		//~ObjectPool_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_("ObjectPool",5b,fb,45,c3); }
+
+		int activeObjects;
+		int inactiveObjects;
+		 ::Dynamic _hx___inactiveObject0;
+		 ::Dynamic _hx___inactiveObject1;
+		 ::haxe::ds::List _hx___inactiveObjectList;
+		::Dynamic _hx___pool;
+		 ::Dynamic _hx___size;
+		void add( ::Dynamic object);
+		::Dynamic add_dyn();
+
+		::Dynamic clean;
+		inline ::Dynamic &clean_dyn() {return clean; }
+
+		void clear();
+		::Dynamic clear_dyn();
+
+		::Dynamic create;
+		inline ::Dynamic &create_dyn() {return create; }
+
+		 ::Dynamic get();
+		::Dynamic get_dyn();
+
+		void release( ::Dynamic object);
+		::Dynamic release_dyn();
+
+		void remove( ::Dynamic object);
+		::Dynamic remove_dyn();
+
+		void _hx___addInactive( ::Dynamic object);
+		::Dynamic _hx___addInactive_dyn();
+
+		 ::Dynamic _hx___getInactive();
+		::Dynamic _hx___getInactive_dyn();
+
+		void _hx___removeInactive(int count);
+		::Dynamic _hx___removeInactive_dyn();
+
+		 ::Dynamic get_size();
+		::Dynamic get_size_dyn();
+
+		 ::Dynamic set_size( ::Dynamic value);
+		::Dynamic set_size_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_ObjectPool */ 

hGameTest/bin/linux/obj/include/lime/utils/Preloader.h

@@ -0,0 +1,95 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_Preloader
+#define INCLUDED_lime_utils_Preloader
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,ObjectMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Int_Void)
+HX_DECLARE_CLASS2(lime,app,_Event_Void_Void)
+HX_DECLARE_CLASS2(lime,utils,AssetLibrary)
+HX_DECLARE_CLASS2(lime,utils,Preloader)
+
+namespace lime{
+namespace utils{
+
+
+class HXCPP_CLASS_ATTRIBUTES Preloader_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Preloader_obj OBJ_;
+		Preloader_obj();
+
+	public:
+		enum { _hx_ClassId = 0x06c9d4e2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils.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,"lime.utils.Preloader"); }
+		static hx::ObjectPtr< Preloader_obj > __new();
+		static hx::ObjectPtr< Preloader_obj > __alloc(hx::Ctx *_hx_ctx);
+		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); }
+
+		bool complete;
+		 ::lime::app::_Event_Void_Void onComplete;
+		 ::lime::app::_Event_Int_Int_Void onProgress;
+		int bytesLoaded;
+		 ::haxe::ds::ObjectMap bytesLoadedCache;
+		 ::haxe::ds::StringMap bytesLoadedCache2;
+		int bytesTotal;
+		 ::haxe::ds::StringMap bytesTotalCache;
+		bool initLibraryNames;
+		::Array< ::Dynamic> libraries;
+		::Array< ::String > libraryNames;
+		int loadedLibraries;
+		bool loadedStage;
+		bool preloadComplete;
+		bool preloadStarted;
+		bool simulateProgress;
+		void addLibrary( ::lime::utils::AssetLibrary library);
+		::Dynamic addLibrary_dyn();
+
+		void addLibraryName(::String name);
+		::Dynamic addLibraryName_dyn();
+
+		void load();
+		::Dynamic load_dyn();
+
+		void loadedAssetLibrary(::String name);
+		::Dynamic loadedAssetLibrary_dyn();
+
+		void start();
+		::Dynamic start_dyn();
+
+		void update(int loaded,int total);
+		::Dynamic update_dyn();
+
+		void updateProgress();
+		::Dynamic updateProgress_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_Preloader */ 

hGameTest/bin/linux/obj/include/lime/utils/TAError.h

@@ -0,0 +1,35 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils_TAError
+#define INCLUDED_lime_utils_TAError
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,TAError)
+namespace lime{
+namespace utils{
+
+
+class TAError_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef TAError_obj OBJ_;
+
+	public:
+		TAError_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_("lime.utils.TAError",c5,58,89,62); }
+		::String __ToString() const { return HX_("TAError.",b3,90,7d,d9) + _hx_tag; }
+
+		static ::lime::utils::TAError RangeError;
+		static inline ::lime::utils::TAError RangeError_dyn() { return RangeError; }
+};
+
+} // end namespace lime
+} // end namespace utils
+
+#endif /* INCLUDED_lime_utils_TAError */ 

hGameTest/bin/linux/obj/include/lime/utils/_ArrayBuffer/ArrayBuffer_Impl_.h

@@ -0,0 +1,74 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__ArrayBuffer_ArrayBuffer_Impl_
+#define INCLUDED_lime_utils__ArrayBuffer_ArrayBuffer_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS3(lime,utils,_ArrayBuffer,ArrayBuffer_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _ArrayBuffer{
+
+
+class HXCPP_CLASS_ATTRIBUTES ArrayBuffer_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ArrayBuffer_Impl__obj OBJ_;
+		ArrayBuffer_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x07bd9007 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._ArrayBuffer.ArrayBuffer_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,"lime.utils._ArrayBuffer.ArrayBuffer_Impl_"); }
+
+		inline static hx::ObjectPtr< ArrayBuffer_Impl__obj > __new() {
+			hx::ObjectPtr< ArrayBuffer_Impl__obj > __this = new ArrayBuffer_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ArrayBuffer_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ArrayBuffer_Impl__obj *__this = (ArrayBuffer_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ArrayBuffer_Impl__obj), false, "lime.utils._ArrayBuffer.ArrayBuffer_Impl_"));
+			*(void **)__this = ArrayBuffer_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ArrayBuffer_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_("ArrayBuffer_Impl_",b9,b4,eb,eb); }
+
+		static int get_byteLength( ::haxe::io::Bytes this1);
+		static ::Dynamic get_byteLength_dyn();
+
+		static  ::haxe::io::Bytes _new(int byteLength);
+		static ::Dynamic _new_dyn();
+
+		static bool isView( ::Dynamic arg);
+		static ::Dynamic isView_dyn();
+
+		static  ::haxe::io::Bytes slice( ::haxe::io::Bytes this1,int begin, ::Dynamic end);
+		static ::Dynamic slice_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _ArrayBuffer
+
+#endif /* INCLUDED_lime_utils__ArrayBuffer_ArrayBuffer_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_Assets/LibrarySymbol.h

@@ -0,0 +1,64 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__Assets_LibrarySymbol
+#define INCLUDED_lime_utils__Assets_LibrarySymbol
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,utils,AssetLibrary)
+HX_DECLARE_CLASS3(lime,utils,_Assets,LibrarySymbol)
+
+namespace lime{
+namespace utils{
+namespace _Assets{
+
+
+class HXCPP_CLASS_ATTRIBUTES LibrarySymbol_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef LibrarySymbol_obj OBJ_;
+		LibrarySymbol_obj();
+
+	public:
+		enum { _hx_ClassId = 0x351db1c5 };
+
+		void __construct(::String id);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.utils._Assets.LibrarySymbol")
+			{ 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,"lime.utils._Assets.LibrarySymbol"); }
+		static hx::ObjectPtr< LibrarySymbol_obj > __new(::String id);
+		static hx::ObjectPtr< LibrarySymbol_obj > __alloc(hx::Ctx *_hx_ctx,::String id);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~LibrarySymbol_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_("LibrarySymbol",93,88,fe,d3); }
+
+		 ::lime::utils::AssetLibrary library;
+		::String libraryName;
+		::String symbolName;
+		bool isLocal(::String type);
+		::Dynamic isLocal_dyn();
+
+		bool exists(::String type);
+		::Dynamic exists_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _Assets
+
+#endif /* INCLUDED_lime_utils__Assets_LibrarySymbol */ 

hGameTest/bin/linux/obj/include/lime/utils/_BytePointer/BytePointer_Impl_.h

@@ -0,0 +1,121 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__BytePointer_BytePointer_Impl_
+#define INCLUDED_lime_utils__BytePointer_BytePointer_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(lime,utils,BytePointerData)
+HX_DECLARE_CLASS3(lime,utils,_BytePointer,BytePointer_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _BytePointer{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytePointer_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BytePointer_Impl__obj OBJ_;
+		BytePointer_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x2a5eae87 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._BytePointer.BytePointer_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,"lime.utils._BytePointer.BytePointer_Impl_"); }
+
+		inline static hx::ObjectPtr< BytePointer_Impl__obj > __new() {
+			hx::ObjectPtr< BytePointer_Impl__obj > __this = new BytePointer_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< BytePointer_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			BytePointer_Impl__obj *__this = (BytePointer_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(BytePointer_Impl__obj), false, "lime.utils._BytePointer.BytePointer_Impl_"));
+			*(void **)__this = BytePointer_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BytePointer_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_("BytePointer_Impl_",d5,d4,c9,f9); }
+
+		static  ::lime::utils::BytePointerData _new( ::haxe::io::Bytes bytes,hx::Null< int >  offset);
+		static ::Dynamic _new_dyn();
+
+		static void set( ::lime::utils::BytePointerData this1, ::haxe::io::Bytes bytes, ::lime::utils::ArrayBufferView bufferView, ::haxe::io::Bytes buffer, ::Dynamic offset);
+		static ::Dynamic set_dyn();
+
+		static int _hx___arrayGet( ::lime::utils::BytePointerData this1,int index);
+		static ::Dynamic _hx___arrayGet_dyn();
+
+		static int _hx___arraySet( ::lime::utils::BytePointerData this1,int index,int value);
+		static ::Dynamic _hx___arraySet_dyn();
+
+		static  ::lime::utils::BytePointerData fromArrayBufferView( ::lime::utils::ArrayBufferView arrayBufferView);
+		static ::Dynamic fromArrayBufferView_dyn();
+
+		static  ::lime::utils::BytePointerData fromArrayBuffer( ::haxe::io::Bytes buffer);
+		static ::Dynamic fromArrayBuffer_dyn();
+
+		static  ::lime::utils::BytePointerData fromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::lime::utils::BytePointerData fromBytesData(::Array< unsigned char > bytesData);
+		static ::Dynamic fromBytesData_dyn();
+
+		static  ::lime::utils::BytePointerData fromFile(::String path);
+		static ::Dynamic fromFile_dyn();
+
+		static  ::lime::utils::BytePointerData fromLimeBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromLimeBytes_dyn();
+
+		static  ::lime::utils::ArrayBufferView toUInt8Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toUInt8Array_dyn();
+
+		static  ::lime::utils::ArrayBufferView toUInt8ClampedArray( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toUInt8ClampedArray_dyn();
+
+		static  ::lime::utils::ArrayBufferView toInt8Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toInt8Array_dyn();
+
+		static  ::lime::utils::ArrayBufferView toUInt16Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toUInt16Array_dyn();
+
+		static  ::lime::utils::ArrayBufferView toInt16Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toInt16Array_dyn();
+
+		static  ::lime::utils::ArrayBufferView toUInt32Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toUInt32Array_dyn();
+
+		static  ::lime::utils::ArrayBufferView toInt32Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toInt32Array_dyn();
+
+		static  ::lime::utils::ArrayBufferView toFloat32Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toFloat32Array_dyn();
+
+		static  ::lime::utils::ArrayBufferView toFloat64Array( ::lime::utils::BytePointerData bytePointer);
+		static ::Dynamic toFloat64Array_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _BytePointer
+
+#endif /* INCLUDED_lime_utils__BytePointer_BytePointer_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_Bytes/Bytes_Impl_.h

@@ -0,0 +1,100 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__Bytes_Bytes_Impl_
+#define INCLUDED_lime_utils__Bytes_Bytes_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,utils,CompressionAlgorithm)
+HX_DECLARE_CLASS3(lime,utils,_Bytes,Bytes_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _Bytes{
+
+
+class HXCPP_CLASS_ATTRIBUTES Bytes_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Bytes_Impl__obj OBJ_;
+		Bytes_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x71d4e487 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._Bytes.Bytes_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,"lime.utils._Bytes.Bytes_Impl_"); }
+
+		inline static hx::ObjectPtr< Bytes_Impl__obj > __new() {
+			hx::ObjectPtr< Bytes_Impl__obj > __this = new Bytes_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Bytes_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			Bytes_Impl__obj *__this = (Bytes_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Bytes_Impl__obj), false, "lime.utils._Bytes.Bytes_Impl_"));
+			*(void **)__this = Bytes_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Bytes_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_("Bytes_Impl_",2b,7f,82,3d); }
+
+		static  ::haxe::io::Bytes _new(int length,::Array< unsigned char > bytesData);
+		static ::Dynamic _new_dyn();
+
+		static  ::haxe::io::Bytes alloc(int length);
+		static ::Dynamic alloc_dyn();
+
+		static  ::haxe::io::Bytes compress( ::haxe::io::Bytes this1, ::lime::utils::CompressionAlgorithm algorithm);
+		static ::Dynamic compress_dyn();
+
+		static  ::haxe::io::Bytes decompress( ::haxe::io::Bytes this1, ::lime::utils::CompressionAlgorithm algorithm);
+		static ::Dynamic decompress_dyn();
+
+		static int fastGet(::Array< unsigned char > b,int pos);
+		static ::Dynamic fastGet_dyn();
+
+		static  ::haxe::io::Bytes fromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes fromFile(::String path);
+		static ::Dynamic fromFile_dyn();
+
+		static  ::lime::app::Future loadFromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic loadFromBytes_dyn();
+
+		static  ::lime::app::Future loadFromFile(::String path);
+		static ::Dynamic loadFromFile_dyn();
+
+		static  ::haxe::io::Bytes ofData(::Array< unsigned char > b);
+		static ::Dynamic ofData_dyn();
+
+		static  ::haxe::io::Bytes ofString(::String s);
+		static ::Dynamic ofString_dyn();
+
+		static  ::haxe::io::Bytes _hx___fromNativePointer( ::Dynamic data,int length);
+		static ::Dynamic _hx___fromNativePointer_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _Bytes
+
+#endif /* INCLUDED_lime_utils__Bytes_Bytes_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_DataPointer/DataPointer_Impl_.h

@@ -0,0 +1,145 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__DataPointer_DataPointer_Impl_
+#define INCLUDED_lime_utils__DataPointer_DataPointer_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS2(lime,utils,BytePointerData)
+HX_DECLARE_CLASS3(lime,utils,_DataPointer,DataPointer_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _DataPointer{
+
+
+class HXCPP_CLASS_ATTRIBUTES DataPointer_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DataPointer_Impl__obj OBJ_;
+		DataPointer_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x11922d63 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._DataPointer.DataPointer_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,"lime.utils._DataPointer.DataPointer_Impl_"); }
+
+		inline static hx::ObjectPtr< DataPointer_Impl__obj > __new() {
+			hx::ObjectPtr< DataPointer_Impl__obj > __this = new DataPointer_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< DataPointer_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			DataPointer_Impl__obj *__this = (DataPointer_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DataPointer_Impl__obj), false, "lime.utils._DataPointer.DataPointer_Impl_"));
+			*(void **)__this = DataPointer_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DataPointer_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_("DataPointer_Impl_",73,50,78,48); }
+
+		static Float _new(Float data);
+		static ::Dynamic _new_dyn();
+
+		static Float fromInt(int value);
+		static ::Dynamic fromInt_dyn();
+
+		static Float fromBytesPointer( ::lime::utils::BytePointerData pointer);
+		static ::Dynamic fromBytesPointer_dyn();
+
+		static Float fromArrayBufferView( ::lime::utils::ArrayBufferView arrayBufferView);
+		static ::Dynamic fromArrayBufferView_dyn();
+
+		static Float fromArrayBuffer( ::haxe::io::Bytes buffer);
+		static ::Dynamic fromArrayBuffer_dyn();
+
+		static Float fromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromBytes_dyn();
+
+		static Float fromBytesData(::Array< unsigned char > bytesData);
+		static ::Dynamic fromBytesData_dyn();
+
+		static Float fromLimeBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromLimeBytes_dyn();
+
+		static Float fromCFFIPointer( ::Dynamic pointer);
+		static ::Dynamic fromCFFIPointer_dyn();
+
+		static Float fromFile(::String path);
+		static ::Dynamic fromFile_dyn();
+
+		static Float _hx___withOffset(Float data,int offset);
+		static ::Dynamic _hx___withOffset_dyn();
+
+		static bool equals(Float a,int b);
+		static ::Dynamic equals_dyn();
+
+		static bool equalsPointer(Float a,Float b);
+		static ::Dynamic equalsPointer_dyn();
+
+		static bool greaterThan(Float a,int b);
+		static ::Dynamic greaterThan_dyn();
+
+		static bool greaterThanPointer(Float a, ::Dynamic b);
+		static ::Dynamic greaterThanPointer_dyn();
+
+		static bool greaterThanOrEqual(Float a,int b);
+		static ::Dynamic greaterThanOrEqual_dyn();
+
+		static bool greaterThanOrEqualPointer(Float a, ::Dynamic b);
+		static ::Dynamic greaterThanOrEqualPointer_dyn();
+
+		static bool lessThan(Float a,int b);
+		static ::Dynamic lessThan_dyn();
+
+		static bool lessThanPointer(Float a, ::Dynamic b);
+		static ::Dynamic lessThanPointer_dyn();
+
+		static bool lessThanOrEqual(Float a,int b);
+		static ::Dynamic lessThanOrEqual_dyn();
+
+		static bool lessThanOrEqualPointer(Float a, ::Dynamic b);
+		static ::Dynamic lessThanOrEqualPointer_dyn();
+
+		static bool notEquals(Float a,int b);
+		static ::Dynamic notEquals_dyn();
+
+		static bool notEqualsPointer(Float a,Float b);
+		static ::Dynamic notEqualsPointer_dyn();
+
+		static Float plus(Float a,int b);
+		static ::Dynamic plus_dyn();
+
+		static Float plusPointer(Float a,Float b);
+		static ::Dynamic plusPointer_dyn();
+
+		static Float minus(Float a,int b);
+		static ::Dynamic minus_dyn();
+
+		static Float minusPointer(Float a,Float b);
+		static ::Dynamic minusPointer_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _DataPointer
+
+#endif /* INCLUDED_lime_utils__DataPointer_DataPointer_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_Float32Array/Float32Array_Impl_.h

@@ -0,0 +1,78 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__Float32Array_Float32Array_Impl_
+#define INCLUDED_lime_utils__Float32Array_Float32Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_Float32Array,Float32Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _Float32Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES Float32Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Float32Array_Impl__obj OBJ_;
+		Float32Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x76ee1857 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._Float32Array.Float32Array_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,"lime.utils._Float32Array.Float32Array_Impl_"); }
+
+		inline static hx::ObjectPtr< Float32Array_Impl__obj > __new() {
+			hx::ObjectPtr< Float32Array_Impl__obj > __this = new Float32Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Float32Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			Float32Array_Impl__obj *__this = (Float32Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Float32Array_Impl__obj), false, "lime.utils._Float32Array.Float32Array_Impl_"));
+			*(void **)__this = Float32Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Float32Array_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_("Float32Array_Impl_",9e,71,1e,f4); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static int hello;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _Float32Array
+
+#endif /* INCLUDED_lime_utils__Float32Array_Float32Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_Float64Array/Float64Array_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__Float64Array_Float64Array_Impl_
+#define INCLUDED_lime_utils__Float64Array_Float64Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_Float64Array,Float64Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _Float64Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES Float64Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Float64Array_Impl__obj OBJ_;
+		Float64Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x28fea341 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._Float64Array.Float64Array_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,"lime.utils._Float64Array.Float64Array_Impl_"); }
+
+		inline static hx::ObjectPtr< Float64Array_Impl__obj > __new() {
+			hx::ObjectPtr< Float64Array_Impl__obj > __this = new Float64Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Float64Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			Float64Array_Impl__obj *__this = (Float64Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Float64Array_Impl__obj), false, "lime.utils._Float64Array.Float64Array_Impl_"));
+			*(void **)__this = Float64Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Float64Array_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_("Float64Array_Impl_",5f,c5,de,48); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _Float64Array
+
+#endif /* INCLUDED_lime_utils__Float64Array_Float64Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_Int16Array/Int16Array_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__Int16Array_Int16Array_Impl_
+#define INCLUDED_lime_utils__Int16Array_Int16Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_Int16Array,Int16Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _Int16Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES Int16Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Int16Array_Impl__obj OBJ_;
+		Int16Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x4aae0a0d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._Int16Array.Int16Array_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,"lime.utils._Int16Array.Int16Array_Impl_"); }
+
+		inline static hx::ObjectPtr< Int16Array_Impl__obj > __new() {
+			hx::ObjectPtr< Int16Array_Impl__obj > __this = new Int16Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Int16Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			Int16Array_Impl__obj *__this = (Int16Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Int16Array_Impl__obj), false, "lime.utils._Int16Array.Int16Array_Impl_"));
+			*(void **)__this = Int16Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Int16Array_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_("Int16Array_Impl_",e5,45,0c,29); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _Int16Array
+
+#endif /* INCLUDED_lime_utils__Int16Array_Int16Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_Int32Array/Int32Array_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__Int32Array_Int32Array_Impl_
+#define INCLUDED_lime_utils__Int32Array_Int32Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_Int32Array,Int32Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _Int32Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES Int32Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Int32Array_Impl__obj OBJ_;
+		Int32Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x304c4419 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._Int32Array.Int32Array_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,"lime.utils._Int32Array.Int32Array_Impl_"); }
+
+		inline static hx::ObjectPtr< Int32Array_Impl__obj > __new() {
+			hx::ObjectPtr< Int32Array_Impl__obj > __this = new Int32Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Int32Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			Int32Array_Impl__obj *__this = (Int32Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Int32Array_Impl__obj), false, "lime.utils._Int32Array.Int32Array_Impl_"));
+			*(void **)__this = Int32Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Int32Array_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_("Int32Array_Impl_",6b,8a,8f,ad); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _Int32Array
+
+#endif /* INCLUDED_lime_utils__Int32Array_Int32Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_Int8Array/Int8Array_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__Int8Array_Int8Array_Impl_
+#define INCLUDED_lime_utils__Int8Array_Int8Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_Int8Array,Int8Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _Int8Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES Int8Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Int8Array_Impl__obj OBJ_;
+		Int8Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x2ec399c3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._Int8Array.Int8Array_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,"lime.utils._Int8Array.Int8Array_Impl_"); }
+
+		inline static hx::ObjectPtr< Int8Array_Impl__obj > __new() {
+			hx::ObjectPtr< Int8Array_Impl__obj > __this = new Int8Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Int8Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			Int8Array_Impl__obj *__this = (Int8Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Int8Array_Impl__obj), false, "lime.utils._Int8Array.Int8Array_Impl_"));
+			*(void **)__this = Int8Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Int8Array_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_("Int8Array_Impl_",f0,34,c2,08); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _Int8Array
+
+#endif /* INCLUDED_lime_utils__Int8Array_Int8Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_LogLevel/LogLevel_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__LogLevel_LogLevel_Impl_
+#define INCLUDED_lime_utils__LogLevel_LogLevel_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,utils,_LogLevel,LogLevel_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _LogLevel{
+
+
+class HXCPP_CLASS_ATTRIBUTES LogLevel_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef LogLevel_Impl__obj OBJ_;
+		LogLevel_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x4c2a8a4b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._LogLevel.LogLevel_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,"lime.utils._LogLevel.LogLevel_Impl_"); }
+
+		inline static hx::ObjectPtr< LogLevel_Impl__obj > __new() {
+			hx::ObjectPtr< LogLevel_Impl__obj > __this = new LogLevel_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< LogLevel_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			LogLevel_Impl__obj *__this = (LogLevel_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(LogLevel_Impl__obj), false, "lime.utils._LogLevel.LogLevel_Impl_"));
+			*(void **)__this = LogLevel_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~LogLevel_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_("LogLevel_Impl_",20,2b,1e,41); }
+
+		static void __boot();
+		static int NONE;
+		static int ERROR;
+		static int WARN;
+		static int INFO;
+		static int DEBUG;
+		static int VERBOSE;
+		static bool gt(int a,int b);
+		static ::Dynamic gt_dyn();
+
+		static bool gte(int a,int b);
+		static ::Dynamic gte_dyn();
+
+		static bool lt(int a,int b);
+		static ::Dynamic lt_dyn();
+
+		static bool lte(int a,int b);
+		static ::Dynamic lte_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _LogLevel
+
+#endif /* INCLUDED_lime_utils__LogLevel_LogLevel_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_UInt16Array/UInt16Array_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__UInt16Array_UInt16Array_Impl_
+#define INCLUDED_lime_utils__UInt16Array_UInt16Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_UInt16Array,UInt16Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _UInt16Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES UInt16Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef UInt16Array_Impl__obj OBJ_;
+		UInt16Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x4d4c9d03 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._UInt16Array.UInt16Array_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,"lime.utils._UInt16Array.UInt16Array_Impl_"); }
+
+		inline static hx::ObjectPtr< UInt16Array_Impl__obj > __new() {
+			hx::ObjectPtr< UInt16Array_Impl__obj > __this = new UInt16Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< UInt16Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			UInt16Array_Impl__obj *__this = (UInt16Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(UInt16Array_Impl__obj), false, "lime.utils._UInt16Array.UInt16Array_Impl_"));
+			*(void **)__this = UInt16Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~UInt16Array_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_("UInt16Array_Impl_",3a,00,01,a4); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _UInt16Array
+
+#endif /* INCLUDED_lime_utils__UInt16Array_UInt16Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_UInt32Array/UInt32Array_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__UInt32Array_UInt32Array_Impl_
+#define INCLUDED_lime_utils__UInt32Array_UInt32Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_UInt32Array,UInt32Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _UInt32Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES UInt32Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef UInt32Array_Impl__obj OBJ_;
+		UInt32Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x684bc143 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._UInt32Array.UInt32Array_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,"lime.utils._UInt32Array.UInt32Array_Impl_"); }
+
+		inline static hx::ObjectPtr< UInt32Array_Impl__obj > __new() {
+			hx::ObjectPtr< UInt32Array_Impl__obj > __this = new UInt32Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< UInt32Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			UInt32Array_Impl__obj *__this = (UInt32Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(UInt32Array_Impl__obj), false, "lime.utils._UInt32Array.UInt32Array_Impl_"));
+			*(void **)__this = UInt32Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~UInt32Array_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_("UInt32Array_Impl_",c0,44,84,28); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _UInt32Array
+
+#endif /* INCLUDED_lime_utils__UInt32Array_UInt32Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_UInt8Array/UInt8Array_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__UInt8Array_UInt8Array_Impl_
+#define INCLUDED_lime_utils__UInt8Array_UInt8Array_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_UInt8Array,UInt8Array_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _UInt8Array{
+
+
+class HXCPP_CLASS_ATTRIBUTES UInt8Array_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef UInt8Array_Impl__obj OBJ_;
+		UInt8Array_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x48c85fb9 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._UInt8Array.UInt8Array_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,"lime.utils._UInt8Array.UInt8Array_Impl_"); }
+
+		inline static hx::ObjectPtr< UInt8Array_Impl__obj > __new() {
+			hx::ObjectPtr< UInt8Array_Impl__obj > __this = new UInt8Array_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< UInt8Array_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			UInt8Array_Impl__obj *__this = (UInt8Array_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(UInt8Array_Impl__obj), false, "lime.utils._UInt8Array.UInt8Array_Impl_"));
+			*(void **)__this = UInt8Array_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~UInt8Array_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_("UInt8Array_Impl_",3b,dc,bf,2b); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _UInt8Array
+
+#endif /* INCLUDED_lime_utils__UInt8Array_UInt8Array_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/utils/_UInt8ClampedArray/UInt8ClampedArray_Impl_.h

@@ -0,0 +1,80 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_utils__UInt8ClampedArray_UInt8ClampedArray_Impl_
+#define INCLUDED_lime_utils__UInt8ClampedArray_UInt8ClampedArray_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+HX_DECLARE_CLASS3(lime,utils,_UInt8ClampedArray,UInt8ClampedArray_Impl_)
+
+namespace lime{
+namespace utils{
+namespace _UInt8ClampedArray{
+
+
+class HXCPP_CLASS_ATTRIBUTES UInt8ClampedArray_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef UInt8ClampedArray_Impl__obj OBJ_;
+		UInt8ClampedArray_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1ece7be3 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.utils._UInt8ClampedArray.UInt8ClampedArray_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,"lime.utils._UInt8ClampedArray.UInt8ClampedArray_Impl_"); }
+
+		inline static hx::ObjectPtr< UInt8ClampedArray_Impl__obj > __new() {
+			hx::ObjectPtr< UInt8ClampedArray_Impl__obj > __this = new UInt8ClampedArray_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< UInt8ClampedArray_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			UInt8ClampedArray_Impl__obj *__this = (UInt8ClampedArray_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(UInt8ClampedArray_Impl__obj), false, "lime.utils._UInt8ClampedArray.UInt8ClampedArray_Impl_"));
+			*(void **)__this = UInt8ClampedArray_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~UInt8ClampedArray_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_("UInt8ClampedArray_Impl_",fd,6f,af,23); }
+
+		static void __boot();
+		static int BYTES_PER_ELEMENT;
+		static  ::lime::utils::ArrayBufferView subarray( ::lime::utils::ArrayBufferView this1,int begin, ::Dynamic end);
+		static ::Dynamic subarray_dyn();
+
+		static  ::lime::utils::ArrayBufferView fromBytes( ::haxe::io::Bytes bytes, ::Dynamic byteOffset, ::Dynamic len);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::haxe::io::Bytes toBytes( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toBytes_dyn();
+
+		static int get_length( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic get_length_dyn();
+
+		static ::String toString( ::lime::utils::ArrayBufferView this1);
+		static ::Dynamic toString_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace utils
+} // end namespace _UInt8ClampedArray
+
+#endif /* INCLUDED_lime_utils__UInt8ClampedArray_UInt8ClampedArray_Impl_ */