First commit

hGameTest/bin/linux/obj/include/lime/media/AudioBuffer.h

@@ -0,0 +1,100 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_AudioBuffer
+#define INCLUDED_lime_media_AudioBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,media,AudioBuffer)
+HX_DECLARE_CLASS3(lime,media,vorbis,VorbisFile)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES AudioBuffer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AudioBuffer_obj OBJ_;
+		AudioBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2df176eb };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.media.AudioBuffer")
+			{ 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.media.AudioBuffer"); }
+		static hx::ObjectPtr< AudioBuffer_obj > __new();
+		static hx::ObjectPtr< AudioBuffer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AudioBuffer_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_("AudioBuffer",56,86,77,83); }
+
+		static  ::lime::media::AudioBuffer fromBase64(::String base64String);
+		static ::Dynamic fromBase64_dyn();
+
+		static  ::lime::media::AudioBuffer fromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::lime::media::AudioBuffer fromFile(::String path);
+		static ::Dynamic fromFile_dyn();
+
+		static  ::lime::media::AudioBuffer fromFiles(::Array< ::String > paths);
+		static ::Dynamic fromFiles_dyn();
+
+		static  ::lime::media::AudioBuffer fromVorbisFile( ::lime::media::vorbis::VorbisFile vorbisFile);
+		static ::Dynamic fromVorbisFile_dyn();
+
+		static  ::lime::app::Future loadFromFile(::String path);
+		static ::Dynamic loadFromFile_dyn();
+
+		static  ::lime::app::Future loadFromFiles(::Array< ::String > paths);
+		static ::Dynamic loadFromFiles_dyn();
+
+		static ::String _hx___getCodec( ::haxe::io::Bytes bytes);
+		static ::Dynamic _hx___getCodec_dyn();
+
+		int bitsPerSample;
+		int channels;
+		 ::lime::utils::ArrayBufferView data;
+		int sampleRate;
+		 ::Dynamic _hx___srcAudio;
+		 ::Dynamic _hx___srcBuffer;
+		 ::Dynamic _hx___srcCustom;
+		 ::Dynamic _hx___srcHowl;
+		 ::Dynamic _hx___srcSound;
+		 ::lime::media::vorbis::VorbisFile _hx___srcVorbisFile;
+		void dispose();
+		::Dynamic dispose_dyn();
+
+		 ::Dynamic get_src();
+		::Dynamic get_src_dyn();
+
+		 ::Dynamic set_src( ::Dynamic value);
+		::Dynamic set_src_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_AudioBuffer */ 

hGameTest/bin/linux/obj/include/lime/media/AudioContext.h

@@ -0,0 +1,62 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_AudioContext
+#define INCLUDED_lime_media_AudioContext
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,media,AudioContext)
+HX_DECLARE_CLASS2(lime,media,FlashAudioContext)
+HX_DECLARE_CLASS2(lime,media,HTML5AudioContext)
+HX_DECLARE_CLASS2(lime,media,OpenALAudioContext)
+HX_DECLARE_CLASS2(lime,media,WebAudioContext)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES AudioContext_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AudioContext_obj OBJ_;
+		AudioContext_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6d3d89a4 };
+
+		void __construct(::String type);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.media.AudioContext")
+			{ 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.media.AudioContext"); }
+		static hx::ObjectPtr< AudioContext_obj > __new(::String type);
+		static hx::ObjectPtr< AudioContext_obj > __alloc(hx::Ctx *_hx_ctx,::String type);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AudioContext_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_("AudioContext",d9,f7,04,ed); }
+
+		 ::Dynamic custom;
+		 ::lime::media::FlashAudioContext flash;
+		 ::lime::media::HTML5AudioContext html5;
+		 ::lime::media::OpenALAudioContext openal;
+		::String type;
+		 ::lime::media::WebAudioContext web;
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_AudioContext */ 

hGameTest/bin/linux/obj/include/lime/media/AudioManager.h

@@ -0,0 +1,74 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_AudioManager
+#define INCLUDED_lime_media_AudioManager
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,media,AudioContext)
+HX_DECLARE_CLASS2(lime,media,AudioManager)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES AudioManager_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AudioManager_obj OBJ_;
+		AudioManager_obj();
+
+	public:
+		enum { _hx_ClassId = 0x67878622 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.AudioManager")
+			{ 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.media.AudioManager"); }
+
+		inline static hx::ObjectPtr< AudioManager_obj > __new() {
+			hx::ObjectPtr< AudioManager_obj > __this = new AudioManager_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< AudioManager_obj > __alloc(hx::Ctx *_hx_ctx) {
+			AudioManager_obj *__this = (AudioManager_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(AudioManager_obj), false, "lime.media.AudioManager"));
+			*(void **)__this = AudioManager_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AudioManager_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_("AudioManager",57,f4,4e,e7); }
+
+		static  ::lime::media::AudioContext context;
+		static void init( ::lime::media::AudioContext context);
+		static ::Dynamic init_dyn();
+
+		static void resume();
+		static ::Dynamic resume_dyn();
+
+		static void shutdown();
+		static ::Dynamic shutdown_dyn();
+
+		static void suspend();
+		static ::Dynamic suspend_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_AudioManager */ 

hGameTest/bin/linux/obj/include/lime/media/AudioSource.h

@@ -0,0 +1,105 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_AudioSource
+#define INCLUDED_lime_media_AudioSource
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,_internal,backend,native,NativeAudioSource)
+HX_DECLARE_CLASS2(lime,app,_Event_Void_Void)
+HX_DECLARE_CLASS2(lime,math,Vector4)
+HX_DECLARE_CLASS2(lime,media,AudioBuffer)
+HX_DECLARE_CLASS2(lime,media,AudioSource)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES AudioSource_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AudioSource_obj OBJ_;
+		AudioSource_obj();
+
+	public:
+		enum { _hx_ClassId = 0x08bb5e62 };
+
+		void __construct( ::lime::media::AudioBuffer buffer,hx::Null< int >  __o_offset, ::Dynamic length,hx::Null< int >  __o_loops);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.media.AudioSource")
+			{ 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.media.AudioSource"); }
+		static hx::ObjectPtr< AudioSource_obj > __new( ::lime::media::AudioBuffer buffer,hx::Null< int >  __o_offset, ::Dynamic length,hx::Null< int >  __o_loops);
+		static hx::ObjectPtr< AudioSource_obj > __alloc(hx::Ctx *_hx_ctx, ::lime::media::AudioBuffer buffer,hx::Null< int >  __o_offset, ::Dynamic length,hx::Null< int >  __o_loops);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AudioSource_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_("AudioSource",31,7a,14,e5); }
+
+		 ::lime::app::_Event_Void_Void onComplete;
+		 ::lime::media::AudioBuffer buffer;
+		int offset;
+		 ::lime::_internal::backend::native::NativeAudioSource _hx___backend;
+		void dispose();
+		::Dynamic dispose_dyn();
+
+		void init();
+		::Dynamic init_dyn();
+
+		void play();
+		::Dynamic play_dyn();
+
+		void pause();
+		::Dynamic pause_dyn();
+
+		void stop();
+		::Dynamic stop_dyn();
+
+		int get_currentTime();
+		::Dynamic get_currentTime_dyn();
+
+		int set_currentTime(int value);
+		::Dynamic set_currentTime_dyn();
+
+		Float get_gain();
+		::Dynamic get_gain_dyn();
+
+		Float set_gain(Float value);
+		::Dynamic set_gain_dyn();
+
+		int get_length();
+		::Dynamic get_length_dyn();
+
+		int set_length(int value);
+		::Dynamic set_length_dyn();
+
+		int get_loops();
+		::Dynamic get_loops_dyn();
+
+		int set_loops(int value);
+		::Dynamic set_loops_dyn();
+
+		 ::lime::math::Vector4 get_position();
+		::Dynamic get_position_dyn();
+
+		 ::lime::math::Vector4 set_position( ::lime::math::Vector4 value);
+		::Dynamic set_position_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_AudioSource */ 

hGameTest/bin/linux/obj/include/lime/media/FlashAudioContext.h

@@ -0,0 +1,91 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_FlashAudioContext
+#define INCLUDED_lime_media_FlashAudioContext
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,media,AudioBuffer)
+HX_DECLARE_CLASS2(lime,media,FlashAudioContext)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES FlashAudioContext_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef FlashAudioContext_obj OBJ_;
+		FlashAudioContext_obj();
+
+	public:
+		enum { _hx_ClassId = 0x78ee545a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.FlashAudioContext")
+			{ 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.media.FlashAudioContext"); }
+		static hx::ObjectPtr< FlashAudioContext_obj > __new();
+		static hx::ObjectPtr< FlashAudioContext_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FlashAudioContext_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_("FlashAudioContext",69,b5,68,01); }
+
+		 ::lime::media::AudioBuffer createBuffer( ::Dynamic stream, ::Dynamic context);
+		::Dynamic createBuffer_dyn();
+
+		int getBytesLoaded( ::lime::media::AudioBuffer buffer);
+		::Dynamic getBytesLoaded_dyn();
+
+		int getBytesTotal( ::lime::media::AudioBuffer buffer);
+		::Dynamic getBytesTotal_dyn();
+
+		 ::Dynamic getID3( ::lime::media::AudioBuffer buffer);
+		::Dynamic getID3_dyn();
+
+		bool getIsBuffering( ::lime::media::AudioBuffer buffer);
+		::Dynamic getIsBuffering_dyn();
+
+		bool getIsURLInaccessible( ::lime::media::AudioBuffer buffer);
+		::Dynamic getIsURLInaccessible_dyn();
+
+		Float getLength( ::lime::media::AudioBuffer buffer);
+		::Dynamic getLength_dyn();
+
+		::String getURL( ::lime::media::AudioBuffer buffer);
+		::Dynamic getURL_dyn();
+
+		void close( ::lime::media::AudioBuffer buffer);
+		::Dynamic close_dyn();
+
+		Float extract( ::lime::media::AudioBuffer buffer, ::Dynamic target,Float length,hx::Null< Float >  startPosition);
+		::Dynamic extract_dyn();
+
+		void load( ::lime::media::AudioBuffer buffer, ::Dynamic stream, ::Dynamic context);
+		::Dynamic load_dyn();
+
+		void loadCompressedDataFromByteArray( ::lime::media::AudioBuffer buffer, ::Dynamic bytes,int bytesLength);
+		::Dynamic loadCompressedDataFromByteArray_dyn();
+
+		void loadPCMFromByteArray( ::lime::media::AudioBuffer buffer, ::Dynamic bytes,int samples,::String format,hx::Null< bool >  stereo,hx::Null< Float >  sampleRate);
+		::Dynamic loadPCMFromByteArray_dyn();
+
+		 ::Dynamic play( ::lime::media::AudioBuffer buffer,hx::Null< Float >  startTime,hx::Null< int >  loops, ::Dynamic sndTransform);
+		::Dynamic play_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_FlashAudioContext */ 

hGameTest/bin/linux/obj/include/lime/media/HTML5AudioContext.h

@@ -0,0 +1,165 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_HTML5AudioContext
+#define INCLUDED_lime_media_HTML5AudioContext
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,media,AudioBuffer)
+HX_DECLARE_CLASS2(lime,media,HTML5AudioContext)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES HTML5AudioContext_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef HTML5AudioContext_obj OBJ_;
+		HTML5AudioContext_obj();
+
+	public:
+		enum { _hx_ClassId = 0x15fc3c60 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.HTML5AudioContext")
+			{ 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.media.HTML5AudioContext"); }
+		static hx::ObjectPtr< HTML5AudioContext_obj > __new();
+		static hx::ObjectPtr< HTML5AudioContext_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~HTML5AudioContext_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_("HTML5AudioContext",43,4f,63,29); }
+
+		int HAVE_CURRENT_DATA;
+		int HAVE_ENOUGH_DATA;
+		int HAVE_FUTURE_DATA;
+		int HAVE_METADATA;
+		int HAVE_NOTHING;
+		int NETWORK_EMPTY;
+		int NETWORK_IDLE;
+		int NETWORK_LOADING;
+		int NETWORK_NO_SOURCE;
+		::String canPlayType( ::lime::media::AudioBuffer buffer,::String type);
+		::Dynamic canPlayType_dyn();
+
+		 ::lime::media::AudioBuffer createBuffer(::String urlString);
+		::Dynamic createBuffer_dyn();
+
+		bool getAutoplay( ::lime::media::AudioBuffer buffer);
+		::Dynamic getAutoplay_dyn();
+
+		 ::Dynamic getBuffered( ::lime::media::AudioBuffer buffer);
+		::Dynamic getBuffered_dyn();
+
+		::String getCurrentSrc( ::lime::media::AudioBuffer buffer);
+		::Dynamic getCurrentSrc_dyn();
+
+		Float getCurrentTime( ::lime::media::AudioBuffer buffer);
+		::Dynamic getCurrentTime_dyn();
+
+		Float getDefaultPlaybackRate( ::lime::media::AudioBuffer buffer);
+		::Dynamic getDefaultPlaybackRate_dyn();
+
+		Float getDuration( ::lime::media::AudioBuffer buffer);
+		::Dynamic getDuration_dyn();
+
+		bool getEnded( ::lime::media::AudioBuffer buffer);
+		::Dynamic getEnded_dyn();
+
+		 ::Dynamic getError( ::lime::media::AudioBuffer buffer);
+		::Dynamic getError_dyn();
+
+		bool getLoop( ::lime::media::AudioBuffer buffer);
+		::Dynamic getLoop_dyn();
+
+		bool getMuted( ::lime::media::AudioBuffer buffer);
+		::Dynamic getMuted_dyn();
+
+		int getNetworkState( ::lime::media::AudioBuffer buffer);
+		::Dynamic getNetworkState_dyn();
+
+		bool getPaused( ::lime::media::AudioBuffer buffer);
+		::Dynamic getPaused_dyn();
+
+		Float getPlaybackRate( ::lime::media::AudioBuffer buffer);
+		::Dynamic getPlaybackRate_dyn();
+
+		 ::Dynamic getPlayed( ::lime::media::AudioBuffer buffer);
+		::Dynamic getPlayed_dyn();
+
+		::String getPreload( ::lime::media::AudioBuffer buffer);
+		::Dynamic getPreload_dyn();
+
+		int getReadyState( ::lime::media::AudioBuffer buffer);
+		::Dynamic getReadyState_dyn();
+
+		 ::Dynamic getSeekable( ::lime::media::AudioBuffer buffer);
+		::Dynamic getSeekable_dyn();
+
+		bool getSeeking( ::lime::media::AudioBuffer buffer);
+		::Dynamic getSeeking_dyn();
+
+		::String getSrc( ::lime::media::AudioBuffer buffer);
+		::Dynamic getSrc_dyn();
+
+		Float getStartTime( ::lime::media::AudioBuffer buffer);
+		::Dynamic getStartTime_dyn();
+
+		Float getVolume( ::lime::media::AudioBuffer buffer);
+		::Dynamic getVolume_dyn();
+
+		void load( ::lime::media::AudioBuffer buffer);
+		::Dynamic load_dyn();
+
+		void pause( ::lime::media::AudioBuffer buffer);
+		::Dynamic pause_dyn();
+
+		void play( ::lime::media::AudioBuffer buffer);
+		::Dynamic play_dyn();
+
+		void setAutoplay( ::lime::media::AudioBuffer buffer,bool value);
+		::Dynamic setAutoplay_dyn();
+
+		void setCurrentTime( ::lime::media::AudioBuffer buffer,Float value);
+		::Dynamic setCurrentTime_dyn();
+
+		void setDefaultPlaybackRate( ::lime::media::AudioBuffer buffer,Float value);
+		::Dynamic setDefaultPlaybackRate_dyn();
+
+		void setLoop( ::lime::media::AudioBuffer buffer,bool value);
+		::Dynamic setLoop_dyn();
+
+		void setMuted( ::lime::media::AudioBuffer buffer,bool value);
+		::Dynamic setMuted_dyn();
+
+		void setPlaybackRate( ::lime::media::AudioBuffer buffer,Float value);
+		::Dynamic setPlaybackRate_dyn();
+
+		void setPreload( ::lime::media::AudioBuffer buffer,::String value);
+		::Dynamic setPreload_dyn();
+
+		void setSrc( ::lime::media::AudioBuffer buffer,::String value);
+		::Dynamic setSrc_dyn();
+
+		void setVolume( ::lime::media::AudioBuffer buffer,Float value);
+		::Dynamic setVolume_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_HTML5AudioContext */ 

hGameTest/bin/linux/obj/include/lime/media/OpenALAudioContext.h

@@ -0,0 +1,405 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_OpenALAudioContext
+#define INCLUDED_lime_media_OpenALAudioContext
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,media,OpenALAudioContext)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES OpenALAudioContext_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef OpenALAudioContext_obj OBJ_;
+		OpenALAudioContext_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f0ec3a5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.OpenALAudioContext")
+			{ 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.media.OpenALAudioContext"); }
+		static hx::ObjectPtr< OpenALAudioContext_obj > __new();
+		static hx::ObjectPtr< OpenALAudioContext_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~OpenALAudioContext_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_("OpenALAudioContext",ae,da,cd,a1); }
+
+		int NONE;
+		int FALSE;
+		int TRUE;
+		int SOURCE_RELATIVE;
+		int CONE_INNER_ANGLE;
+		int CONE_OUTER_ANGLE;
+		int PITCH;
+		int POSITION;
+		int DIRECTION;
+		int VELOCITY;
+		int LOOPING;
+		int BUFFER;
+		int GAIN;
+		int MIN_GAIN;
+		int MAX_GAIN;
+		int ORIENTATION;
+		int SOURCE_STATE;
+		int INITIAL;
+		int PLAYING;
+		int PAUSED;
+		int STOPPED;
+		int BUFFERS_QUEUED;
+		int BUFFERS_PROCESSED;
+		int REFERENCE_DISTANCE;
+		int ROLLOFF_FACTOR;
+		int CONE_OUTER_GAIN;
+		int MAX_DISTANCE;
+		int SEC_OFFSET;
+		int SAMPLE_OFFSET;
+		int BYTE_OFFSET;
+		int SOURCE_TYPE;
+		int STATIC;
+		int STREAMING;
+		int UNDETERMINED;
+		int FORMAT_MONO8;
+		int FORMAT_MONO16;
+		int FORMAT_STEREO8;
+		int FORMAT_STEREO16;
+		int FREQUENCY;
+		int BITS;
+		int CHANNELS;
+		int SIZE;
+		int NO_ERROR;
+		int INVALID_NAME;
+		int INVALID_ENUM;
+		int INVALID_VALUE;
+		int INVALID_OPERATION;
+		int OUT_OF_MEMORY;
+		int VENDOR;
+		int VERSION;
+		int RENDERER;
+		int EXTENSIONS;
+		int DOPPLER_FACTOR;
+		int SPEED_OF_SOUND;
+		int DOPPLER_VELOCITY;
+		int DISTANCE_MODEL;
+		int INVERSE_DISTANCE;
+		int INVERSE_DISTANCE_CLAMPED;
+		int LINEAR_DISTANCE;
+		int LINEAR_DISTANCE_CLAMPED;
+		int EXPONENT_DISTANCE;
+		int EXPONENT_DISTANCE_CLAMPED;
+		int REFRESH;
+		int SYNC;
+		int MONO_SOURCES;
+		int STEREO_SOURCES;
+		int INVALID_DEVICE;
+		int INVALID_CONTEXT;
+		int ATTRIBUTES_SIZE;
+		int ALL_ATTRIBUTES;
+		int DEFAULT_DEVICE_SPECIFIER;
+		int DEVICE_SPECIFIER;
+		int ENUMERATE_ALL_EXT;
+		int DEFAULT_ALL_DEVICES_SPECIFIER;
+		int ALL_DEVICES_SPECIFIER;
+		void bufferData( ::Dynamic buffer,int format, ::lime::utils::ArrayBufferView data,int size,int freq);
+		::Dynamic bufferData_dyn();
+
+		void buffer3f( ::Dynamic buffer,int param,Float value1,Float value2,Float value3);
+		::Dynamic buffer3f_dyn();
+
+		void buffer3i( ::Dynamic buffer,int param,int value1,int value2,int value3);
+		::Dynamic buffer3i_dyn();
+
+		void bufferf( ::Dynamic buffer,int param,Float value);
+		::Dynamic bufferf_dyn();
+
+		void bufferfv( ::Dynamic buffer,int param,::Array< Float > values);
+		::Dynamic bufferfv_dyn();
+
+		void bufferi( ::Dynamic buffer,int param,int value);
+		::Dynamic bufferi_dyn();
+
+		void bufferiv( ::Dynamic buffer,int param,::Array< int > values);
+		::Dynamic bufferiv_dyn();
+
+		bool closeDevice( ::Dynamic device);
+		::Dynamic closeDevice_dyn();
+
+		 ::Dynamic createContext( ::Dynamic device,::Array< int > attrlist);
+		::Dynamic createContext_dyn();
+
+		 ::Dynamic createBuffer();
+		::Dynamic createBuffer_dyn();
+
+		 ::Dynamic createSource();
+		::Dynamic createSource_dyn();
+
+		void deleteBuffer( ::Dynamic buffer);
+		::Dynamic deleteBuffer_dyn();
+
+		void deleteBuffers(::cpp::VirtualArray buffers);
+		::Dynamic deleteBuffers_dyn();
+
+		void deleteSource( ::Dynamic source);
+		::Dynamic deleteSource_dyn();
+
+		void deleteSources(::cpp::VirtualArray sources);
+		::Dynamic deleteSources_dyn();
+
+		void destroyContext( ::Dynamic context);
+		::Dynamic destroyContext_dyn();
+
+		void disable(int capability);
+		::Dynamic disable_dyn();
+
+		void distanceModel(int distanceModel);
+		::Dynamic distanceModel_dyn();
+
+		void dopplerFactor(Float value);
+		::Dynamic dopplerFactor_dyn();
+
+		void dopplerVelocity(Float value);
+		::Dynamic dopplerVelocity_dyn();
+
+		void enable(int capability);
+		::Dynamic enable_dyn();
+
+		 ::Dynamic genSource();
+		::Dynamic genSource_dyn();
+
+		::cpp::VirtualArray genSources(int n);
+		::Dynamic genSources_dyn();
+
+		 ::Dynamic genBuffer();
+		::Dynamic genBuffer_dyn();
+
+		::cpp::VirtualArray genBuffers(int n);
+		::Dynamic genBuffers_dyn();
+
+		bool getBoolean(int param);
+		::Dynamic getBoolean_dyn();
+
+		::Array< bool > getBooleanv(int param,hx::Null< int >  count);
+		::Dynamic getBooleanv_dyn();
+
+		::Array< Float > getBuffer3f( ::Dynamic buffer,int param);
+		::Dynamic getBuffer3f_dyn();
+
+		::Array< int > getBuffer3i( ::Dynamic buffer,int param);
+		::Dynamic getBuffer3i_dyn();
+
+		Float getBufferf( ::Dynamic buffer,int param);
+		::Dynamic getBufferf_dyn();
+
+		::Array< Float > getBufferfv( ::Dynamic buffer,int param,hx::Null< int >  count);
+		::Dynamic getBufferfv_dyn();
+
+		int getBufferi( ::Dynamic buffer,int param);
+		::Dynamic getBufferi_dyn();
+
+		::Array< int > getBufferiv( ::Dynamic buffer,int param,hx::Null< int >  count);
+		::Dynamic getBufferiv_dyn();
+
+		 ::Dynamic getContextsDevice( ::Dynamic context);
+		::Dynamic getContextsDevice_dyn();
+
+		 ::Dynamic getCurrentContext();
+		::Dynamic getCurrentContext_dyn();
+
+		Float getDouble(int param);
+		::Dynamic getDouble_dyn();
+
+		::Array< Float > getDoublev(int param,hx::Null< int >  count);
+		::Dynamic getDoublev_dyn();
+
+		int getEnumValue(::String ename);
+		::Dynamic getEnumValue_dyn();
+
+		int getError( ::Dynamic device);
+		::Dynamic getError_dyn();
+
+		::String getErrorString( ::Dynamic device);
+		::Dynamic getErrorString_dyn();
+
+		Float getFloat(int param);
+		::Dynamic getFloat_dyn();
+
+		::Array< Float > getFloatv(int param,hx::Null< int >  count);
+		::Dynamic getFloatv_dyn();
+
+		int getInteger(int param);
+		::Dynamic getInteger_dyn();
+
+		::Array< int > getIntegerv(int param,hx::Null< int >  count, ::Dynamic device);
+		::Dynamic getIntegerv_dyn();
+
+		::Array< Float > getListener3f(int param);
+		::Dynamic getListener3f_dyn();
+
+		::Array< int > getListener3i(int param);
+		::Dynamic getListener3i_dyn();
+
+		Float getListenerf(int param);
+		::Dynamic getListenerf_dyn();
+
+		::Array< Float > getListenerfv(int param,hx::Null< int >  count);
+		::Dynamic getListenerfv_dyn();
+
+		int getListeneri(int param);
+		::Dynamic getListeneri_dyn();
+
+		::Array< int > getListeneriv(int param,hx::Null< int >  count);
+		::Dynamic getListeneriv_dyn();
+
+		 ::Dynamic getProcAddress(::String fname);
+		::Dynamic getProcAddress_dyn();
+
+		::Array< Float > getSource3f( ::Dynamic source,int param);
+		::Dynamic getSource3f_dyn();
+
+		Float getSourcef( ::Dynamic source,int param);
+		::Dynamic getSourcef_dyn();
+
+		::Array< int > getSource3i( ::Dynamic source,int param);
+		::Dynamic getSource3i_dyn();
+
+		::Array< Float > getSourcefv( ::Dynamic source,int param,hx::Null< int >  count);
+		::Dynamic getSourcefv_dyn();
+
+		 ::Dynamic getSourcei( ::Dynamic source,int param);
+		::Dynamic getSourcei_dyn();
+
+		::Array< int > getSourceiv( ::Dynamic source,int param,hx::Null< int >  count);
+		::Dynamic getSourceiv_dyn();
+
+		::String getString(int param, ::Dynamic device);
+		::Dynamic getString_dyn();
+
+		bool isBuffer( ::Dynamic buffer);
+		::Dynamic isBuffer_dyn();
+
+		bool isEnabled(int capability);
+		::Dynamic isEnabled_dyn();
+
+		bool isExtensionPresent(::String extname);
+		::Dynamic isExtensionPresent_dyn();
+
+		bool isSource( ::Dynamic source);
+		::Dynamic isSource_dyn();
+
+		void listener3f(int param,Float value1,Float value2,Float value3);
+		::Dynamic listener3f_dyn();
+
+		void listener3i(int param,int value1,int value2,int value3);
+		::Dynamic listener3i_dyn();
+
+		void listenerf(int param,Float value);
+		::Dynamic listenerf_dyn();
+
+		void listenerfv(int param,::Array< Float > values);
+		::Dynamic listenerfv_dyn();
+
+		void listeneri(int param,int value);
+		::Dynamic listeneri_dyn();
+
+		void listeneriv(int param,::Array< int > values);
+		::Dynamic listeneriv_dyn();
+
+		bool makeContextCurrent( ::Dynamic context);
+		::Dynamic makeContextCurrent_dyn();
+
+		 ::Dynamic openDevice(::String deviceName);
+		::Dynamic openDevice_dyn();
+
+		void pauseDevice( ::Dynamic device);
+		::Dynamic pauseDevice_dyn();
+
+		void processContext( ::Dynamic context);
+		::Dynamic processContext_dyn();
+
+		void resumeDevice( ::Dynamic device);
+		::Dynamic resumeDevice_dyn();
+
+		void source3f( ::Dynamic source,int param,Float value1,Float value2,Float value3);
+		::Dynamic source3f_dyn();
+
+		void source3i( ::Dynamic source,int param,int value1,int value2,int value3);
+		::Dynamic source3i_dyn();
+
+		void sourcef( ::Dynamic source,int param,Float value);
+		::Dynamic sourcef_dyn();
+
+		void sourcefv( ::Dynamic source,int param,::Array< Float > values);
+		::Dynamic sourcefv_dyn();
+
+		void sourcei( ::Dynamic source,int param, ::Dynamic value);
+		::Dynamic sourcei_dyn();
+
+		void sourceiv( ::Dynamic source,int param,::Array< int > values);
+		::Dynamic sourceiv_dyn();
+
+		void sourcePlay( ::Dynamic source);
+		::Dynamic sourcePlay_dyn();
+
+		void sourcePlayv(::cpp::VirtualArray sources);
+		::Dynamic sourcePlayv_dyn();
+
+		void sourceStop( ::Dynamic source);
+		::Dynamic sourceStop_dyn();
+
+		void sourceStopv(::cpp::VirtualArray sources);
+		::Dynamic sourceStopv_dyn();
+
+		void sourceRewind( ::Dynamic source);
+		::Dynamic sourceRewind_dyn();
+
+		void sourceRewindv(::cpp::VirtualArray sources);
+		::Dynamic sourceRewindv_dyn();
+
+		void sourcePause( ::Dynamic source);
+		::Dynamic sourcePause_dyn();
+
+		void sourcePausev(::cpp::VirtualArray sources);
+		::Dynamic sourcePausev_dyn();
+
+		void sourceQueueBuffer( ::Dynamic source, ::Dynamic buffer);
+		::Dynamic sourceQueueBuffer_dyn();
+
+		void sourceQueueBuffers( ::Dynamic source,int nb,::cpp::VirtualArray buffers);
+		::Dynamic sourceQueueBuffers_dyn();
+
+		int sourceUnqueueBuffer( ::Dynamic source);
+		::Dynamic sourceUnqueueBuffer_dyn();
+
+		::cpp::VirtualArray sourceUnqueueBuffers( ::Dynamic source,int nb);
+		::Dynamic sourceUnqueueBuffers_dyn();
+
+		void speedOfSound(Float value);
+		::Dynamic speedOfSound_dyn();
+
+		void suspendContext( ::Dynamic context);
+		::Dynamic suspendContext_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_OpenALAudioContext */ 

hGameTest/bin/linux/obj/include/lime/media/WebAudioContext.h

@@ -0,0 +1,131 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_WebAudioContext
+#define INCLUDED_lime_media_WebAudioContext
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_8f3cbf1fbb3e6ea9_14_new)
+HX_DECLARE_CLASS2(lime,media,WebAudioContext)
+
+namespace lime{
+namespace media{
+
+
+class HXCPP_CLASS_ATTRIBUTES WebAudioContext_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef WebAudioContext_obj OBJ_;
+		WebAudioContext_obj();
+
+	public:
+		enum { _hx_ClassId = 0x30db9fc6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.media.WebAudioContext")
+			{ 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.media.WebAudioContext"); }
+
+		inline static hx::ObjectPtr< WebAudioContext_obj > __new() {
+			hx::ObjectPtr< WebAudioContext_obj > __this = new WebAudioContext_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< WebAudioContext_obj > __alloc(hx::Ctx *_hx_ctx) {
+			WebAudioContext_obj *__this = (WebAudioContext_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(WebAudioContext_obj), true, "lime.media.WebAudioContext"));
+			*(void **)__this = WebAudioContext_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_8f3cbf1fbb3e6ea9_14_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~WebAudioContext_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_("WebAudioContext",4d,32,9a,10); }
+
+		int activeSourceCount;
+		Float currentTime;
+		 ::Dynamic destination;
+		 ::Dynamic listener;
+		 ::Dynamic oncomplete;
+		Float sampleRate;
+		 ::Dynamic createAnalyser();
+		::Dynamic createAnalyser_dyn();
+
+		 ::Dynamic createBiquadFilter();
+		::Dynamic createBiquadFilter_dyn();
+
+		 ::Dynamic createBuffer( ::Dynamic buffer,bool mixToMono);
+		::Dynamic createBuffer_dyn();
+
+		 ::Dynamic createBufferSource();
+		::Dynamic createBufferSource_dyn();
+
+		 ::Dynamic createChannelMerger( ::Dynamic numberOfInputs);
+		::Dynamic createChannelMerger_dyn();
+
+		 ::Dynamic createChannelSplitter( ::Dynamic numberOfOutputs);
+		::Dynamic createChannelSplitter_dyn();
+
+		 ::Dynamic createConvolver();
+		::Dynamic createConvolver_dyn();
+
+		 ::Dynamic createDelay( ::Dynamic maxDelayTime);
+		::Dynamic createDelay_dyn();
+
+		 ::Dynamic createDynamicsCompressor();
+		::Dynamic createDynamicsCompressor_dyn();
+
+		 ::Dynamic createGain();
+		::Dynamic createGain_dyn();
+
+		 ::Dynamic createMediaElementSource( ::Dynamic mediaElement);
+		::Dynamic createMediaElementSource_dyn();
+
+		 ::Dynamic createMediaStreamSource( ::Dynamic mediaStream);
+		::Dynamic createMediaStreamSource_dyn();
+
+		 ::Dynamic createOscillator();
+		::Dynamic createOscillator_dyn();
+
+		 ::Dynamic createPanner();
+		::Dynamic createPanner_dyn();
+
+		 ::Dynamic createScriptProcessor(int bufferSize, ::Dynamic numberOfInputChannels, ::Dynamic numberOfOutputChannels);
+		::Dynamic createScriptProcessor_dyn();
+
+		 ::Dynamic createWaveShaper();
+		::Dynamic createWaveShaper_dyn();
+
+		 ::Dynamic createWaveTable( ::Dynamic real, ::Dynamic imag);
+		::Dynamic createWaveTable_dyn();
+
+		void decodeAudioData( ::Dynamic audioData, ::Dynamic successCallback, ::Dynamic errorCallback);
+		::Dynamic decodeAudioData_dyn();
+
+		void startRendering();
+		::Dynamic startRendering_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+
+#endif /* INCLUDED_lime_media_WebAudioContext */ 

hGameTest/bin/linux/obj/include/lime/media/openal/AL.h

@@ -0,0 +1,561 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal_AL
+#define INCLUDED_lime_media_openal_AL
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,media,openal,AL)
+HX_DECLARE_CLASS2(lime,utils,ArrayBufferView)
+
+namespace lime{
+namespace media{
+namespace openal{
+
+
+class HXCPP_CLASS_ATTRIBUTES AL_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef AL_obj OBJ_;
+		AL_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1527a64f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal.AL")
+			{ 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.media.openal.AL"); }
+
+		inline static hx::ObjectPtr< AL_obj > __new() {
+			hx::ObjectPtr< AL_obj > __this = new AL_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< AL_obj > __alloc(hx::Ctx *_hx_ctx) {
+			AL_obj *__this = (AL_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(AL_obj), false, "lime.media.openal.AL"));
+			*(void **)__this = AL_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~AL_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_("AL",eb,38,00,00); }
+
+		static void __boot();
+		static int NONE;
+		static int FALSE;
+		static int TRUE;
+		static int SOURCE_RELATIVE;
+		static int CONE_INNER_ANGLE;
+		static int CONE_OUTER_ANGLE;
+		static int PITCH;
+		static int POSITION;
+		static int DIRECTION;
+		static int VELOCITY;
+		static int LOOPING;
+		static int BUFFER;
+		static int GAIN;
+		static int MIN_GAIN;
+		static int MAX_GAIN;
+		static int ORIENTATION;
+		static int SOURCE_STATE;
+		static int INITIAL;
+		static int PLAYING;
+		static int PAUSED;
+		static int STOPPED;
+		static int BUFFERS_QUEUED;
+		static int BUFFERS_PROCESSED;
+		static int REFERENCE_DISTANCE;
+		static int ROLLOFF_FACTOR;
+		static int CONE_OUTER_GAIN;
+		static int MAX_DISTANCE;
+		static int SEC_OFFSET;
+		static int SAMPLE_OFFSET;
+		static int BYTE_OFFSET;
+		static int SOURCE_TYPE;
+		static int STATIC;
+		static int STREAMING;
+		static int UNDETERMINED;
+		static int FORMAT_MONO8;
+		static int FORMAT_MONO16;
+		static int FORMAT_STEREO8;
+		static int FORMAT_STEREO16;
+		static int FREQUENCY;
+		static int BITS;
+		static int CHANNELS;
+		static int SIZE;
+		static int NO_ERROR;
+		static int INVALID_NAME;
+		static int INVALID_ENUM;
+		static int INVALID_VALUE;
+		static int INVALID_OPERATION;
+		static int OUT_OF_MEMORY;
+		static int VENDOR;
+		static int VERSION;
+		static int RENDERER;
+		static int EXTENSIONS;
+		static int DOPPLER_FACTOR;
+		static int SPEED_OF_SOUND;
+		static int DOPPLER_VELOCITY;
+		static int DISTANCE_MODEL;
+		static int INVERSE_DISTANCE;
+		static int INVERSE_DISTANCE_CLAMPED;
+		static int LINEAR_DISTANCE;
+		static int LINEAR_DISTANCE_CLAMPED;
+		static int EXPONENT_DISTANCE;
+		static int EXPONENT_DISTANCE_CLAMPED;
+		static int METERS_PER_UNIT;
+		static int DIRECT_FILTER;
+		static int AUXILIARY_SEND_FILTER;
+		static int AIR_ABSORPTION_FACTOR;
+		static int ROOM_ROLLOFF_FACTOR;
+		static int CONE_OUTER_GAINHF;
+		static int DIRECT_FILTER_GAINHF_AUTO;
+		static int AUXILIARY_SEND_FILTER_GAIN_AUTO;
+		static int AUXILIARY_SEND_FILTER_GAINHF_AUTO;
+		static int REVERB_DENSITY;
+		static int REVERB_DIFFUSION;
+		static int REVERB_GAIN;
+		static int REVERB_GAINHF;
+		static int REVERB_DECAY_TIME;
+		static int REVERB_DECAY_HFRATIO;
+		static int REVERB_REFLECTIONS_GAIN;
+		static int REVERB_REFLECTIONS_DELAY;
+		static int REVERB_LATE_REVERB_GAIN;
+		static int REVERB_LATE_REVERB_DELAY;
+		static int REVERB_AIR_ABSORPTION_GAINHF;
+		static int REVERB_ROOM_ROLLOFF_FACTOR;
+		static int REVERB_DECAY_HFLIMIT;
+		static int EAXREVERB_DENSITY;
+		static int EAXREVERB_DIFFUSION;
+		static int EAXREVERB_GAIN;
+		static int EAXREVERB_GAINHF;
+		static int EAXREVERB_GAINLF;
+		static int EAXREVERB_DECAY_TIME;
+		static int EAXREVERB_DECAY_HFRATIO;
+		static int EAXREVERB_DECAY_LFRATIO;
+		static int EAXREVERB_REFLECTIONS_GAIN;
+		static int EAXREVERB_REFLECTIONS_DELAY;
+		static int EAXREVERB_REFLECTIONS_PAN;
+		static int EAXREVERB_LATE_REVERB_GAIN;
+		static int EAXREVERB_LATE_REVERB_DELAY;
+		static int EAXREVERB_LATE_REVERB_PAN;
+		static int EAXREVERB_ECHO_TIME;
+		static int EAXREVERB_ECHO_DEPTH;
+		static int EAXREVERB_MODULATION_TIME;
+		static int EAXREVERB_MODULATION_DEPTH;
+		static int EAXREVERB_AIR_ABSORPTION_GAINHF;
+		static int EAXREVERB_HFREFERENCE;
+		static int EAXREVERB_LFREFERENCE;
+		static int EAXREVERB_ROOM_ROLLOFF_FACTOR;
+		static int EAXREVERB_DECAY_HFLIMIT;
+		static int CHORUS_WAVEFORM;
+		static int CHORUS_PHASE;
+		static int CHORUS_RATE;
+		static int CHORUS_DEPTH;
+		static int CHORUS_FEEDBACK;
+		static int CHORUS_DELAY;
+		static int DISTORTION_EDGE;
+		static int DISTORTION_GAIN;
+		static int DISTORTION_LOWPASS_CUTOFF;
+		static int DISTORTION_EQCENTER;
+		static int DISTORTION_EQBANDWIDTH;
+		static int ECHO_DELAY;
+		static int ECHO_LRDELAY;
+		static int ECHO_DAMPING;
+		static int ECHO_FEEDBACK;
+		static int ECHO_SPREAD;
+		static int FLANGER_WAVEFORM;
+		static int FLANGER_PHASE;
+		static int FLANGER_RATE;
+		static int FLANGER_DEPTH;
+		static int FLANGER_FEEDBACK;
+		static int FLANGER_DELAY;
+		static int FREQUENCY_SHIFTER_FREQUENCY;
+		static int FREQUENCY_SHIFTER_LEFT_DIRECTION;
+		static int FREQUENCY_SHIFTER_RIGHT_DIRECTION;
+		static int VOCAL_MORPHER_PHONEMEA;
+		static int VOCAL_MORPHER_PHONEMEA_COARSE_TUNING;
+		static int VOCAL_MORPHER_PHONEMEB;
+		static int VOCAL_MORPHER_PHONEMEB_COARSE_TUNING;
+		static int VOCAL_MORPHER_WAVEFORM;
+		static int VOCAL_MORPHER_RATE;
+		static int PITCH_SHIFTER_COARSE_TUNE;
+		static int PITCH_SHIFTER_FINE_TUNE;
+		static int RING_MODULATOR_FREQUENCY;
+		static int RING_MODULATOR_HIGHPASS_CUTOFF;
+		static int RING_MODULATOR_WAVEFORM;
+		static int AUTOWAH_ATTACK_TIME;
+		static int AUTOWAH_RELEASE_TIME;
+		static int AUTOWAH_RESONANCE;
+		static int AUTOWAH_PEAK_GAIN;
+		static int COMPRESSOR_ONOFF;
+		static int EQUALIZER_LOW_GAIN;
+		static int EQUALIZER_LOW_CUTOFF;
+		static int EQUALIZER_MID1_GAIN;
+		static int EQUALIZER_MID1_CENTER;
+		static int EQUALIZER_MID1_WIDTH;
+		static int EQUALIZER_MID2_GAIN;
+		static int EQUALIZER_MID2_CENTER;
+		static int EQUALIZER_MID2_WIDTH;
+		static int EQUALIZER_HIGH_GAIN;
+		static int EQUALIZER_HIGH_CUTOFF;
+		static int EFFECT_FIRST_PARAMETER;
+		static int EFFECT_LAST_PARAMETER;
+		static int EFFECT_TYPE;
+		static int EFFECT_NULL;
+		static int EFFECT_EAXREVERB;
+		static int EFFECT_REVERB;
+		static int EFFECT_CHORUS;
+		static int EFFECT_DISTORTION;
+		static int EFFECT_ECHO;
+		static int EFFECT_FLANGER;
+		static int EFFECT_FREQUENCY_SHIFTER;
+		static int EFFECT_VOCAL_MORPHER;
+		static int EFFECT_PITCH_SHIFTER;
+		static int EFFECT_RING_MODULATOR;
+		static int FFECT_AUTOWAH;
+		static int EFFECT_COMPRESSOR;
+		static int EFFECT_EQUALIZER;
+		static int EFFECTSLOT_EFFECT;
+		static int EFFECTSLOT_GAIN;
+		static int EFFECTSLOT_AUXILIARY_SEND_AUTO;
+		static int LOWPASS_GAIN;
+		static int LOWPASS_GAINHF;
+		static int HIGHPASS_GAIN;
+		static int HIGHPASS_GAINLF;
+		static int BANDPASS_GAIN;
+		static int BANDPASS_GAINLF;
+		static int BANDPASS_GAINHF;
+		static int FILTER_FIRST_PARAMETER;
+		static int FILTER_LAST_PARAMETER;
+		static int FILTER_TYPE;
+		static int FILTER_NULL;
+		static int FILTER_LOWPASS;
+		static int FILTER_HIGHPASS;
+		static int FILTER_BANDPASS;
+		static void removeDirectFilter( ::Dynamic source);
+		static ::Dynamic removeDirectFilter_dyn();
+
+		static void removeSend( ::Dynamic source,int index);
+		static ::Dynamic removeSend_dyn();
+
+		static void auxf( ::Dynamic aux,int param,Float value);
+		static ::Dynamic auxf_dyn();
+
+		static void auxfv( ::Dynamic aux,int param,::Array< Float > values);
+		static ::Dynamic auxfv_dyn();
+
+		static void auxi( ::Dynamic aux,int param, ::Dynamic value);
+		static ::Dynamic auxi_dyn();
+
+		static void auxiv( ::Dynamic aux,int param,::Array< int > values);
+		static ::Dynamic auxiv_dyn();
+
+		static void bufferData( ::Dynamic buffer,int format, ::lime::utils::ArrayBufferView data,int size,int freq);
+		static ::Dynamic bufferData_dyn();
+
+		static void buffer3f( ::Dynamic buffer,int param,Float value1,Float value2,Float value3);
+		static ::Dynamic buffer3f_dyn();
+
+		static void buffer3i( ::Dynamic buffer,int param,int value1,int value2,int value3);
+		static ::Dynamic buffer3i_dyn();
+
+		static void bufferf( ::Dynamic buffer,int param,Float value);
+		static ::Dynamic bufferf_dyn();
+
+		static void bufferfv( ::Dynamic buffer,int param,::Array< Float > values);
+		static ::Dynamic bufferfv_dyn();
+
+		static void bufferi( ::Dynamic buffer,int param,int value);
+		static ::Dynamic bufferi_dyn();
+
+		static void bufferiv( ::Dynamic buffer,int param,::Array< int > values);
+		static ::Dynamic bufferiv_dyn();
+
+		static  ::Dynamic createAux();
+		static ::Dynamic createAux_dyn();
+
+		static  ::Dynamic createBuffer();
+		static ::Dynamic createBuffer_dyn();
+
+		static  ::Dynamic createEffect();
+		static ::Dynamic createEffect_dyn();
+
+		static  ::Dynamic createFilter();
+		static ::Dynamic createFilter_dyn();
+
+		static  ::Dynamic createSource();
+		static ::Dynamic createSource_dyn();
+
+		static void deleteBuffer( ::Dynamic buffer);
+		static ::Dynamic deleteBuffer_dyn();
+
+		static void deleteBuffers(::cpp::VirtualArray buffers);
+		static ::Dynamic deleteBuffers_dyn();
+
+		static void deleteSource( ::Dynamic source);
+		static ::Dynamic deleteSource_dyn();
+
+		static void deleteSources(::cpp::VirtualArray sources);
+		static ::Dynamic deleteSources_dyn();
+
+		static void disable(int capability);
+		static ::Dynamic disable_dyn();
+
+		static void distanceModel(int distanceModel);
+		static ::Dynamic distanceModel_dyn();
+
+		static void dopplerFactor(Float value);
+		static ::Dynamic dopplerFactor_dyn();
+
+		static void dopplerVelocity(Float value);
+		static ::Dynamic dopplerVelocity_dyn();
+
+		static void effectf( ::Dynamic effect,int param,Float value);
+		static ::Dynamic effectf_dyn();
+
+		static void effectfv( ::Dynamic effect,int param,::Array< Float > values);
+		static ::Dynamic effectfv_dyn();
+
+		static void effecti( ::Dynamic effect,int param,int value);
+		static ::Dynamic effecti_dyn();
+
+		static void effectiv( ::Dynamic effect,int param,::Array< int > values);
+		static ::Dynamic effectiv_dyn();
+
+		static void enable(int capability);
+		static ::Dynamic enable_dyn();
+
+		static  ::Dynamic genSource();
+		static ::Dynamic genSource_dyn();
+
+		static ::cpp::VirtualArray genSources(int n);
+		static ::Dynamic genSources_dyn();
+
+		static  ::Dynamic genBuffer();
+		static ::Dynamic genBuffer_dyn();
+
+		static ::cpp::VirtualArray genBuffers(int n);
+		static ::Dynamic genBuffers_dyn();
+
+		static bool getBoolean(int param);
+		static ::Dynamic getBoolean_dyn();
+
+		static ::Array< bool > getBooleanv(int param,hx::Null< int >  count);
+		static ::Dynamic getBooleanv_dyn();
+
+		static ::Array< Float > getBuffer3f( ::Dynamic buffer,int param);
+		static ::Dynamic getBuffer3f_dyn();
+
+		static ::Array< int > getBuffer3i( ::Dynamic buffer,int param);
+		static ::Dynamic getBuffer3i_dyn();
+
+		static Float getBufferf( ::Dynamic buffer,int param);
+		static ::Dynamic getBufferf_dyn();
+
+		static ::Array< Float > getBufferfv( ::Dynamic buffer,int param,hx::Null< int >  count);
+		static ::Dynamic getBufferfv_dyn();
+
+		static int getBufferi( ::Dynamic buffer,int param);
+		static ::Dynamic getBufferi_dyn();
+
+		static ::Array< int > getBufferiv( ::Dynamic buffer,int param,hx::Null< int >  count);
+		static ::Dynamic getBufferiv_dyn();
+
+		static Float getDouble(int param);
+		static ::Dynamic getDouble_dyn();
+
+		static ::Array< Float > getDoublev(int param,hx::Null< int >  count);
+		static ::Dynamic getDoublev_dyn();
+
+		static int getEnumValue(::String ename);
+		static ::Dynamic getEnumValue_dyn();
+
+		static int getError();
+		static ::Dynamic getError_dyn();
+
+		static ::String getErrorString();
+		static ::Dynamic getErrorString_dyn();
+
+		static int getFilteri( ::Dynamic filter,int param);
+		static ::Dynamic getFilteri_dyn();
+
+		static Float getFloat(int param);
+		static ::Dynamic getFloat_dyn();
+
+		static ::Array< Float > getFloatv(int param,hx::Null< int >  count);
+		static ::Dynamic getFloatv_dyn();
+
+		static int getInteger(int param);
+		static ::Dynamic getInteger_dyn();
+
+		static ::Array< int > getIntegerv(int param,hx::Null< int >  count);
+		static ::Dynamic getIntegerv_dyn();
+
+		static ::Array< Float > getListener3f(int param);
+		static ::Dynamic getListener3f_dyn();
+
+		static ::Array< int > getListener3i(int param);
+		static ::Dynamic getListener3i_dyn();
+
+		static Float getListenerf(int param);
+		static ::Dynamic getListenerf_dyn();
+
+		static ::Array< Float > getListenerfv(int param,hx::Null< int >  count);
+		static ::Dynamic getListenerfv_dyn();
+
+		static int getListeneri(int param);
+		static ::Dynamic getListeneri_dyn();
+
+		static ::Array< int > getListeneriv(int param,hx::Null< int >  count);
+		static ::Dynamic getListeneriv_dyn();
+
+		static  ::Dynamic getParameter(int param);
+		static ::Dynamic getParameter_dyn();
+
+		static  ::Dynamic getProcAddress(::String fname);
+		static ::Dynamic getProcAddress_dyn();
+
+		static ::Array< Float > getSource3f( ::Dynamic source,int param);
+		static ::Dynamic getSource3f_dyn();
+
+		static Float getSourcef( ::Dynamic source,int param);
+		static ::Dynamic getSourcef_dyn();
+
+		static ::Array< int > getSource3i( ::Dynamic source,int param);
+		static ::Dynamic getSource3i_dyn();
+
+		static ::Array< Float > getSourcefv( ::Dynamic source,int param,hx::Null< int >  count);
+		static ::Dynamic getSourcefv_dyn();
+
+		static  ::Dynamic getSourcei( ::Dynamic source,int param);
+		static ::Dynamic getSourcei_dyn();
+
+		static ::Array< int > getSourceiv( ::Dynamic source,int param,hx::Null< int >  count);
+		static ::Dynamic getSourceiv_dyn();
+
+		static ::String getString(int param);
+		static ::Dynamic getString_dyn();
+
+		static bool isBuffer( ::Dynamic buffer);
+		static ::Dynamic isBuffer_dyn();
+
+		static bool isEnabled(int capability);
+		static ::Dynamic isEnabled_dyn();
+
+		static bool isExtensionPresent(::String extname);
+		static ::Dynamic isExtensionPresent_dyn();
+
+		static bool isAux( ::Dynamic aux);
+		static ::Dynamic isAux_dyn();
+
+		static bool isEffect( ::Dynamic effect);
+		static ::Dynamic isEffect_dyn();
+
+		static bool isFilter( ::Dynamic filter);
+		static ::Dynamic isFilter_dyn();
+
+		static bool isSource( ::Dynamic source);
+		static ::Dynamic isSource_dyn();
+
+		static void listener3f(int param,Float value1,Float value2,Float value3);
+		static ::Dynamic listener3f_dyn();
+
+		static void listener3i(int param,int value1,int value2,int value3);
+		static ::Dynamic listener3i_dyn();
+
+		static void listenerf(int param,Float value);
+		static ::Dynamic listenerf_dyn();
+
+		static void listenerfv(int param,::Array< Float > values);
+		static ::Dynamic listenerfv_dyn();
+
+		static void listeneri(int param,int value);
+		static ::Dynamic listeneri_dyn();
+
+		static void listeneriv(int param,::Array< int > values);
+		static ::Dynamic listeneriv_dyn();
+
+		static void source3f( ::Dynamic source,int param,Float value1,Float value2,Float value3);
+		static ::Dynamic source3f_dyn();
+
+		static void source3i( ::Dynamic source,int param, ::Dynamic value1,int value2,int value3);
+		static ::Dynamic source3i_dyn();
+
+		static void sourcef( ::Dynamic source,int param,Float value);
+		static ::Dynamic sourcef_dyn();
+
+		static void sourcefv( ::Dynamic source,int param,::Array< Float > values);
+		static ::Dynamic sourcefv_dyn();
+
+		static void sourcei( ::Dynamic source,int param, ::Dynamic value);
+		static ::Dynamic sourcei_dyn();
+
+		static void filteri( ::Dynamic filter,int param, ::Dynamic value);
+		static ::Dynamic filteri_dyn();
+
+		static void filterf( ::Dynamic filter,int param,Float value);
+		static ::Dynamic filterf_dyn();
+
+		static void sourceiv( ::Dynamic source,int param,::Array< int > values);
+		static ::Dynamic sourceiv_dyn();
+
+		static void sourcePlay( ::Dynamic source);
+		static ::Dynamic sourcePlay_dyn();
+
+		static void sourcePlayv(::cpp::VirtualArray sources);
+		static ::Dynamic sourcePlayv_dyn();
+
+		static void sourceStop( ::Dynamic source);
+		static ::Dynamic sourceStop_dyn();
+
+		static void sourceStopv(::cpp::VirtualArray sources);
+		static ::Dynamic sourceStopv_dyn();
+
+		static void sourceRewind( ::Dynamic source);
+		static ::Dynamic sourceRewind_dyn();
+
+		static void sourceRewindv(::cpp::VirtualArray sources);
+		static ::Dynamic sourceRewindv_dyn();
+
+		static void sourcePause( ::Dynamic source);
+		static ::Dynamic sourcePause_dyn();
+
+		static void sourcePausev(::cpp::VirtualArray sources);
+		static ::Dynamic sourcePausev_dyn();
+
+		static void sourceQueueBuffer( ::Dynamic source, ::Dynamic buffer);
+		static ::Dynamic sourceQueueBuffer_dyn();
+
+		static void sourceQueueBuffers( ::Dynamic source,int nb,::cpp::VirtualArray buffers);
+		static ::Dynamic sourceQueueBuffers_dyn();
+
+		static  ::Dynamic sourceUnqueueBuffer( ::Dynamic source);
+		static ::Dynamic sourceUnqueueBuffer_dyn();
+
+		static ::cpp::VirtualArray sourceUnqueueBuffers( ::Dynamic source,int nb);
+		static ::Dynamic sourceUnqueueBuffers_dyn();
+
+		static void speedOfSound(Float value);
+		static ::Dynamic speedOfSound_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+
+#endif /* INCLUDED_lime_media_openal_AL */ 

hGameTest/bin/linux/obj/include/lime/media/openal/ALC.h

@@ -0,0 +1,128 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal_ALC
+#define INCLUDED_lime_media_openal_ALC
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,media,openal,ALC)
+
+namespace lime{
+namespace media{
+namespace openal{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALC_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALC_obj OBJ_;
+		ALC_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6d89df14 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal.ALC")
+			{ 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.media.openal.ALC"); }
+
+		inline static hx::ObjectPtr< ALC_obj > __new() {
+			hx::ObjectPtr< ALC_obj > __this = new ALC_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALC_obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALC_obj *__this = (ALC_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALC_obj), false, "lime.media.openal.ALC"));
+			*(void **)__this = ALC_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALC_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_("ALC",f8,94,31,00); }
+
+		static void __boot();
+		static int FALSE;
+		static int TRUE;
+		static int FREQUENCY;
+		static int REFRESH;
+		static int SYNC;
+		static int MONO_SOURCES;
+		static int STEREO_SOURCES;
+		static int NO_ERROR;
+		static int INVALID_DEVICE;
+		static int INVALID_CONTEXT;
+		static int INVALID_ENUM;
+		static int INVALID_VALUE;
+		static int OUT_OF_MEMORY;
+		static int ATTRIBUTES_SIZE;
+		static int ALL_ATTRIBUTES;
+		static int DEFAULT_DEVICE_SPECIFIER;
+		static int DEVICE_SPECIFIER;
+		static int EXTENSIONS;
+		static int ENUMERATE_ALL_EXT;
+		static int DEFAULT_ALL_DEVICES_SPECIFIER;
+		static int ALL_DEVICES_SPECIFIER;
+		static bool closeDevice( ::Dynamic device);
+		static ::Dynamic closeDevice_dyn();
+
+		static  ::Dynamic createContext( ::Dynamic device,::Array< int > attrlist);
+		static ::Dynamic createContext_dyn();
+
+		static void destroyContext( ::Dynamic context);
+		static ::Dynamic destroyContext_dyn();
+
+		static  ::Dynamic getContextsDevice( ::Dynamic context);
+		static ::Dynamic getContextsDevice_dyn();
+
+		static  ::Dynamic getCurrentContext();
+		static ::Dynamic getCurrentContext_dyn();
+
+		static int getError( ::Dynamic device);
+		static ::Dynamic getError_dyn();
+
+		static ::String getErrorString( ::Dynamic device);
+		static ::Dynamic getErrorString_dyn();
+
+		static ::Array< int > getIntegerv( ::Dynamic device,int param,int size);
+		static ::Dynamic getIntegerv_dyn();
+
+		static ::String getString( ::Dynamic device,int param);
+		static ::Dynamic getString_dyn();
+
+		static bool makeContextCurrent( ::Dynamic context);
+		static ::Dynamic makeContextCurrent_dyn();
+
+		static  ::Dynamic openDevice(::String deviceName);
+		static ::Dynamic openDevice_dyn();
+
+		static void pauseDevice( ::Dynamic device);
+		static ::Dynamic pauseDevice_dyn();
+
+		static void processContext( ::Dynamic context);
+		static ::Dynamic processContext_dyn();
+
+		static void resumeDevice( ::Dynamic device);
+		static ::Dynamic resumeDevice_dyn();
+
+		static void suspendContext( ::Dynamic context);
+		static ::Dynamic suspendContext_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+
+#endif /* INCLUDED_lime_media_openal_ALC */ 

hGameTest/bin/linux/obj/include/lime/media/openal/_ALAuxiliaryEffectSlot/ALAuxiliaryEffectSlot_Impl_.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal__ALAuxiliaryEffectSlot_ALAuxiliaryEffectSlot_Impl_
+#define INCLUDED_lime_media_openal__ALAuxiliaryEffectSlot_ALAuxiliaryEffectSlot_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,media,openal,_ALAuxiliaryEffectSlot,ALAuxiliaryEffectSlot_Impl_)
+
+namespace lime{
+namespace media{
+namespace openal{
+namespace _ALAuxiliaryEffectSlot{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALAuxiliaryEffectSlot_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALAuxiliaryEffectSlot_Impl__obj OBJ_;
+		ALAuxiliaryEffectSlot_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x54171dbf };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal._ALAuxiliaryEffectSlot.ALAuxiliaryEffectSlot_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.media.openal._ALAuxiliaryEffectSlot.ALAuxiliaryEffectSlot_Impl_"); }
+
+		inline static hx::ObjectPtr< ALAuxiliaryEffectSlot_Impl__obj > __new() {
+			hx::ObjectPtr< ALAuxiliaryEffectSlot_Impl__obj > __this = new ALAuxiliaryEffectSlot_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALAuxiliaryEffectSlot_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALAuxiliaryEffectSlot_Impl__obj *__this = (ALAuxiliaryEffectSlot_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALAuxiliaryEffectSlot_Impl__obj), false, "lime.media.openal._ALAuxiliaryEffectSlot.ALAuxiliaryEffectSlot_Impl_"));
+			*(void **)__this = ALAuxiliaryEffectSlot_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALAuxiliaryEffectSlot_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_("ALAuxiliaryEffectSlot_Impl_",ca,89,74,28); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+} // end namespace _ALAuxiliaryEffectSlot
+
+#endif /* INCLUDED_lime_media_openal__ALAuxiliaryEffectSlot_ALAuxiliaryEffectSlot_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/media/openal/_ALBuffer/ALBuffer_Impl_.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal__ALBuffer_ALBuffer_Impl_
+#define INCLUDED_lime_media_openal__ALBuffer_ALBuffer_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,media,openal,_ALBuffer,ALBuffer_Impl_)
+
+namespace lime{
+namespace media{
+namespace openal{
+namespace _ALBuffer{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALBuffer_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALBuffer_Impl__obj OBJ_;
+		ALBuffer_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x78e0f2dd };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal._ALBuffer.ALBuffer_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.media.openal._ALBuffer.ALBuffer_Impl_"); }
+
+		inline static hx::ObjectPtr< ALBuffer_Impl__obj > __new() {
+			hx::ObjectPtr< ALBuffer_Impl__obj > __this = new ALBuffer_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALBuffer_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALBuffer_Impl__obj *__this = (ALBuffer_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALBuffer_Impl__obj), false, "lime.media.openal._ALBuffer.ALBuffer_Impl_"));
+			*(void **)__this = ALBuffer_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALBuffer_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_("ALBuffer_Impl_",2b,73,03,08); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+} // end namespace _ALBuffer
+
+#endif /* INCLUDED_lime_media_openal__ALBuffer_ALBuffer_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/media/openal/_ALContext/ALContext_Impl_.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal__ALContext_ALContext_Impl_
+#define INCLUDED_lime_media_openal__ALContext_ALContext_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,media,openal,_ALContext,ALContext_Impl_)
+
+namespace lime{
+namespace media{
+namespace openal{
+namespace _ALContext{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALContext_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALContext_Impl__obj OBJ_;
+		ALContext_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x72af199b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal._ALContext.ALContext_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.media.openal._ALContext.ALContext_Impl_"); }
+
+		inline static hx::ObjectPtr< ALContext_Impl__obj > __new() {
+			hx::ObjectPtr< ALContext_Impl__obj > __this = new ALContext_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALContext_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALContext_Impl__obj *__this = (ALContext_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALContext_Impl__obj), false, "lime.media.openal._ALContext.ALContext_Impl_"));
+			*(void **)__this = ALContext_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALContext_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_("ALContext_Impl_",e4,0f,31,11); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+} // end namespace _ALContext
+
+#endif /* INCLUDED_lime_media_openal__ALContext_ALContext_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/media/openal/_ALDevice/ALDevice_Impl_.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal__ALDevice_ALDevice_Impl_
+#define INCLUDED_lime_media_openal__ALDevice_ALDevice_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,media,openal,_ALDevice,ALDevice_Impl_)
+
+namespace lime{
+namespace media{
+namespace openal{
+namespace _ALDevice{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALDevice_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALDevice_Impl__obj OBJ_;
+		ALDevice_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x1e2fac5d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal._ALDevice.ALDevice_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.media.openal._ALDevice.ALDevice_Impl_"); }
+
+		inline static hx::ObjectPtr< ALDevice_Impl__obj > __new() {
+			hx::ObjectPtr< ALDevice_Impl__obj > __this = new ALDevice_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALDevice_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALDevice_Impl__obj *__this = (ALDevice_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALDevice_Impl__obj), false, "lime.media.openal._ALDevice.ALDevice_Impl_"));
+			*(void **)__this = ALDevice_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALDevice_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_("ALDevice_Impl_",41,67,1b,6c); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+} // end namespace _ALDevice
+
+#endif /* INCLUDED_lime_media_openal__ALDevice_ALDevice_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/media/openal/_ALEffect/ALEffect_Impl_.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal__ALEffect_ALEffect_Impl_
+#define INCLUDED_lime_media_openal__ALEffect_ALEffect_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,media,openal,_ALEffect,ALEffect_Impl_)
+
+namespace lime{
+namespace media{
+namespace openal{
+namespace _ALEffect{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALEffect_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALEffect_Impl__obj OBJ_;
+		ALEffect_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ede22bf };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal._ALEffect.ALEffect_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.media.openal._ALEffect.ALEffect_Impl_"); }
+
+		inline static hx::ObjectPtr< ALEffect_Impl__obj > __new() {
+			hx::ObjectPtr< ALEffect_Impl__obj > __this = new ALEffect_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALEffect_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALEffect_Impl__obj *__this = (ALEffect_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALEffect_Impl__obj), false, "lime.media.openal._ALEffect.ALEffect_Impl_"));
+			*(void **)__this = ALEffect_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALEffect_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_("ALEffect_Impl_",7c,13,0e,4e); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+} // end namespace _ALEffect
+
+#endif /* INCLUDED_lime_media_openal__ALEffect_ALEffect_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/media/openal/_ALFilter/ALFilter_Impl_.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal__ALFilter_ALFilter_Impl_
+#define INCLUDED_lime_media_openal__ALFilter_ALFilter_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,media,openal,_ALFilter,ALFilter_Impl_)
+
+namespace lime{
+namespace media{
+namespace openal{
+namespace _ALFilter{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALFilter_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALFilter_Impl__obj OBJ_;
+		ALFilter_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x13b01c21 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal._ALFilter.ALFilter_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.media.openal._ALFilter.ALFilter_Impl_"); }
+
+		inline static hx::ObjectPtr< ALFilter_Impl__obj > __new() {
+			hx::ObjectPtr< ALFilter_Impl__obj > __this = new ALFilter_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALFilter_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALFilter_Impl__obj *__this = (ALFilter_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALFilter_Impl__obj), false, "lime.media.openal._ALFilter.ALFilter_Impl_"));
+			*(void **)__this = ALFilter_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALFilter_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_("ALFilter_Impl_",e3,af,86,0f); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+} // end namespace _ALFilter
+
+#endif /* INCLUDED_lime_media_openal__ALFilter_ALFilter_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/media/openal/_ALSource/ALSource_Impl_.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_openal__ALSource_ALSource_Impl_
+#define INCLUDED_lime_media_openal__ALSource_ALSource_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS4(lime,media,openal,_ALSource,ALSource_Impl_)
+
+namespace lime{
+namespace media{
+namespace openal{
+namespace _ALSource{
+
+
+class HXCPP_CLASS_ATTRIBUTES ALSource_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ALSource_Impl__obj OBJ_;
+		ALSource_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x63a2f0a7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.openal._ALSource.ALSource_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.media.openal._ALSource.ALSource_Impl_"); }
+
+		inline static hx::ObjectPtr< ALSource_Impl__obj > __new() {
+			hx::ObjectPtr< ALSource_Impl__obj > __this = new ALSource_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< ALSource_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			ALSource_Impl__obj *__this = (ALSource_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(ALSource_Impl__obj), false, "lime.media.openal._ALSource.ALSource_Impl_"));
+			*(void **)__this = ALSource_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ALSource_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_("ALSource_Impl_",46,3d,35,f9); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace openal
+} // end namespace _ALSource
+
+#endif /* INCLUDED_lime_media_openal__ALSource_ALSource_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/media/vorbis/VorbisComment.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_vorbis_VorbisComment
+#define INCLUDED_lime_media_vorbis_VorbisComment
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_ad1e8e68f8403b12_9_new)
+HX_DECLARE_CLASS3(lime,media,vorbis,VorbisComment)
+
+namespace lime{
+namespace media{
+namespace vorbis{
+
+
+class HXCPP_CLASS_ATTRIBUTES VorbisComment_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef VorbisComment_obj OBJ_;
+		VorbisComment_obj();
+
+	public:
+		enum { _hx_ClassId = 0x488981ea };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.media.vorbis.VorbisComment")
+			{ 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.media.vorbis.VorbisComment"); }
+
+		inline static hx::ObjectPtr< VorbisComment_obj > __new() {
+			hx::ObjectPtr< VorbisComment_obj > __this = new VorbisComment_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< VorbisComment_obj > __alloc(hx::Ctx *_hx_ctx) {
+			VorbisComment_obj *__this = (VorbisComment_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(VorbisComment_obj), true, "lime.media.vorbis.VorbisComment"));
+			*(void **)__this = VorbisComment_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_ad1e8e68f8403b12_9_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~VorbisComment_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_("VorbisComment",2c,4f,a7,75); }
+
+		::Array< ::String > userComments;
+		::String vendor;
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace vorbis
+
+#endif /* INCLUDED_lime_media_vorbis_VorbisComment */ 

hGameTest/bin/linux/obj/include/lime/media/vorbis/VorbisFile.h

@@ -0,0 +1,151 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_vorbis_VorbisFile
+#define INCLUDED_lime_media_vorbis_VorbisFile
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_38344beec7696400
+#define INCLUDED_38344beec7696400
+#include "cpp/Int64.h"
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS3(lime,media,vorbis,VorbisComment)
+HX_DECLARE_CLASS3(lime,media,vorbis,VorbisFile)
+HX_DECLARE_CLASS3(lime,media,vorbis,VorbisInfo)
+
+namespace lime{
+namespace media{
+namespace vorbis{
+
+
+class HXCPP_CLASS_ATTRIBUTES VorbisFile_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef VorbisFile_obj OBJ_;
+		VorbisFile_obj();
+
+	public:
+		enum { _hx_ClassId = 0x35c77211 };
+
+		void __construct( ::Dynamic handle);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.media.vorbis.VorbisFile")
+			{ 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.media.vorbis.VorbisFile"); }
+		static hx::ObjectPtr< VorbisFile_obj > __new( ::Dynamic handle);
+		static hx::ObjectPtr< VorbisFile_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic handle);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~VorbisFile_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_("VorbisFile",8f,a7,81,d4); }
+
+		static  ::lime::media::vorbis::VorbisFile fromBytes( ::haxe::io::Bytes bytes);
+		static ::Dynamic fromBytes_dyn();
+
+		static  ::lime::media::vorbis::VorbisFile fromFile(::String path);
+		static ::Dynamic fromFile_dyn();
+
+		int bitstream;
+		 ::Dynamic handle;
+		int bitrate(hx::Null< int >  bitstream);
+		::Dynamic bitrate_dyn();
+
+		int bitrateInstant();
+		::Dynamic bitrateInstant_dyn();
+
+		void clear();
+		::Dynamic clear_dyn();
+
+		 ::lime::media::vorbis::VorbisComment comment(hx::Null< int >  bitstream);
+		::Dynamic comment_dyn();
+
+		int crosslap( ::lime::media::vorbis::VorbisFile other);
+		::Dynamic crosslap_dyn();
+
+		 ::lime::media::vorbis::VorbisInfo info(hx::Null< int >  bitstream);
+		::Dynamic info_dyn();
+
+		int pcmSeek( cpp::Int64Struct pos);
+		::Dynamic pcmSeek_dyn();
+
+		int pcmSeekLap( cpp::Int64Struct pos);
+		::Dynamic pcmSeekLap_dyn();
+
+		int pcmSeekPage( cpp::Int64Struct pos);
+		::Dynamic pcmSeekPage_dyn();
+
+		int pcmSeekPageLap( cpp::Int64Struct pos);
+		::Dynamic pcmSeekPageLap_dyn();
+
+		 cpp::Int64Struct pcmTell();
+		::Dynamic pcmTell_dyn();
+
+		 cpp::Int64Struct pcmTotal(hx::Null< int >  bitstream);
+		::Dynamic pcmTotal_dyn();
+
+		int rawSeek( cpp::Int64Struct pos);
+		::Dynamic rawSeek_dyn();
+
+		int rawSeekLap( cpp::Int64Struct pos);
+		::Dynamic rawSeekLap_dyn();
+
+		 cpp::Int64Struct rawTell();
+		::Dynamic rawTell_dyn();
+
+		 cpp::Int64Struct rawTotal(hx::Null< int >  bitstream);
+		::Dynamic rawTotal_dyn();
+
+		int read( ::haxe::io::Bytes buffer,int position,hx::Null< int >  length,hx::Null< bool >  bigEndianPacking,hx::Null< int >  wordSize,hx::Null< bool >  _hx_signed);
+		::Dynamic read_dyn();
+
+		int readFloat( ::haxe::io::Bytes pcmChannels,int samples);
+		::Dynamic readFloat_dyn();
+
+		bool seekable();
+		::Dynamic seekable_dyn();
+
+		int serialNumber(hx::Null< int >  bitstream);
+		::Dynamic serialNumber_dyn();
+
+		int streams();
+		::Dynamic streams_dyn();
+
+		int timeSeek(Float s);
+		::Dynamic timeSeek_dyn();
+
+		int timeSeekLap(Float s);
+		::Dynamic timeSeekLap_dyn();
+
+		int timeSeekPage(Float s);
+		::Dynamic timeSeekPage_dyn();
+
+		int timeSeekPageLap(Float s);
+		::Dynamic timeSeekPageLap_dyn();
+
+		Float timeTell();
+		::Dynamic timeTell_dyn();
+
+		Float timeTotal(hx::Null< int >  bitstream);
+		::Dynamic timeTotal_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace vorbis
+
+#endif /* INCLUDED_lime_media_vorbis_VorbisFile */ 

hGameTest/bin/linux/obj/include/lime/media/vorbis/VorbisInfo.h

@@ -0,0 +1,74 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_media_vorbis_VorbisInfo
+#define INCLUDED_lime_media_vorbis_VorbisInfo
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_d9b59d7587cb992f_14_new)
+HX_DECLARE_CLASS3(lime,media,vorbis,VorbisInfo)
+
+namespace lime{
+namespace media{
+namespace vorbis{
+
+
+class HXCPP_CLASS_ATTRIBUTES VorbisInfo_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef VorbisInfo_obj OBJ_;
+		VorbisInfo_obj();
+
+	public:
+		enum { _hx_ClassId = 0x37c6dc03 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.media.vorbis.VorbisInfo")
+			{ 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.media.vorbis.VorbisInfo"); }
+
+		inline static hx::ObjectPtr< VorbisInfo_obj > __new() {
+			hx::ObjectPtr< VorbisInfo_obj > __this = new VorbisInfo_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< VorbisInfo_obj > __alloc(hx::Ctx *_hx_ctx) {
+			VorbisInfo_obj *__this = (VorbisInfo_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(VorbisInfo_obj), false, "lime.media.vorbis.VorbisInfo"));
+			*(void **)__this = VorbisInfo_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_d9b59d7587cb992f_14_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~VorbisInfo_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_("VorbisInfo",81,11,81,d6); }
+
+		int bitrateLower;
+		int bitrateNominal;
+		int bitrateUpper;
+		int channels;
+		int rate;
+		int version;
+};
+
+} // end namespace lime
+} // end namespace media
+} // end namespace vorbis
+
+#endif /* INCLUDED_lime_media_vorbis_VorbisInfo */