ExternalInterface.cpp

#ifndef STATIC_LINK
#define IMPLEMENT_API
#endif

#if defined(HX_WINDOWS) || defined(HX_MACOS) || defined(HX_LINUX)
#define NEKO_COMPATIBLE
#endif

#include <system/CFFI.h>

#include <app/Application.h>
#include <app/ApplicationEvent.h>
#include <graphics/format/JPEG.h>
#include <graphics/format/PNG.h>
#include <graphics/utils/ImageDataUtil.h>
#include <graphics/Image.h>
#include <graphics/ImageBuffer.h>
#include <graphics/RenderEvent.h>
#include <media/containers/OGG.h>
#include <media/containers/WAV.h>
#include <media/containers/MP3.h>
#include <media/AudioBuffer.h>
#include <system/CFFIPointer.h>
#include <system/Clipboard.h>
#include <system/ClipboardEvent.h>
#include <system/Endian.h>
#include <system/FileWatcher.h>
#include <system/JNI.h>
#include <system/Locale.h>
#include <system/OrientationEvent.h>
#include <system/SensorEvent.h>
#include <system/System.h>
#include <text/Font.h>
#include <ui/Cursor.h>
#include <ui/DropEvent.h>
#include <ui/FileDialog.h>
#include <ui/Gamepad.h>
#include <ui/GamepadEvent.h>
#include <ui/Haptic.h>
#include <ui/Joystick.h>
#include <ui/JoystickEvent.h>
#include <ui/KeyCode.h>
#include <ui/KeyEvent.h>
#include <ui/MouseEvent.h>
#include <ui/TextEvent.h>
#include <ui/TouchEvent.h>
#include <ui/Window.h>
#include <ui/WindowEvent.h>
#include <utils/compress/LZMA.h>
#include <utils/compress/Zlib.h>
#include <vm/NekoVM.h>

#ifdef HX_WINDOWS
#include <locale>
#include <codecvt>
#endif
#include <memory>

#include <cstdlib>
#include <cstring>

DEFINE_KIND (k_finalizer);


namespace lime {


	void gc_application (value handle) {

		Application* application = (Application*)val_data (handle);
		delete application;

	}


	void hl_gc_application (HL_CFFIPointer* handle) {

		Application* application = (Application*)handle->ptr;
		delete application;

	}


	void gc_file_watcher (value handle) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)val_data (handle);
		delete watcher;
		#endif

	}


	void hl_gc_file_watcher (HL_CFFIPointer* handle) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)handle->ptr;
		delete watcher;
		#endif

	}


	void gc_font (value handle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (handle);
		delete font;
		#endif

	}


	void hl_gc_font (HL_CFFIPointer* handle) {

		#ifdef LIME_FREETYPE
		Font* font = (Font*)handle->ptr;
		delete font;
		#endif

	}


	void gc_window (value handle) {

		Window* window = (Window*)val_data (handle);
		delete window;

	}


	void hl_gc_window (HL_CFFIPointer* handle) {

		Window* window = (Window*)handle->ptr;
		delete window;

	}


	std::string wstring_utf8 (const std::wstring& val) {

		std::string out;
		unsigned int codepoint = 0;

		for (const wchar_t chr : val) {

			if (chr >= 0xd800 && chr <= 0xdbff) {

				codepoint = ((chr - 0xd800) << 10) + 0x10000;

			} else {

				if (chr >= 0xdc00 && chr <= 0xdfff) {

					codepoint |= chr - 0xdc00;

				} else {

					codepoint = chr;

				}

				if (codepoint <= 0x7f) {

					out.append (1, static_cast<char> (codepoint));

				} else if (codepoint <= 0x7ff) {

					out.append (1, static_cast<char> (0xc0 | ((codepoint >> 6) & 0x1f)));
					out.append (1, static_cast<char> (0x80 | (codepoint & 0x3f)));

				} else if (codepoint <= 0xffff) {

					out.append (1, static_cast<char> (0xe0 | ((codepoint >> 12) & 0x0f)));
					out.append (1, static_cast<char> (0x80 | ((codepoint >> 6) & 0x3f)));
					out.append (1, static_cast<char> (0x80 | (codepoint & 0x3f)));

				} else {

					out.append (1, static_cast<char> (0xf0 | ((codepoint >> 18) & 0x07)));
					out.append (1, static_cast<char> (0x80 | ((codepoint >> 12) & 0x3f)));
					out.append (1, static_cast<char> (0x80 | ((codepoint >> 6) & 0x3f)));
					out.append (1, static_cast<char> (0x80 | (codepoint & 0x3f)));

				}

				codepoint = 0;

			}

		}

		return out;

	}


	vbyte* hl_wstring_to_utf8_bytes (const std::wstring& val) {

		const std::string utf8 (wstring_utf8 (val));
		vbyte* const bytes = hl_alloc_bytes (utf8.size () + 1);
		std::memcpy(bytes, utf8.c_str (), utf8.size () + 1);
		return bytes;

	}


	std::wstring* hxstring_to_wstring (HxString val) {

		if (val.c_str ()) {

			#ifdef HX_WINDOWS
			return new std::wstring (hxs_wchar (val, nullptr));
			#else
			const std::string _val (hxs_utf8 (val, nullptr));
			return new std::wstring (_val.begin (), _val.end ());
			#endif

		} else {

			return 0;

		}

	}


	std::wstring* hxstring_to_wstring (hl_vstring* val) {

		if (val) {

			std::string _val = std::string (hl_to_utf8 (val->bytes));
			#ifdef HX_WINDOWS
			std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
			return new std::wstring (converter.from_bytes (_val));
			#else
			return new std::wstring (_val.begin (), _val.end ());
			#endif

		} else {

			return 0;

		}

	}


	value wstring_to_value (std::wstring* val) {

		if (val) {

			#ifdef HX_WINDOWS
			return alloc_wstring (val->c_str ());
			#else
			std::string _val = std::string (val->begin (), val->end ());
			return alloc_string (_val.c_str ());
			#endif

		} else {

			return 0;

		}

	}


	value lime_application_create () {

		Application* application = CreateApplication ();
		return CFFIPointer (application, gc_application);

	}


	HL_PRIM HL_CFFIPointer* HL_NAME(hl_application_create) () {

		Application* application = CreateApplication ();
		return HLCFFIPointer (application, (hl_finalizer)hl_gc_application);

	}


	void lime_application_event_manager_register (value callback, value eventObject) {

		ApplicationEvent::callback = new ValuePointer (callback);
		ApplicationEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_application_event_manager_register) (vclosure* callback, ApplicationEvent* eventObject) {

		ApplicationEvent::callback = new ValuePointer (callback);
		ApplicationEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	int lime_application_exec (value application) {

		Application* app = (Application*)val_data (application);
		return app->Exec ();

	}


	HL_PRIM int HL_NAME(hl_application_exec) (HL_CFFIPointer* application) {

		Application* app = (Application*)application->ptr;
		return app->Exec ();

	}


	void lime_application_init (value application) {

		Application* app = (Application*)val_data (application);
		app->Init ();

	}


	HL_PRIM void HL_NAME(hl_application_init) (HL_CFFIPointer* application) {

		Application* app = (Application*)application->ptr;
		app->Init ();

	}


	int lime_application_quit (value application) {

		Application* app = (Application*)val_data (application);
		return app->Quit ();

	}


	HL_PRIM int HL_NAME(hl_application_quit) (HL_CFFIPointer* application) {

		Application* app = (Application*)application->ptr;
		return app->Quit ();

	}


	void lime_application_set_frame_rate (value application, double frameRate) {

		Application* app = (Application*)val_data (application);
		app->SetFrameRate (frameRate);

	}


	HL_PRIM void HL_NAME(hl_application_set_frame_rate) (HL_CFFIPointer* application, double frameRate) {

		Application* app = (Application*)application->ptr;
		app->SetFrameRate (frameRate);

	}


	bool lime_application_update (value application) {

		Application* app = (Application*)val_data (application);
		return app->Update ();

	}


	HL_PRIM bool HL_NAME(hl_application_update) (HL_CFFIPointer* application) {

		Application* app = (Application*)application->ptr;
		return app->Update ();

	}


	value lime_audio_load_bytes (value data, value buffer) {

		Resource resource;
		Bytes bytes;

		AudioBuffer audioBuffer = AudioBuffer (buffer);

		bytes.Set (data);
		resource = Resource (&bytes);

		if (WAV::Decode (&resource, &audioBuffer)) {

			return audioBuffer.Value (buffer);

		}

		#ifdef LIME_OGG
		if (OGG::Decode (&resource, &audioBuffer)) {

			return audioBuffer.Value (buffer);

		}
		#endif

		#ifdef LIME_MP3
        if (MP3::Decode (&resource, &audioBuffer)) {

            return audioBuffer.Value (buffer);
        }
        #endif

		return alloc_null ();

	}


	HL_PRIM AudioBuffer* HL_NAME(hl_audio_load_bytes) (Bytes* data, AudioBuffer* buffer) {

		Resource resource = Resource (data);

		if (WAV::Decode (&resource, buffer)) {

			return buffer;

		}

		#ifdef LIME_OGG
		if (OGG::Decode (&resource, buffer)) {

			return buffer;

		}
		#endif

		#ifdef LIME_MP3
        if (MP3::Decode (&resource, buffer)) {

            return buffer;
        }
        #endif

		return 0;

	}


	value lime_audio_load_file (value data, value buffer) {

		Resource resource;

		AudioBuffer audioBuffer = AudioBuffer (buffer);

		resource = Resource (val_string (data));

		if (WAV::Decode (&resource, &audioBuffer)) {

			return audioBuffer.Value (buffer);

		}

		#ifdef LIME_OGG
		if (OGG::Decode (&resource, &audioBuffer)) {

			return audioBuffer.Value (buffer);

		}
		#endif

		#ifdef LIME_MP3
        if (MP3::Decode (&resource, &audioBuffer)) {

            return audioBuffer.Value (buffer);
        }
        #endif

		return alloc_null ();

	}


	HL_PRIM AudioBuffer* HL_NAME(hl_audio_load_file) (hl_vstring* data, AudioBuffer* buffer) {

		Resource resource = Resource (data ? hl_to_utf8 ((const uchar*)data->bytes) : NULL);

		if (WAV::Decode (&resource, buffer)) {

			return buffer;

		}

		#ifdef LIME_OGG
		if (OGG::Decode (&resource, buffer)) {

			return buffer;

		}
		#endif

		#ifdef LIME_MP3
        if (MP3::Decode (&resource, buffer)) {

            return buffer;
        }
        #endif

		return 0;

	}


	value lime_audio_load (value data, value buffer) {

		if (val_is_string (data)) {

			return lime_audio_load_file (data, buffer);

		} else {

			return lime_audio_load_bytes (data, buffer);

		}

	}


	value lime_bytes_from_data_pointer (double data, int length, value _bytes) {

		uintptr_t ptr = (uintptr_t)data;
		Bytes bytes (_bytes);
		bytes.Resize (length);

		if (ptr) {

			memcpy (bytes.b, (const void*)ptr, length);

		}

		return bytes.Value (_bytes);

	}


	HL_PRIM Bytes* HL_NAME(hl_bytes_from_data_pointer) (double data, int length, Bytes* bytes) {

		uintptr_t ptr = (uintptr_t)data;
		bytes->Resize (length);

		if (ptr) {

			memcpy (bytes->b, (const void*)ptr, length);

		}

		return bytes;

	}


	double lime_bytes_get_data_pointer (value bytes) {

		Bytes data = Bytes (bytes);
		return (uintptr_t)data.b;

	}


	HL_PRIM double HL_NAME(hl_bytes_get_data_pointer) (Bytes* bytes) {

		return bytes ? (uintptr_t)bytes->b : 0;

	}


	double lime_bytes_get_data_pointer_offset (value bytes, int offset) {

		if (val_is_null (bytes)) return 0;

		Bytes data = Bytes (bytes);
		return (uintptr_t)data.b + offset;

	}


	HL_PRIM double HL_NAME(hl_bytes_get_data_pointer_offset) (Bytes* bytes, int offset) {

		if (!bytes) return 0;
		return (uintptr_t)bytes->b + offset;

	}


	value lime_bytes_read_file (HxString path, value bytes) {

		Bytes data (bytes);
		data.ReadFile (hxs_utf8 (path, nullptr));
		return data.Value (bytes);

	}


	HL_PRIM Bytes* HL_NAME(hl_bytes_read_file) (hl_vstring* path, Bytes* bytes) {

		if (!path) return 0;
		bytes->ReadFile (hl_to_utf8 ((const uchar*)path->bytes));
		return bytes;

	}


	double lime_cffi_get_native_pointer (value handle) {

		return (uintptr_t)val_data (handle);

	}


	HL_PRIM double HL_NAME(hl_cffi_get_native_pointer) (HL_CFFIPointer* handle) {

		return (uintptr_t)handle->ptr;

	}


	void lime_cffi_finalizer (value abstract) {

		val_call0 ((value)val_data (abstract));

	}


	value lime_cffi_set_finalizer (value callback) {

		value abstract = alloc_abstract (k_finalizer, callback);
		val_gc (abstract, lime_cffi_finalizer);
		return abstract;

	}


	void lime_clipboard_event_manager_register (value callback, value eventObject) {

		ClipboardEvent::callback = new ValuePointer (callback);
		ClipboardEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_clipboard_event_manager_register) (vclosure* callback, ClipboardEvent* eventObject) {

		ClipboardEvent::callback = new ValuePointer (callback);
		ClipboardEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	value lime_clipboard_get_text () {

		if (Clipboard::HasText ()) {

			const char* text = Clipboard::GetText ();
			value _text = alloc_string (text);

			// TODO: Should we free for all backends? (SDL requires it)

			free ((char*)text);
			return _text;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_clipboard_get_text) () {

		if (Clipboard::HasText ()) {

			const char* text = Clipboard::GetText ();
			return (vbyte*)text;

		} else {

			return 0;

		}

	}


	void lime_clipboard_set_text (HxString text) {

		Clipboard::SetText (hxs_utf8 (text, nullptr));

	}


	HL_PRIM void HL_NAME(hl_clipboard_set_text) (hl_vstring* text) {

		Clipboard::SetText (text ? (const char*)hl_to_utf8 ((const uchar*)text->bytes) : NULL);

	}


	double lime_data_pointer_offset (double pointer, int offset) {

		return (uintptr_t)pointer + offset;

	}


	HL_PRIM double HL_NAME(hl_data_pointer_offset) (double pointer, int offset) {

		return (uintptr_t)pointer + offset;

	}


	value lime_deflate_compress (value buffer, value bytes) {

		#ifdef LIME_ZLIB
		Bytes data (buffer);
		Bytes result (bytes);

		Zlib::Compress (DEFLATE, &data, &result);

		return result.Value (bytes);
		#else
		return alloc_null();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_deflate_compress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_ZLIB
		Zlib::Compress (DEFLATE, buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	value lime_deflate_decompress (value buffer, value bytes) {

		#ifdef LIME_ZLIB
		Bytes data (buffer);
		Bytes result (bytes);

		Zlib::Decompress (DEFLATE, &data, &result);

		return result.Value (bytes);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_deflate_decompress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_ZLIB
		Zlib::Decompress (DEFLATE, buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	void lime_drop_event_manager_register (value callback, value eventObject) {

		DropEvent::callback = new ValuePointer (callback);
		DropEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_drop_event_manager_register) (vclosure* callback, DropEvent* eventObject) {

		DropEvent::callback = new ValuePointer (callback);
		DropEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	value lime_file_dialog_open_directory (HxString title, HxString filter, HxString defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::wstring* path = FileDialog::OpenDirectory (_title, _filter, _defaultPath);

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		if (path) {

			value _path = wstring_to_value (path);
			delete path;
			return _path;

		} else {

			return alloc_null ();

		}

		#endif

		return alloc_null ();

	}


	HL_PRIM vbyte* HL_NAME(hl_file_dialog_open_directory) (hl_vstring* title, hl_vstring* filter, hl_vstring* defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::wstring* path = FileDialog::OpenDirectory (_title, _filter, _defaultPath);

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		if (path) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*path);
			delete path;
			return result;

		} else {

			return NULL;

		}

		#endif

		return NULL;

	}


	value lime_file_dialog_open_file (HxString title, HxString filter, HxString defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::wstring* path = FileDialog::OpenFile (_title, _filter, _defaultPath);

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		if (path) {

			value _path = wstring_to_value (path);
			delete path;
			return _path;

		} else {

			return alloc_null ();

		}

		#endif

		return alloc_null ();

	}


	HL_PRIM vbyte* HL_NAME(hl_file_dialog_open_file) (hl_vstring* title, hl_vstring* filter, hl_vstring* defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::wstring* path = FileDialog::OpenFile (_title, _filter, _defaultPath);

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		if (path) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*path);
			delete path;
			return result;

		} else {

			return NULL;

		}

		#endif

		return NULL;

	}


	value lime_file_dialog_open_files (HxString title, HxString filter, HxString defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::vector<std::wstring*> files;

		FileDialog::OpenFiles (&files, _title, _filter, _defaultPath);
		value result = alloc_array (files.size ());

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		for (int i = 0; i < files.size (); i++) {

			value _file = wstring_to_value (files[i]);
			val_array_set_i (result, i, _file);
			delete files[i];

		}

		#else
		value result = alloc_array (0);
		#endif

		return result;

	}


	HL_PRIM hl_varray* HL_NAME(hl_file_dialog_open_files) (hl_vstring* title, hl_vstring* filter, hl_vstring* defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::vector<std::wstring*> files;

		FileDialog::OpenFiles (&files, _title, _filter, _defaultPath);
		hl_varray* result = (hl_varray*)hl_alloc_array (&hlt_bytes, files.size ());
		vbyte** resultData = hl_aptr (result, vbyte*);

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		for (int i = 0; i < files.size (); i++) {

			*resultData++ = hl_wstring_to_utf8_bytes (*files[i]);
			delete files[i];

		}

		#else
		hl_varray* result = hl_alloc_array (&hlt_bytes, 0);
		#endif

		return result;

	}


	value lime_file_dialog_save_file (HxString title, HxString filter, HxString defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::wstring* path = FileDialog::SaveFile (_title, _filter, _defaultPath);

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		if (path) {

			value _path = wstring_to_value (path);
			delete path;
			return _path;

		} else {

			return alloc_null ();

		}

		#endif

		return alloc_null ();

	}


	HL_PRIM vbyte* HL_NAME(hl_file_dialog_save_file) (hl_vstring* title, hl_vstring* filter, hl_vstring* defaultPath) {

		#ifdef LIME_TINYFILEDIALOGS

		std::wstring* _title = hxstring_to_wstring (title);
		std::wstring* _filter = hxstring_to_wstring (filter);
		std::wstring* _defaultPath = hxstring_to_wstring (defaultPath);

		std::wstring* path = FileDialog::SaveFile (_title, _filter, _defaultPath);

		if (_title) delete _title;
		if (_filter) delete _filter;
		if (_defaultPath) delete _defaultPath;

		if (path) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*path);
			delete path;
			return result;

		} else {

			return NULL;

		}

		#endif

		return NULL;

	}


	value lime_file_watcher_create (value callback) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = new FileWatcher (callback);
		return CFFIPointer (watcher, gc_file_watcher);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM HL_CFFIPointer* HL_NAME(hl_file_watcher_create) (vclosure* callback) {

		// #ifdef LIME_EFSW
		// FileWatcher* watcher = new FileWatcher (callback);
		// return HLCFFIPointer (watcher, (hl_finalizer)hl_gc_file_watcher);
		// #else
		return 0;
		// #endif

	}


	value lime_file_watcher_add_directory (value handle, value path, bool recursive) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)val_data (handle);
		return alloc_int (watcher->AddDirectory (val_string (path), recursive));
		#else
		return alloc_int (0);
		#endif

	}


	HL_PRIM int HL_NAME(hl_file_watcher_add_directory) (HL_CFFIPointer* handle, hl_vstring* path, bool recursive) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)handle->ptr;
		return watcher->AddDirectory ((const char*)path, recursive);
		#else
		return 0;
		#endif

	}


	void lime_file_watcher_remove_directory (value handle, value watchID) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)val_data (handle);
		watcher->RemoveDirectory (val_int (watchID));
		#endif

	}


	HL_PRIM void HL_NAME(hl_file_watcher_remove_directory) (HL_CFFIPointer* handle, int watchID) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)handle->ptr;
		watcher->RemoveDirectory (watchID);
		#endif

	}


	void lime_file_watcher_update (value handle) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)val_data (handle);
		watcher->Update ();
		#endif

	}


	HL_PRIM void HL_NAME(hl_file_watcher_update) (HL_CFFIPointer* handle) {

		#ifdef LIME_EFSW
		FileWatcher* watcher = (FileWatcher*)handle->ptr;
		watcher->Update ();
		#endif

	}


	int lime_font_get_ascender (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetAscender ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_ascender) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetAscender ();
		#else
		return 0;
		#endif

	}


	int lime_font_get_descender (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetDescender ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_descender) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetDescender ();
		#else
		return 0;
		#endif

	}


	value lime_font_get_family_name (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		wchar_t *name = font->GetFamilyName ();
		value result = alloc_wstring (name);
		delete name;
		return result;
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM vbyte* HL_NAME(hl_font_get_family_name) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		wchar_t *name = font->GetFamilyName ();
		if (!name)
			return nullptr;
		vbyte* const result = hl_wstring_to_utf8_bytes (name);
		delete name;
		return result;
		#else
		return 0;
		#endif

	}


	int lime_font_get_glyph_index (value fontHandle, HxString character) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetGlyphIndex (hxs_utf8 (character, nullptr));
		#else
		return -1;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_glyph_index) (HL_CFFIPointer* fontHandle, hl_vstring* character) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetGlyphIndex (character ? (char*)hl_to_utf8 ((const uchar*)character->bytes) : NULL);
		#else
		return -1;
		#endif

	}


	value lime_font_get_glyph_indices (value fontHandle, HxString characters) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return (value)font->GetGlyphIndices (true, hxs_utf8 (characters, nullptr));
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM hl_varray* HL_NAME(hl_font_get_glyph_indices) (HL_CFFIPointer* fontHandle, hl_vstring* characters) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return (hl_varray*)font->GetGlyphIndices (false, characters ? (char*)hl_to_utf8 ((const uchar*)characters->bytes) : NULL);
		#else
		return 0;
		#endif

	}


	value lime_font_get_glyph_metrics (value fontHandle, int index) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return (value)font->GetGlyphMetrics (true, index);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM vdynamic* HL_NAME(hl_font_get_glyph_metrics) (HL_CFFIPointer* fontHandle, int index) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return (vdynamic*)font->GetGlyphMetrics (false, index);
		#else
		return 0;
		#endif

	}


	int lime_font_get_height (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetHeight ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_height) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetHeight ();
		#else
		return 0;
		#endif

	}


	int lime_font_get_num_glyphs (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetNumGlyphs ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_num_glyphs) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetNumGlyphs ();
		#else
		return 0;
		#endif

	}


	int lime_font_get_underline_position (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetUnderlinePosition ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_underline_position) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetUnderlinePosition ();
		#else
		return 0;
		#endif

	}


	int lime_font_get_underline_thickness (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetUnderlineThickness ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_underline_thickness) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetUnderlineThickness ();
		#else
		return 0;
		#endif

	}


	int lime_font_get_strikethrough_position (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetStrikethroughPosition ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_strikethrough_position) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetStrikethroughPosition ();
		#else
		return 0;
		#endif

	}


	int lime_font_get_strikethrough_thickness (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetStrikethroughThickness ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_strikethrough_thickness) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetStrikethroughThickness ();
		#else
		return 0;
		#endif

	}


	int lime_font_get_units_per_em (value fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return font->GetUnitsPerEM ();
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_font_get_units_per_em) (HL_CFFIPointer* fontHandle) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return font->GetUnitsPerEM ();
		#else
		return 0;
		#endif

	}


	value lime_font_load_bytes (value data) {

		#ifdef LIME_FREETYPE
		Resource resource;
		Bytes bytes;

		bytes.Set (data);
		resource = Resource (&bytes);

		Font *font = new Font (&resource, 0);

		if (font) {

			if (font->face) {

				return CFFIPointer (font, gc_font);

			} else {

				delete font;

			}

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM HL_CFFIPointer* HL_NAME(hl_font_load_bytes) (Bytes* data) {

		#ifdef LIME_FREETYPE
		Resource resource = Resource (data);

		Font *font = new Font (&resource, 0);

		if (font) {

			if (font->face) {

				return HLCFFIPointer (font, (hl_finalizer)hl_gc_font);

			} else {

				delete font;

			}

		}
		#endif

		return 0;

	}


	value lime_font_load_file (value data) {

		#ifdef LIME_FREETYPE
		Resource resource = Resource (val_string (data));

		Font *font = new Font (&resource, 0);

		if (font) {

			if (font->face) {

				return CFFIPointer (font, gc_font);

			} else {

				delete font;

			}

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM HL_CFFIPointer* HL_NAME(hl_font_load_file) (hl_vstring* data) {

		#ifdef LIME_FREETYPE
		Resource resource = Resource (data ? hl_to_utf8 ((const uchar*)data->bytes) : NULL);

		Font *font = new Font (&resource, 0);

		if (font) {

			if (font->face) {

				return HLCFFIPointer (font, (hl_finalizer)hl_gc_font);

			} else {

				delete font;

			}

		}
		#endif

		return 0;

	}


	value lime_font_load (value data) {

		if (val_is_string (data)) {

			return lime_font_load_file (data);

		} else {

			return lime_font_load_bytes (data);

		}

	}


	value lime_font_outline_decompose (value fontHandle, int size) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		return (value)font->Decompose (true, size);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM vdynamic* HL_NAME(hl_font_outline_decompose) (HL_CFFIPointer* fontHandle, int size) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		return (vdynamic*)font->Decompose (false, size);
		#else
		return 0;
		#endif

	}


	value lime_font_render_glyph (value fontHandle, int index, value data) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		Bytes bytes (data);

		if (font->RenderGlyph (index, &bytes)) {

			return bytes.Value (data);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM Bytes* HL_NAME(hl_font_render_glyph) (HL_CFFIPointer* fontHandle, int index, Bytes* data) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;

		if (font->RenderGlyph (index, data)) {

			return data;

		}
		#endif

		return NULL;

	}


	value lime_font_render_glyphs (value fontHandle, value indices, value data) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		Bytes bytes (data);

		if (font->RenderGlyphs (indices, &bytes)) {

			return bytes.Value (data);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM Bytes* HL_NAME(hl_font_render_glyphs) (HL_CFFIPointer* fontHandle, hl_varray* indices, Bytes* data) {

		// #ifdef LIME_FREETYPE
		// Font *font = (Font*)fontHandle->ptr;
		// return font->RenderGlyphs (indices, &bytes);
		// #else
		return NULL;
		// #endif

	}


	void lime_font_set_size (value fontHandle, int fontSize, int dpi) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)val_data (fontHandle);
		font->SetSize (fontSize, dpi);
		#endif

	}


	HL_PRIM void HL_NAME(hl_font_set_size) (HL_CFFIPointer* fontHandle, int fontSize, int dpi) {

		#ifdef LIME_FREETYPE
		Font *font = (Font*)fontHandle->ptr;
		font->SetSize (fontSize, dpi);
		#endif

	}


	void lime_gamepad_add_mappings (value mappings) {

		int length = val_array_size (mappings);

		for (int i = 0; i < length; i++) {

			Gamepad::AddMapping (val_string (val_array_i (mappings, i)));

		}

	}


	HL_PRIM void HL_NAME(hl_gamepad_add_mappings) (hl_varray* mappings) {

		int length = mappings->size;
		hl_vstring** mappingsData = hl_aptr (mappings, hl_vstring*);

		for (int i = 0; i < length; i++) {

			Gamepad::AddMapping (hl_to_utf8 ((const uchar*)((*mappingsData++)->bytes)));

		}

	}


	void lime_gamepad_event_manager_register (value callback, value eventObject) {

		GamepadEvent::callback = new ValuePointer (callback);
		GamepadEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_gamepad_event_manager_register) (vclosure* callback, GamepadEvent* eventObject) {

		GamepadEvent::callback = new ValuePointer (callback);
		GamepadEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	value lime_gamepad_get_device_guid (int id) {

		const char* guid = Gamepad::GetDeviceGUID (id);

		if (guid) {

			value result = alloc_string (guid);
			delete guid;
			return result;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_gamepad_get_device_guid) (int id) {

		const char* guid = Gamepad::GetDeviceGUID (id);

		if (guid) {

			return (vbyte*)guid;

		} else {

			return 0;

		}

	}


	value lime_gamepad_get_device_name (int id) {

		const char* name = Gamepad::GetDeviceName (id);
		return name ? alloc_string (name) : alloc_null ();

	}


	HL_PRIM vbyte* HL_NAME(hl_gamepad_get_device_name) (int id) {

		return (vbyte*)Gamepad::GetDeviceName (id);

	}


	void lime_gamepad_rumble (int id, double lowFrequencyRumble, double highFrequencyRumble, int duration) {

		Gamepad::Rumble (id, lowFrequencyRumble, highFrequencyRumble, duration);

	}


	HL_PRIM void HL_NAME(hl_gamepad_rumble) (int id, double lowFrequencyRumble, double highFrequencyRumble, int duration) {

		Gamepad::Rumble (id, lowFrequencyRumble, highFrequencyRumble, duration);

	}


	value lime_gzip_compress (value buffer, value bytes) {

		#ifdef LIME_ZLIB
		Bytes data (buffer);
		Bytes result (bytes);

		Zlib::Compress (GZIP, &data, &result);

		return result.Value (bytes);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_gzip_compress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_ZLIB
		Zlib::Compress (GZIP, buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	value lime_gzip_decompress (value buffer, value bytes) {

		#ifdef LIME_ZLIB
		Bytes data (buffer);
		Bytes result (bytes);

		Zlib::Decompress (GZIP, &data, &result);

		return result.Value (bytes);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_gzip_decompress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_ZLIB
		Zlib::Decompress (GZIP, buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	void lime_haptic_vibrate (int period, int duration) {

		#ifdef IPHONE
		Haptic::Vibrate (period, duration);
		#endif

	}


	HL_PRIM void HL_NAME(hl_haptic_vibrate) (int period, int duration) {

		#ifdef IPHONE
		Haptic::Vibrate (period, duration);
		#endif

	}


	value lime_image_encode (value buffer, int type, int quality, value bytes) {

		ImageBuffer imageBuffer = ImageBuffer (buffer);
		Bytes data = Bytes (bytes);

		switch (type) {

			case 0:

				#ifdef LIME_PNG
				if (PNG::Encode (&imageBuffer, &data)) {

					return data.Value (bytes);

				}
				#endif
				break;

			case 1:

				#ifdef LIME_JPEG
				if (JPEG::Encode (&imageBuffer, &data, quality)) {

					return data.Value (bytes);

				}
				#endif
				break;

			default: break;

		}

		return alloc_null ();

	}


	HL_PRIM Bytes* HL_NAME(hl_image_encode) (ImageBuffer* buffer, int type, int quality, Bytes* bytes) {

		switch (type) {

			case 0:

				#ifdef LIME_PNG
				if (PNG::Encode (buffer, bytes)) {

					return bytes;

				}
				#endif
				break;

			case 1:

				#ifdef LIME_JPEG
				if (JPEG::Encode (buffer, bytes, quality)) {

					return bytes;

				}
				#endif
				break;

			default: break;

		}

		return 0;

	}


	value lime_image_load_bytes (value data, value buffer) {

		Resource resource;
		Bytes bytes;

		ImageBuffer imageBuffer = ImageBuffer (buffer);

		bytes.Set (data);
		resource = Resource (&bytes);

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, &imageBuffer)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, &imageBuffer)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM ImageBuffer* HL_NAME(hl_image_load_bytes) (Bytes* data, ImageBuffer* buffer) {

		Resource resource = Resource (data);

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, buffer)) {

			return buffer;

		}
		#endif

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, buffer)) {

			return buffer;

		}
		#endif

		return 0;

	}


	value lime_image_load_file (value data, value buffer) {

		Resource resource = Resource (val_string (data));
		ImageBuffer imageBuffer = ImageBuffer (buffer);

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, &imageBuffer)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, &imageBuffer)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM ImageBuffer* HL_NAME(hl_image_load_file) (hl_vstring* data, ImageBuffer* buffer) {

		Resource resource = Resource (data);

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, buffer)) {

			return buffer;

		}
		#endif

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, buffer)) {

			return buffer;

		}
		#endif

		return 0;

	}


	value lime_image_load (value data, value buffer) {

		if (val_is_string (data)) {

			return lime_image_load_file (data, buffer);

		} else {

			return lime_image_load_bytes (data, buffer);

		}

	}


	void lime_image_data_util_color_transform (value image, value rect, value colorMatrix) {

		Image _image = Image (image);
		Rectangle _rect = Rectangle (rect);
		ColorMatrix _colorMatrix = ColorMatrix (colorMatrix);
		ImageDataUtil::ColorTransform (&_image, &_rect, &_colorMatrix);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_color_transform) (Image* image, Rectangle* rect, ArrayBufferView* colorMatrix) {

		ColorMatrix _colorMatrix = ColorMatrix (colorMatrix);
		ImageDataUtil::ColorTransform (image, rect, &_colorMatrix);

	}


	void lime_image_data_util_copy_channel (value image, value sourceImage, value sourceRect, value destPoint, int srcChannel, int destChannel) {

		Image _image = Image (image);
		Image _sourceImage = Image (sourceImage);
		Rectangle _sourceRect = Rectangle (sourceRect);
		Vector2 _destPoint = Vector2 (destPoint);
		ImageDataUtil::CopyChannel (&_image, &_sourceImage, &_sourceRect, &_destPoint, srcChannel, destChannel);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_copy_channel) (Image* image, Image* sourceImage, Rectangle* sourceRect, Vector2* destPoint, int srcChannel, int destChannel) {

		ImageDataUtil::CopyChannel (image, sourceImage, sourceRect, destPoint, srcChannel, destChannel);

	}


	void lime_image_data_util_copy_pixels (value image, value sourceImage, value sourceRect, value destPoint, value alphaImage, value alphaPoint, bool mergeAlpha) {

		Image _image = Image (image);
		Image _sourceImage = Image (sourceImage);
		Rectangle _sourceRect = Rectangle (sourceRect);
		Vector2 _destPoint = Vector2 (destPoint);

		if (val_is_null (alphaImage)) {

			ImageDataUtil::CopyPixels (&_image, &_sourceImage, &_sourceRect, &_destPoint, 0, 0, mergeAlpha);

		} else {

			Image _alphaImage = Image (alphaImage);
			Vector2 _alphaPoint = Vector2 (alphaPoint);

			ImageDataUtil::CopyPixels (&_image, &_sourceImage, &_sourceRect, &_destPoint, &_alphaImage, &_alphaPoint, mergeAlpha);

		}

	}


	HL_PRIM void HL_NAME(hl_image_data_util_copy_pixels) (Image* image, Image* sourceImage, Rectangle* sourceRect, Vector2* destPoint, Image* alphaImage, Vector2* alphaPoint, bool mergeAlpha) {

		if (!alphaImage) {

			ImageDataUtil::CopyPixels (image, sourceImage, sourceRect, destPoint, NULL, NULL, mergeAlpha);

		} else {

			if (!alphaPoint) {

				Vector2 _alphaPoint = Vector2 (0, 0);

				ImageDataUtil::CopyPixels (image, sourceImage, sourceRect, destPoint, alphaImage, &_alphaPoint, mergeAlpha);

			} else {

				ImageDataUtil::CopyPixels (image, sourceImage, sourceRect, destPoint, alphaImage, alphaPoint, mergeAlpha);

			}

		}

	}


	void lime_image_data_util_fill_rect (value image, value rect, int rg, int ba) {

		Image _image = Image (image);
		Rectangle _rect = Rectangle (rect);
		int32_t color = (rg << 16) | ba;
		ImageDataUtil::FillRect (&_image, &_rect, color);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_fill_rect) (Image* image, Rectangle* rect, int rg, int ba) {

		int32_t color = (rg << 16) | ba;
		ImageDataUtil::FillRect (image, rect, color);

	}


	void lime_image_data_util_flood_fill (value image, int x, int y, int rg, int ba) {

		Image _image = Image (image);
		int32_t color = (rg << 16) | ba;
		ImageDataUtil::FloodFill (&_image, x, y, color);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_flood_fill) (Image* image, int x, int y, int rg, int ba) {

		int32_t color = (rg << 16) | ba;
		ImageDataUtil::FloodFill (image, x, y, color);

	}


	void lime_image_data_util_get_pixels (value image, value rect, int format, value bytes) {

		Image _image = Image (image);
		Rectangle _rect = Rectangle (rect);
		PixelFormat _format = (PixelFormat)format;
		Bytes pixels = Bytes (bytes);
		ImageDataUtil::GetPixels (&_image, &_rect, _format, &pixels);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_get_pixels) (Image* image, Rectangle* rect, PixelFormat format, Bytes* bytes) {

		ImageDataUtil::GetPixels (image, rect, format, bytes);

	}


	void lime_image_data_util_merge (value image, value sourceImage, value sourceRect, value destPoint, int redMultiplier, int greenMultiplier, int blueMultiplier, int alphaMultiplier) {

		Image _image = Image (image);
		Image _sourceImage = Image (sourceImage);
		Rectangle _sourceRect = Rectangle (sourceRect);
		Vector2 _destPoint = Vector2 (destPoint);
		ImageDataUtil::Merge (&_image, &_sourceImage, &_sourceRect, &_destPoint, redMultiplier, greenMultiplier, blueMultiplier, alphaMultiplier);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_merge) (Image* image, Image* sourceImage, Rectangle* sourceRect, Vector2* destPoint, int redMultiplier, int greenMultiplier, int blueMultiplier, int alphaMultiplier) {

		ImageDataUtil::Merge (image, sourceImage, sourceRect, destPoint, redMultiplier, greenMultiplier, blueMultiplier, alphaMultiplier);

	}


	void lime_image_data_util_multiply_alpha (value image) {

		Image _image = Image (image);
		ImageDataUtil::MultiplyAlpha (&_image);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_multiply_alpha) (Image* image) {

		ImageDataUtil::MultiplyAlpha (image);

	}


	void lime_image_data_util_resize (value image, value buffer, int width, int height) {

		Image _image = Image (image);
		ImageBuffer _buffer = ImageBuffer (buffer);
		ImageDataUtil::Resize (&_image, &_buffer, width, height);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_resize) (Image* image, ImageBuffer* buffer, int width, int height) {

		ImageDataUtil::Resize (image, buffer, width, height);

	}


	void lime_image_data_util_set_format (value image, int format) {

		Image _image = Image (image);
		PixelFormat _format = (PixelFormat)format;
		ImageDataUtil::SetFormat (&_image, _format);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_set_format) (Image* image, PixelFormat format) {

		ImageDataUtil::SetFormat (image, format);

	}


	void lime_image_data_util_set_pixels (value image, value rect, value bytes, int offset, int format, int endian) {

		Image _image = Image (image);
		Rectangle _rect = Rectangle (rect);
		Bytes _bytes (bytes);
		PixelFormat _format = (PixelFormat)format;
		Endian _endian = (Endian)endian;
		ImageDataUtil::SetPixels (&_image, &_rect, &_bytes, offset, _format, _endian);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_set_pixels) (Image* image, Rectangle* rect, Bytes* bytes, int offset, PixelFormat format, Endian endian) {

		ImageDataUtil::SetPixels (image, rect, bytes, offset, format, endian);

	}


	int lime_image_data_util_threshold (value image, value sourceImage, value sourceRect, value destPoint, int operation, int thresholdRG, int thresholdBA, int colorRG, int colorBA, int maskRG, int maskBA, bool copySource) {

		Image _image = Image (image);
		Image _sourceImage = Image (sourceImage);
		Rectangle _sourceRect = Rectangle (sourceRect);
		Vector2 _destPoint = Vector2 (destPoint);
		int32_t threshold = (thresholdRG << 16) | thresholdBA;
		int32_t color = (colorRG << 16) | colorBA;
		int32_t mask = (maskRG << 16) | maskBA;
		return ImageDataUtil::Threshold (&_image, &_sourceImage, &_sourceRect, &_destPoint, operation, threshold, color, mask, copySource);

	}


	HL_PRIM int HL_NAME(hl_image_data_util_threshold) (Image* image, Image* sourceImage, Rectangle* sourceRect, Vector2* destPoint, int operation, int thresholdRG, int thresholdBA, int colorRG, int colorBA, int maskRG, int maskBA, bool copySource) {

		int32_t threshold = (thresholdRG << 16) | thresholdBA;
		int32_t color = (colorRG << 16) | colorBA;
		int32_t mask = (maskRG << 16) | maskBA;
		return ImageDataUtil::Threshold (image, sourceImage, sourceRect, destPoint, operation, threshold, color, mask, copySource);

	}


	void lime_image_data_util_unmultiply_alpha (value image) {

		Image _image = Image (image);
		ImageDataUtil::UnmultiplyAlpha (&_image);

	}


	HL_PRIM void HL_NAME(hl_image_data_util_unmultiply_alpha) (Image* image) {

		ImageDataUtil::UnmultiplyAlpha (image);

	}


	double lime_jni_getenv () {

		#ifdef ANDROID
		return (uintptr_t)JNI::GetEnv ();
		#else
		return 0;
		#endif

	}


	HL_PRIM double HL_NAME(hl_jni_getenv) () {

		#ifdef ANDROID
		return (uintptr_t)JNI::GetEnv ();
		#else
		return 0;
		#endif

	}


	void lime_joystick_event_manager_register (value callback, value eventObject) {

		JoystickEvent::callback = new ValuePointer (callback);
		JoystickEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_joystick_event_manager_register) (vclosure* callback, JoystickEvent* eventObject) {

		JoystickEvent::callback = new ValuePointer (callback);
		JoystickEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	value lime_joystick_get_device_guid (int id) {

		const char* guid = Joystick::GetDeviceGUID (id);
		return guid ? alloc_string (guid) : alloc_null ();

	}


	HL_PRIM vbyte* HL_NAME(hl_joystick_get_device_guid) (int id) {

		return (vbyte*)Joystick::GetDeviceGUID (id);

	}


	value lime_joystick_get_device_name (int id) {

		const char* name = Joystick::GetDeviceName (id);
		return name ? alloc_string (name) : alloc_null ();

	}


	HL_PRIM vbyte* HL_NAME(hl_joystick_get_device_name) (int id) {

		return (vbyte*)Joystick::GetDeviceName (id);

	}


	int lime_joystick_get_num_axes (int id) {

		return Joystick::GetNumAxes (id);

	}


	HL_PRIM int HL_NAME(hl_joystick_get_num_axes) (int id) {

		return Joystick::GetNumAxes (id);

	}


	int lime_joystick_get_num_buttons (int id) {

		return Joystick::GetNumButtons (id);

	}


	HL_PRIM int HL_NAME(hl_joystick_get_num_buttons) (int id) {

		return Joystick::GetNumButtons (id);

	}


	int lime_joystick_get_num_hats (int id) {

		return Joystick::GetNumHats (id);

	}


	HL_PRIM int HL_NAME(hl_joystick_get_num_hats) (int id) {

		return Joystick::GetNumHats (id);

	}


	value lime_jpeg_decode_bytes (value data, bool decodeData, value buffer) {

		ImageBuffer imageBuffer (buffer);

		Bytes bytes (data);
		Resource resource = Resource (&bytes);

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, &imageBuffer, decodeData)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM ImageBuffer* HL_NAME(hl_jpeg_decode_bytes) (Bytes* data, bool decodeData, ImageBuffer* buffer) {

		Resource resource = Resource (data);

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, buffer, decodeData)) {

			return buffer;

		}
		#endif

		return 0;

	}


	value lime_jpeg_decode_file (HxString path, bool decodeData, value buffer) {

		ImageBuffer imageBuffer (buffer);
		Resource resource = Resource (hxs_utf8 (path, nullptr));

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, &imageBuffer, decodeData)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM ImageBuffer* HL_NAME(hl_jpeg_decode_file) (hl_vstring* path, bool decodeData, ImageBuffer* buffer) {

		Resource resource = Resource (path);

		#ifdef LIME_JPEG
		if (JPEG::Decode (&resource, buffer, decodeData)) {

			return buffer;

		}
		#endif

		return 0;

	}


	int lime_key_code_from_scan_code (int scanCode) {

		return KeyCode::FromScanCode (scanCode);

	}


	HL_PRIM int HL_NAME(hl_key_code_from_scan_code) (int scanCode) {

		return KeyCode::FromScanCode (scanCode);

	}


	int lime_key_code_to_scan_code (int keyCode) {

		return KeyCode::ToScanCode (keyCode);

	}


	HL_PRIM int HL_NAME(hl_key_code_to_scan_code) (int keyCode) {

		return KeyCode::ToScanCode (keyCode);

	}


	void lime_key_event_manager_register (value callback, value eventObject) {

		KeyEvent::callback = new ValuePointer (callback);
		KeyEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_key_event_manager_register) (vclosure* callback, KeyEvent* eventObject) {

		KeyEvent::callback = new ValuePointer (callback);
		KeyEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	value lime_locale_get_system_locale () {

		std::string* locale = Locale::GetSystemLocale ();

		if (!locale) {

			return alloc_null ();

		} else {

			value result = alloc_string (locale->c_str ());
			delete locale;
			return result;

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_locale_get_system_locale) () {

		std::string* locale = Locale::GetSystemLocale ();

		if (!locale) {

			return 0;

		} else {

			int size = locale->size ();
			char* _locale = (char*)malloc (size + 1);
			strncpy (_locale, locale->c_str (), size);
			_locale[size] = '\0';
			delete locale;

			return (vbyte*)_locale;

		}

	}


	value lime_lzma_compress (value buffer, value bytes) {

		#ifdef LIME_LZMA
		Bytes data (buffer);
		Bytes result (bytes);

		LZMA::Compress (&data, &result);

		return result.Value (bytes);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_lzma_compress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_LZMA
		LZMA::Compress (buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	value lime_lzma_decompress (value buffer, value bytes) {

		#ifdef LIME_LZMA
		Bytes data (buffer);
		Bytes result (bytes);

		LZMA::Decompress (&data, &result);

		return result.Value (bytes);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_lzma_decompress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_LZMA
		LZMA::Decompress (buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	void lime_mouse_event_manager_register (value callback, value eventObject) {

		MouseEvent::callback = new ValuePointer (callback);
		MouseEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_mouse_event_manager_register) (vclosure* callback, MouseEvent* eventObject) {

		MouseEvent::callback = new ValuePointer (callback);
		MouseEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	void lime_neko_execute (HxString module) {

		#ifdef LIME_NEKO
		NekoVM::Execute (module.c_str ());
		#endif

	}


	void lime_orientation_event_manager_register (value callback, value eventObject) {

		OrientationEvent::callback = new ValuePointer (callback);
		OrientationEvent::eventObject = new ValuePointer (eventObject);
		System::EnableDeviceOrientationChange(true);

	}


	HL_PRIM void HL_NAME(hl_orientation_event_manager_register) (vclosure* callback, OrientationEvent* eventObject) {

		OrientationEvent::callback = new ValuePointer (callback);
		OrientationEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	value lime_png_decode_bytes (value data, bool decodeData, value buffer) {

		ImageBuffer imageBuffer (buffer);
		Bytes bytes (data);
		Resource resource = Resource (&bytes);

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, &imageBuffer, decodeData)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM ImageBuffer* HL_NAME(hl_png_decode_bytes) (Bytes* data, bool decodeData, ImageBuffer* buffer) {

		Resource resource = Resource (data);

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, buffer, decodeData)) {

			return buffer;

		}
		#endif

		return 0;

	}


	value lime_png_decode_file (HxString path, bool decodeData, value buffer) {

		ImageBuffer imageBuffer (buffer);
		Resource resource = Resource (hxs_utf8 (path, nullptr));

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, &imageBuffer, decodeData)) {

			return imageBuffer.Value (buffer);

		}
		#endif

		return alloc_null ();

	}


	HL_PRIM ImageBuffer* HL_NAME(hl_png_decode_file) (hl_vstring* path, bool decodeData, ImageBuffer* buffer) {

		Resource resource = Resource (path);

		#ifdef LIME_PNG
		if (PNG::Decode (&resource, buffer, decodeData)) {

			return buffer;

		}
		#endif

		return 0;

	}


	void lime_render_event_manager_register (value callback, value eventObject) {

		RenderEvent::callback = new ValuePointer (callback);
		RenderEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_render_event_manager_register) (vclosure* callback, RenderEvent* eventObject) {

		RenderEvent::callback = new ValuePointer (callback);
		RenderEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	void lime_sensor_event_manager_register (value callback, value eventObject) {

		SensorEvent::callback = new ValuePointer (callback);
		SensorEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_sensor_event_manager_register) (vclosure* callback, SensorEvent* eventObject) {

		SensorEvent::callback = new ValuePointer (callback);
		SensorEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	bool lime_system_get_allow_screen_timeout () {

		return System::GetAllowScreenTimeout ();

	}


	HL_PRIM bool HL_NAME(hl_system_get_allow_screen_timeout) () {

		return System::GetAllowScreenTimeout ();

	}


	value lime_system_get_device_model () {

		std::wstring* model = System::GetDeviceModel ();

		if (model) {

			value result = alloc_wstring (model->c_str ());
			delete model;
			return result;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_system_get_device_model) () {

		#ifndef EMSCRIPTEN

		std::wstring* model = System::GetDeviceModel ();

		if (model) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*model);
			delete model;
			return result;

		}

		#endif

		return 0;

	}


	value lime_system_get_device_vendor () {

		std::wstring* vendor = System::GetDeviceVendor ();

		if (vendor) {

			value result = alloc_wstring (vendor->c_str ());
			delete vendor;
			return result;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_system_get_device_vendor) () {

		#ifndef EMSCRIPTEN

		std::wstring* vendor = System::GetDeviceVendor ();

		if (vendor) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*vendor);
			delete vendor;
			return result;

		}

		#endif

		return 0;

	}


	value lime_system_get_directory (int type, HxString company, HxString title) {

		std::wstring* path = System::GetDirectory ((SystemDirectory)type, hxs_utf8 (company, nullptr), hxs_utf8 (title, nullptr));

		if (path) {

			value result = alloc_wstring (path->c_str ());
			delete path;
			return result;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_system_get_directory) (int type, hl_vstring* company, hl_vstring* title) {

		#ifndef EMSCRIPTEN

		std::wstring* path = System::GetDirectory ((SystemDirectory)type, company ? (char*)hl_to_utf8 ((const uchar*)company->bytes) : NULL, title ? (char*)hl_to_utf8 ((const uchar*)title->bytes) : NULL);

		if (path) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*path);
			delete path;
			return result;

		}

		#endif

		return 0;

	}


	value lime_system_get_display (int id) {

		return (value)System::GetDisplay (true, id);

	}


	HL_PRIM vdynamic* HL_NAME(hl_system_get_display) (int id) {

		return (vdynamic*)System::GetDisplay (false, id);

	}


	bool lime_system_get_ios_tablet () {

		#ifdef IPHONE
		return System::GetIOSTablet ();
		#else
		return false;
		#endif

	}


	HL_PRIM bool HL_NAME(hl_system_get_ios_tablet) () {

		#ifdef IPHONE
		return System::GetIOSTablet ();
		#else
		return false;
		#endif

	}


	int lime_system_get_num_displays () {

		return System::GetNumDisplays ();

	}


	HL_PRIM int HL_NAME(hl_system_get_num_displays) () {

		return System::GetNumDisplays ();

	}


	int lime_system_get_device_orientation () {

		return System::GetDeviceOrientation();

	}


	HL_PRIM int HL_NAME(hl_system_get_device_orientation) () {

		return System::GetDeviceOrientation();

	}


	value lime_system_get_platform_label () {

		std::wstring* label = System::GetPlatformLabel ();

		if (label) {

			value result = alloc_wstring (label->c_str ());
			delete label;
			return result;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_system_get_platform_label) () {

		#ifndef EMSCRIPTEN

		std::wstring* label = System::GetPlatformLabel ();

		if (label) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*label);
			delete label;
			return result;

		}

		#endif

		return 0;

	}


	value lime_system_get_platform_name () {

		std::wstring* name = System::GetPlatformName ();

		if (name) {

			value result = alloc_wstring (name->c_str ());
			delete name;
			return result;

		} else {

			return 0;

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_system_get_platform_name) () {

		#ifndef EMSCRIPTEN

		std::wstring* name = System::GetPlatformName ();

		if (name) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*name);
			delete name;
			return result;

		}

		#endif

		return 0;

	}


	value lime_system_get_platform_version () {

		std::wstring* version = System::GetPlatformVersion ();

		if (version) {

			value result = alloc_wstring (version->c_str ());
			delete version;
			return result;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM vbyte* HL_NAME(hl_system_get_platform_version) () {

		#ifndef EMSCRIPTEN

		std::wstring* version = System::GetPlatformVersion ();

		if (version) {

			vbyte* const result = hl_wstring_to_utf8_bytes (*version);
			delete version;
			return result;
		}

		#endif

		return 0;

	}


	double lime_system_get_timer () {

		return System::GetTimer ();

	}


	HL_PRIM double HL_NAME(hl_system_get_timer) () {

		return System::GetTimer ();

	}


	int lime_system_get_windows_console_mode (int handleType) {

		#if defined (HX_WINDOWS) && !defined (HX_WINRT)
		return System::GetWindowsConsoleMode (handleType);
		#else
		return 0;
		#endif

	}


	HL_PRIM int HL_NAME(hl_system_get_windows_console_mode) (int handleType) {

		#if defined (HX_WINDOWS) && !defined (HX_WINRT)
		return System::GetWindowsConsoleMode (handleType);
		#else
		return 0;
		#endif

	}


	void lime_system_open_file (HxString path) {

		#ifdef IPHONE
		System::OpenFile (path.c_str ());
		#endif

	}


	HL_PRIM void HL_NAME(hl_system_open_file) (vbyte* path) {

		#ifdef IPHONE
		System::OpenFile ((char*)path);
		#endif

	}


	void lime_system_open_url (HxString url, HxString target) {

		#ifdef IPHONE
		System::OpenURL (url.c_str (), target.c_str ());
		#endif

	}


	HL_PRIM void HL_NAME(hl_system_open_url) (vbyte* url, vbyte* target) {

		#ifdef IPHONE
		System::OpenURL ((char*)url, (char*)target);
		#endif

	}


	bool lime_system_set_allow_screen_timeout (bool allow) {

		return System::SetAllowScreenTimeout (allow);

	}


	HL_PRIM bool HL_NAME(hl_system_set_allow_screen_timeout) (bool allow) {

		return System::SetAllowScreenTimeout (allow);

	}


	bool lime_system_set_windows_console_mode (int handleType, int mode) {

		#if defined (HX_WINDOWS) && !defined (HX_WINRT)
		return System::SetWindowsConsoleMode (handleType, mode);
		#else
		return false;
		#endif

	}


	HL_PRIM bool HL_NAME(hl_system_set_windows_console_mode) (int handleType, int mode) {

		#if defined (HX_WINDOWS) && !defined (HX_WINRT)
		return System::SetWindowsConsoleMode (handleType, mode);
		#else
		return false;
		#endif

	}


	void lime_text_event_manager_register (value callback, value eventObject) {

		TextEvent::callback = new ValuePointer (callback);
		TextEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_text_event_manager_register) (vclosure* callback, TextEvent* eventObject) {

		TextEvent::callback = new ValuePointer (callback);
		TextEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	void lime_touch_event_manager_register (value callback, value eventObject) {

		TouchEvent::callback = new ValuePointer (callback);
		TouchEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_touch_event_manager_register) (vclosure* callback, TouchEvent* eventObject) {

		TouchEvent::callback = new ValuePointer (callback);
		TouchEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	void lime_window_alert (value window, HxString message, HxString title) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->Alert (hxs_utf8 (message, nullptr), hxs_utf8 (title, nullptr));

	}


	HL_PRIM void HL_NAME(hl_window_alert) (HL_CFFIPointer* window, hl_vstring* message, hl_vstring* title) {

		Window* targetWindow = (Window*)window->ptr;
		const char *cmessage = message ? hl_to_utf8(message->bytes) : nullptr;
		const char *ctitle = title ? hl_to_utf8(title->bytes) : nullptr;
		targetWindow->Alert (cmessage, ctitle);

	}


	void lime_window_close (value window) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->Close ();

	}


	HL_PRIM void HL_NAME(hl_window_close) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->Close ();

	}


	void lime_window_context_flip (value window) {

		((Window*)val_data (window))->ContextFlip ();

	}


	HL_PRIM void HL_NAME(hl_window_context_flip) (HL_CFFIPointer* window) {

		((Window*)window->ptr)->ContextFlip ();

	}


	value lime_window_context_lock (value window) {

		return (value)((Window*)val_data (window))->ContextLock (true);

	}


	HL_PRIM vdynamic* HL_NAME(hl_window_context_lock) (HL_CFFIPointer* window) {

		return (vdynamic*)((Window*)window->ptr)->ContextLock (false);

	}


	void lime_window_context_make_current (value window) {

		((Window*)val_data (window))->ContextMakeCurrent ();

	}


	HL_PRIM void HL_NAME(hl_window_context_make_current) (HL_CFFIPointer* window) {

		((Window*)window->ptr)->ContextMakeCurrent ();

	}


	void lime_window_context_unlock (value window) {

		((Window*)val_data (window))->ContextUnlock ();

	}


	HL_PRIM void HL_NAME(hl_window_context_unlock) (HL_CFFIPointer* window) {

		((Window*)window->ptr)->ContextUnlock ();

	}


	value lime_window_create (value application, int width, int height, int flags, HxString title) {

		Window* window = CreateWindow ((Application*)val_data (application), width, height, flags, hxs_utf8 (title, nullptr));
		return CFFIPointer (window, gc_window);

	}


	HL_PRIM HL_CFFIPointer* HL_NAME(hl_window_create) (HL_CFFIPointer* application, int width, int height, int flags, hl_vstring* title) {

		Window* window = CreateWindow ((Application*)application->ptr, width, height, flags, (const char*)hl_to_utf8 ((const uchar*)title->bytes));
		return HLCFFIPointer (window, (hl_finalizer)hl_gc_window);

	}


	void lime_window_event_manager_register (value callback, value eventObject) {

		WindowEvent::callback = new ValuePointer (callback);
		WindowEvent::eventObject = new ValuePointer (eventObject);

	}


	HL_PRIM void HL_NAME(hl_window_event_manager_register) (vclosure* callback, WindowEvent* eventObject) {

		WindowEvent::callback = new ValuePointer (callback);
		WindowEvent::eventObject = new ValuePointer ((vobj*)eventObject);

	}


	void lime_window_focus (value window) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->Focus ();

	}


	HL_PRIM void HL_NAME(hl_window_focus) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->Focus ();

	}


	double lime_window_get_context (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return (uintptr_t)targetWindow->GetContext ();

	}


	HL_PRIM double HL_NAME(hl_window_get_context) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return (uintptr_t)targetWindow->GetContext ();

	}


	value lime_window_get_context_type (value window) {

		Window* targetWindow = (Window*)val_data (window);
		const char* type = targetWindow->GetContextType ();
		return type ? alloc_string (type) : alloc_null ();

	}


	HL_PRIM vbyte* HL_NAME(hl_window_get_context_type) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return (vbyte*)targetWindow->GetContextType ();

	}


	int lime_window_get_display (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetDisplay ();

	}


	HL_PRIM int HL_NAME(hl_window_get_display) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetDisplay ();

	}


	value lime_window_get_display_mode (value window) {

		Window* targetWindow = (Window*)val_data (window);
		DisplayMode displayMode;
		targetWindow->GetDisplayMode (&displayMode);
		return (value)displayMode.Value ();

	}


	HL_PRIM void HL_NAME(hl_window_get_display_mode) (HL_CFFIPointer* window, DisplayMode* result) {

		Window* targetWindow = (Window*)window->ptr;
		DisplayMode displayMode;
		targetWindow->GetDisplayMode (&displayMode);
		result->CopyFrom(&displayMode);

	}


	int lime_window_get_height (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetHeight ();

	}


	HL_PRIM int HL_NAME(hl_window_get_height) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetHeight ();

	}


	int32_t lime_window_get_id (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return (int32_t)targetWindow->GetID ();

	}


	HL_PRIM int32_t HL_NAME(hl_window_get_id) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return (int32_t)targetWindow->GetID ();

	}


	bool lime_window_get_mouse_lock (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetMouseLock ();

	}


	HL_PRIM bool HL_NAME(hl_window_get_mouse_lock) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetMouseLock ();

	}


	double lime_window_get_opacity (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return (float)targetWindow->GetOpacity ();

	}


	HL_PRIM double HL_NAME(hl_window_get_opacity) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return (float)targetWindow->GetOpacity ();

	}


	double lime_window_get_scale (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetScale ();

	}


	HL_PRIM double HL_NAME(hl_window_get_scale) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetScale ();

	}


	bool lime_window_get_text_input_enabled (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetTextInputEnabled ();

	}


	HL_PRIM bool HL_NAME(hl_window_get_text_input_enabled) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetTextInputEnabled ();

	}


	int lime_window_get_width (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetWidth ();

	}


	HL_PRIM int HL_NAME(hl_window_get_width) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetWidth ();

	}


	int lime_window_get_x (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetX ();

	}


	HL_PRIM int HL_NAME(hl_window_get_x) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetX ();

	}


	int lime_window_get_y (value window) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->GetY ();

	}


	HL_PRIM int HL_NAME(hl_window_get_y) (HL_CFFIPointer* window) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->GetY ();

	}


	void lime_window_move (value window, int x, int y) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->Move (x, y);

	}


	HL_PRIM void HL_NAME(hl_window_move) (HL_CFFIPointer* window, int x, int y) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->Move (x, y);

	}


	value lime_window_read_pixels (value window, value rect, value imageBuffer) {

		Window* targetWindow = (Window*)val_data (window);
		ImageBuffer buffer (imageBuffer);

		if (!val_is_null (rect)) {

			Rectangle _rect = Rectangle (rect);
			targetWindow->ReadPixels (&buffer, &_rect);

		} else {

			targetWindow->ReadPixels (&buffer, NULL);

		}

		return buffer.Value (imageBuffer);

	}


	HL_PRIM ImageBuffer* HL_NAME(hl_window_read_pixels) (HL_CFFIPointer* window, Rectangle* rect, ImageBuffer* imageBuffer) {

		Window* targetWindow = (Window*)window->ptr;

		if (rect) {

			targetWindow->ReadPixels (imageBuffer, rect);

		} else {

			targetWindow->ReadPixels (imageBuffer, NULL);

		}

		return imageBuffer;

	}


	void lime_window_resize (value window, int width, int height) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->Resize (width, height);

	}


	HL_PRIM void HL_NAME(hl_window_resize) (HL_CFFIPointer* window, int width, int height) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->Resize (width, height);

	}


	void lime_window_set_minimum_size (value window, int width, int height) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->SetMinimumSize (width, height);

	}


	HL_PRIM void HL_NAME(hl_window_set_minimum_size) (HL_CFFIPointer* window, int width, int height) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetMinimumSize (width, height);

	}


	void lime_window_set_maximum_size (value window, int width, int height) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->SetMaximumSize (width, height);

	}


	HL_PRIM void HL_NAME(hl_window_set_maximum_size) (HL_CFFIPointer* window, int width, int height) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetMaximumSize (width, height);

	}


	bool lime_window_set_borderless (value window, bool borderless) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->SetBorderless (borderless);

	}


	HL_PRIM bool HL_NAME(hl_window_set_borderless) (HL_CFFIPointer* window, bool borderless) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->SetBorderless (borderless);

	}


	void lime_window_set_cursor (value window, int cursor) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->SetCursor ((Cursor)cursor);

	}


	HL_PRIM void HL_NAME(hl_window_set_cursor) (HL_CFFIPointer* window, int cursor) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetCursor ((Cursor)cursor);

	}


	value lime_window_set_display_mode (value window, value displayMode) {

		Window* targetWindow = (Window*)val_data (window);
		DisplayMode _displayMode (displayMode);
		targetWindow->SetDisplayMode (&_displayMode);
		targetWindow->GetDisplayMode (&_displayMode);
		return (value)_displayMode.Value ();

	}


	HL_PRIM void HL_NAME(hl_window_set_display_mode) (HL_CFFIPointer* window, DisplayMode* displayMode, DisplayMode* result) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetDisplayMode (displayMode);
		targetWindow->GetDisplayMode (displayMode);
		result->CopyFrom(displayMode);

	}


	bool lime_window_set_fullscreen (value window, bool fullscreen) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->SetFullscreen (fullscreen);

	}


	HL_PRIM bool HL_NAME(hl_window_set_fullscreen) (HL_CFFIPointer* window, bool fullscreen) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->SetFullscreen (fullscreen);

	}


	void lime_window_set_icon (value window, value buffer) {

		Window* targetWindow = (Window*)val_data (window);
		ImageBuffer imageBuffer = ImageBuffer (buffer);
		targetWindow->SetIcon (&imageBuffer);

	}


	HL_PRIM void HL_NAME(hl_window_set_icon) (HL_CFFIPointer* window, ImageBuffer* buffer) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetIcon (buffer);

	}


	bool lime_window_set_maximized (value window, bool maximized) {

		Window* targetWindow = (Window*)val_data(window);
		return targetWindow->SetMaximized (maximized);

	}


	HL_PRIM bool HL_NAME(hl_window_set_maximized) (HL_CFFIPointer* window, bool maximized) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->SetMaximized (maximized);

	}


	bool lime_window_set_minimized (value window, bool minimized) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->SetMinimized (minimized);

	}


	HL_PRIM bool HL_NAME(hl_window_set_minimized) (HL_CFFIPointer* window, bool minimized) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->SetMinimized (minimized);

	}


	void lime_window_set_mouse_lock (value window, bool mouseLock) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->SetMouseLock (mouseLock);

	}


	HL_PRIM void HL_NAME(hl_window_set_mouse_lock) (HL_CFFIPointer* window, bool mouseLock) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetMouseLock (mouseLock);

	}


	void lime_window_set_opacity (value window, double opacity) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->SetOpacity ((float)opacity);

	}


	HL_PRIM void HL_NAME(hl_window_set_opacity) (HL_CFFIPointer* window, double opacity) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetOpacity ((float)opacity);

	}


	bool lime_window_set_resizable (value window, bool resizable) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->SetResizable (resizable);

	}


	HL_PRIM bool HL_NAME(hl_window_set_resizable) (HL_CFFIPointer* window, bool resizable) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->SetResizable (resizable);

	}


	void lime_window_set_text_input_enabled (value window, bool enabled) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->SetTextInputEnabled (enabled);

	}


	HL_PRIM void HL_NAME(hl_window_set_text_input_enabled) (HL_CFFIPointer* window, bool enabled) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetTextInputEnabled (enabled);

	}


	void lime_window_set_text_input_rect (value window, value rect) {

		Window* targetWindow = (Window*)val_data (window);
		Rectangle _rect = Rectangle (rect);
		targetWindow->SetTextInputRect (&_rect);

	}


	HL_PRIM void HL_NAME(hl_window_set_text_input_rect) (HL_CFFIPointer* window, Rectangle* rect) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->SetTextInputRect (rect);

	}


	value lime_window_set_title (value window, HxString title) {

		Window* targetWindow = (Window*)val_data (window);
		const char* titleUtf8 = hxs_utf8 (title, nullptr);
		const char* result = targetWindow->SetTitle (titleUtf8);

		if (result) {

			value _result = alloc_string (result);

			if (result != titleUtf8) {

				free ((char*) result);

			}

			return _result;

		} else {

			return alloc_null ();

		}

	}


	HL_PRIM hl_vstring* HL_NAME(hl_window_set_title) (HL_CFFIPointer* window, hl_vstring* title) {

		Window* targetWindow = (Window*)window->ptr;
		const char* result = targetWindow->SetTitle ((char*)hl_to_utf8 ((const uchar*)title->bytes));

		if (result) {

			return title;

		} else {

			return 0;

		}

	}


	bool lime_window_set_visible (value window, bool visible) {

		Window* targetWindow = (Window*)val_data (window);
		return targetWindow->SetVisible (visible);

	}


	HL_PRIM bool HL_NAME(hl_window_set_visible) (HL_CFFIPointer* window, bool visible) {

		Window* targetWindow = (Window*)window->ptr;
		return targetWindow->SetVisible (visible);

	}


	void lime_window_warp_mouse (value window, int x, int y) {

		Window* targetWindow = (Window*)val_data (window);
		targetWindow->WarpMouse (x, y);

	}


	HL_PRIM void HL_NAME(hl_window_warp_mouse) (HL_CFFIPointer* window, int x, int y) {

		Window* targetWindow = (Window*)window->ptr;
		targetWindow->WarpMouse (x, y);

	}


	value lime_zlib_compress (value buffer, value bytes) {

		#ifdef LIME_ZLIB
		Bytes data (buffer);
		Bytes result (bytes);

		Zlib::Compress (ZLIB, &data, &result);

		return result.Value (bytes);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_zlib_compress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_ZLIB
		Zlib::Compress (ZLIB, buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	value lime_zlib_decompress (value buffer, value bytes) {

		#ifdef LIME_ZLIB
		Bytes data (buffer);
		Bytes result (bytes);

		Zlib::Decompress (ZLIB, &data, &result);

		return result.Value (bytes);
		#else
		return alloc_null ();
		#endif

	}


	HL_PRIM Bytes* HL_NAME(hl_zlib_decompress) (Bytes* buffer, Bytes* bytes) {

		#ifdef LIME_ZLIB
		Zlib::Decompress (ZLIB, buffer, bytes);
		return bytes;
		#else
		return 0;
		#endif

	}


	DEFINE_PRIME0 (lime_application_create);
	DEFINE_PRIME2v (lime_application_event_manager_register);
	DEFINE_PRIME1 (lime_application_exec);
	DEFINE_PRIME1v (lime_application_init);
	DEFINE_PRIME1 (lime_application_quit);
	DEFINE_PRIME2v (lime_application_set_frame_rate);
	DEFINE_PRIME1 (lime_application_update);
	DEFINE_PRIME2 (lime_audio_load);
	DEFINE_PRIME2 (lime_audio_load_bytes);
	DEFINE_PRIME2 (lime_audio_load_file);
	DEFINE_PRIME3 (lime_bytes_from_data_pointer);
	DEFINE_PRIME1 (lime_bytes_get_data_pointer);
	DEFINE_PRIME2 (lime_bytes_get_data_pointer_offset);
	DEFINE_PRIME2 (lime_bytes_read_file);
	DEFINE_PRIME1 (lime_cffi_get_native_pointer);
	DEFINE_PRIME1 (lime_cffi_set_finalizer);
	DEFINE_PRIME2v (lime_clipboard_event_manager_register);
	DEFINE_PRIME0 (lime_clipboard_get_text);
	DEFINE_PRIME1v (lime_clipboard_set_text);
	DEFINE_PRIME2 (lime_data_pointer_offset);
	DEFINE_PRIME2 (lime_deflate_compress);
	DEFINE_PRIME2 (lime_deflate_decompress);
	DEFINE_PRIME2v (lime_drop_event_manager_register);
	DEFINE_PRIME3 (lime_file_dialog_open_directory);
	DEFINE_PRIME3 (lime_file_dialog_open_file);
	DEFINE_PRIME3 (lime_file_dialog_open_files);
	DEFINE_PRIME3 (lime_file_dialog_save_file);
	DEFINE_PRIME1 (lime_file_watcher_create);
	DEFINE_PRIME3 (lime_file_watcher_add_directory);
	DEFINE_PRIME2v (lime_file_watcher_remove_directory);
	DEFINE_PRIME1v (lime_file_watcher_update);
	DEFINE_PRIME1 (lime_font_get_ascender);
	DEFINE_PRIME1 (lime_font_get_descender);
	DEFINE_PRIME1 (lime_font_get_family_name);
	DEFINE_PRIME2 (lime_font_get_glyph_index);
	DEFINE_PRIME2 (lime_font_get_glyph_indices);
	DEFINE_PRIME2 (lime_font_get_glyph_metrics);
	DEFINE_PRIME1 (lime_font_get_height);
	DEFINE_PRIME1 (lime_font_get_num_glyphs);
	DEFINE_PRIME1 (lime_font_get_underline_position);
	DEFINE_PRIME1 (lime_font_get_underline_thickness);
	DEFINE_PRIME1 (lime_font_get_strikethrough_position);
	DEFINE_PRIME1 (lime_font_get_strikethrough_thickness);
	DEFINE_PRIME1 (lime_font_get_units_per_em);
	DEFINE_PRIME1 (lime_font_load);
	DEFINE_PRIME1 (lime_font_load_bytes);
	DEFINE_PRIME1 (lime_font_load_file);
	DEFINE_PRIME2 (lime_font_outline_decompose);
	DEFINE_PRIME3 (lime_font_render_glyph);
	DEFINE_PRIME3 (lime_font_render_glyphs);
	DEFINE_PRIME3v (lime_font_set_size);
	DEFINE_PRIME1v (lime_gamepad_add_mappings);
	DEFINE_PRIME2v (lime_gamepad_event_manager_register);
	DEFINE_PRIME1 (lime_gamepad_get_device_guid);
	DEFINE_PRIME1 (lime_gamepad_get_device_name);
	DEFINE_PRIME4v (lime_gamepad_rumble);
	DEFINE_PRIME2 (lime_gzip_compress);
	DEFINE_PRIME2 (lime_gzip_decompress);
	DEFINE_PRIME2v (lime_haptic_vibrate);
	DEFINE_PRIME3v (lime_image_data_util_color_transform);
	DEFINE_PRIME6v (lime_image_data_util_copy_channel);
	DEFINE_PRIME7v (lime_image_data_util_copy_pixels);
	DEFINE_PRIME4v (lime_image_data_util_fill_rect);
	DEFINE_PRIME5v (lime_image_data_util_flood_fill);
	DEFINE_PRIME4v (lime_image_data_util_get_pixels);
	DEFINE_PRIME8v (lime_image_data_util_merge);
	DEFINE_PRIME1v (lime_image_data_util_multiply_alpha);
	DEFINE_PRIME4v (lime_image_data_util_resize);
	DEFINE_PRIME2v (lime_image_data_util_set_format);
	DEFINE_PRIME6v (lime_image_data_util_set_pixels);
	DEFINE_PRIME12 (lime_image_data_util_threshold);
	DEFINE_PRIME1v (lime_image_data_util_unmultiply_alpha);
	DEFINE_PRIME4 (lime_image_encode);
	DEFINE_PRIME2 (lime_image_load);
	DEFINE_PRIME2 (lime_image_load_bytes);
	DEFINE_PRIME2 (lime_image_load_file);
	DEFINE_PRIME0 (lime_jni_getenv);
	DEFINE_PRIME2v (lime_joystick_event_manager_register);
	DEFINE_PRIME1 (lime_joystick_get_device_guid);
	DEFINE_PRIME1 (lime_joystick_get_device_name);
	DEFINE_PRIME1 (lime_joystick_get_num_axes);
	DEFINE_PRIME1 (lime_joystick_get_num_buttons);
	DEFINE_PRIME1 (lime_joystick_get_num_hats);
	DEFINE_PRIME3 (lime_jpeg_decode_bytes);
	DEFINE_PRIME3 (lime_jpeg_decode_file);
	DEFINE_PRIME1 (lime_key_code_from_scan_code);
	DEFINE_PRIME1 (lime_key_code_to_scan_code);
	DEFINE_PRIME2v (lime_key_event_manager_register);
	DEFINE_PRIME0 (lime_locale_get_system_locale);
	DEFINE_PRIME2 (lime_lzma_compress);
	DEFINE_PRIME2 (lime_lzma_decompress);
	DEFINE_PRIME2v (lime_mouse_event_manager_register);
	DEFINE_PRIME1v (lime_neko_execute);
	DEFINE_PRIME2v (lime_orientation_event_manager_register);
	DEFINE_PRIME3 (lime_png_decode_bytes);
	DEFINE_PRIME3 (lime_png_decode_file);
	DEFINE_PRIME2v (lime_render_event_manager_register);
	DEFINE_PRIME2v (lime_sensor_event_manager_register);
	DEFINE_PRIME0 (lime_system_get_allow_screen_timeout);
	DEFINE_PRIME0 (lime_system_get_device_model);
	DEFINE_PRIME0 (lime_system_get_device_vendor);
	DEFINE_PRIME3 (lime_system_get_directory);
	DEFINE_PRIME1 (lime_system_get_display);
	DEFINE_PRIME0 (lime_system_get_ios_tablet);
	DEFINE_PRIME0 (lime_system_get_num_displays);
	DEFINE_PRIME0 (lime_system_get_device_orientation);
	DEFINE_PRIME0 (lime_system_get_platform_label);
	DEFINE_PRIME0 (lime_system_get_platform_name);
	DEFINE_PRIME0 (lime_system_get_platform_version);
	DEFINE_PRIME0 (lime_system_get_timer);
	DEFINE_PRIME1 (lime_system_get_windows_console_mode);
	DEFINE_PRIME1v (lime_system_open_file);
	DEFINE_PRIME2v (lime_system_open_url);
	DEFINE_PRIME1 (lime_system_set_allow_screen_timeout);
	DEFINE_PRIME2 (lime_system_set_windows_console_mode);
	DEFINE_PRIME2v (lime_text_event_manager_register);
	DEFINE_PRIME2v (lime_touch_event_manager_register);
	DEFINE_PRIME3v (lime_window_alert);
	DEFINE_PRIME1v (lime_window_close);
	DEFINE_PRIME1v (lime_window_context_flip);
	DEFINE_PRIME1 (lime_window_context_lock);
	DEFINE_PRIME1v (lime_window_context_make_current);
	DEFINE_PRIME1v (lime_window_context_unlock);
	DEFINE_PRIME5 (lime_window_create);
	DEFINE_PRIME2v (lime_window_event_manager_register);
	DEFINE_PRIME1v (lime_window_focus);
	DEFINE_PRIME1 (lime_window_get_context);
	DEFINE_PRIME1 (lime_window_get_context_type);
	DEFINE_PRIME1 (lime_window_get_display);
	DEFINE_PRIME1 (lime_window_get_display_mode);
	DEFINE_PRIME1 (lime_window_get_height);
	DEFINE_PRIME1 (lime_window_get_id);
	DEFINE_PRIME1 (lime_window_get_mouse_lock);
	DEFINE_PRIME1 (lime_window_get_scale);
	DEFINE_PRIME1 (lime_window_get_text_input_enabled);
	DEFINE_PRIME1 (lime_window_get_width);
	DEFINE_PRIME1 (lime_window_get_x);
	DEFINE_PRIME1 (lime_window_get_y);
	DEFINE_PRIME3v (lime_window_move);
	DEFINE_PRIME3 (lime_window_read_pixels);
	DEFINE_PRIME3v (lime_window_resize);
	DEFINE_PRIME3v (lime_window_set_minimum_size);
	DEFINE_PRIME3v (lime_window_set_maximum_size);
	DEFINE_PRIME2 (lime_window_set_borderless);
	DEFINE_PRIME2v (lime_window_set_cursor);
	DEFINE_PRIME2 (lime_window_set_display_mode);
	DEFINE_PRIME2 (lime_window_set_fullscreen);
	DEFINE_PRIME2v (lime_window_set_icon);
	DEFINE_PRIME2 (lime_window_set_maximized);
	DEFINE_PRIME2 (lime_window_set_minimized);
	DEFINE_PRIME2v (lime_window_set_mouse_lock);
	DEFINE_PRIME2 (lime_window_set_resizable);
	DEFINE_PRIME2v (lime_window_set_text_input_enabled);
	DEFINE_PRIME2v (lime_window_set_text_input_rect);
	DEFINE_PRIME2 (lime_window_set_title);
	DEFINE_PRIME2 (lime_window_set_visible);
	DEFINE_PRIME3v (lime_window_warp_mouse);
	DEFINE_PRIME1 (lime_window_get_opacity);
	DEFINE_PRIME2v (lime_window_set_opacity);
	DEFINE_PRIME2 (lime_zlib_compress);
	DEFINE_PRIME2 (lime_zlib_decompress);


	#define _ENUM "?"
	// #define _TCFFIPOINTER _ABSTRACT (HL_CFFIPointer)
	#define _TAPPLICATION_EVENT _OBJ (_I32 _I32)
	#define _TBYTES _OBJ (_I32 _BYTES)
	#define _TCFFIPOINTER _DYN
	#define _TCLIPBOARD_EVENT _OBJ (_I32)
	#define _TDISPLAYMODE _OBJ (_I32 _I32 _I32 _I32)
	#define _TDROP_EVENT _OBJ (_BYTES _I32)
	#define _TGAMEPAD_EVENT _OBJ (_I32 _I32 _I32 _I32 _F64)
	#define _TJOYSTICK_EVENT _OBJ (_I32 _I32 _I32 _I32 _F64 _F64)
	#define _TKEY_EVENT _OBJ (_F64 _I32 _I32 _I32)
	#define _TMOUSE_EVENT _OBJ (_I32 _F64 _F64 _I32 _I32 _F64 _F64 _I32)
	#define _TORIENTATION_EVENT _OBJ (_I32 _I32 _I32)
	#define _TRECTANGLE _OBJ (_F64 _F64 _F64 _F64)
	#define _TRENDER_EVENT _OBJ (_I32)
	#define _TSENSOR_EVENT _OBJ (_I32 _F64 _F64 _F64 _I32)
	#define _TTEXT_EVENT _OBJ (_I32 _I32 _I32 _BYTES _I32 _I32)
	#define _TTOUCH_EVENT _OBJ (_I32 _F64 _F64 _I32 _F64 _I32 _F64 _F64)
	#define _TVECTOR2 _OBJ (_F64 _F64)
	#define _TVORBISFILE _OBJ (_I32 _DYN)
	#define _TWINDOW_EVENT _OBJ (_I32 _I32 _I32 _I32 _I32 _I32)

	#define _TARRAYBUFFER _TBYTES
	#define _TARRAYBUFFERVIEW _OBJ (_I32 _TARRAYBUFFER _I32 _I32 _I32 _I32)
	#define _TAUDIOBUFFER _OBJ (_I32 _I32 _TARRAYBUFFERVIEW _I32 _DYN _DYN _DYN _DYN _DYN _TVORBISFILE)
	#define _TIMAGEBUFFER _OBJ (_I32 _TARRAYBUFFERVIEW _I32 _I32 _BOOL _BOOL _I32 _DYN _DYN _DYN _DYN _DYN _DYN)
	#define _TIMAGE _OBJ (_TIMAGEBUFFER _BOOL _I32 _I32 _I32 _TRECTANGLE _ENUM _I32 _I32 _F64 _F64)

	#define _TARRAY _OBJ (_BYTES _I32)
	#define _TARRAY2 _OBJ (_ARR)


	DEFINE_HL_PRIM (_TCFFIPOINTER, hl_application_create, _NO_ARG);
	DEFINE_HL_PRIM (_VOID, hl_application_event_manager_register, _FUN(_VOID, _NO_ARG) _TAPPLICATION_EVENT);
	DEFINE_HL_PRIM (_I32, hl_application_exec, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_application_init, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_application_quit, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_application_set_frame_rate, _TCFFIPOINTER _F64);
	DEFINE_HL_PRIM (_BOOL, hl_application_update, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_TAUDIOBUFFER, hl_audio_load_bytes, _TBYTES _TAUDIOBUFFER);
	DEFINE_HL_PRIM (_TAUDIOBUFFER, hl_audio_load_file, _STRING _TAUDIOBUFFER);
	DEFINE_HL_PRIM (_TBYTES, hl_bytes_from_data_pointer, _F64 _I32 _TBYTES);
	DEFINE_HL_PRIM (_F64, hl_bytes_get_data_pointer, _TBYTES);
	DEFINE_HL_PRIM (_F64, hl_bytes_get_data_pointer_offset, _TBYTES _I32);
	DEFINE_HL_PRIM (_TBYTES, hl_bytes_read_file, _STRING _TBYTES);
	DEFINE_HL_PRIM (_F64, hl_cffi_get_native_pointer, _TCFFIPOINTER);
	// DEFINE_PRIME1 (lime_cffi_set_finalizer);
	DEFINE_HL_PRIM (_VOID, hl_clipboard_event_manager_register, _FUN(_VOID, _NO_ARG) _TCLIPBOARD_EVENT);
	DEFINE_HL_PRIM (_BYTES, hl_clipboard_get_text, _NO_ARG);
	DEFINE_HL_PRIM (_VOID, hl_clipboard_set_text, _STRING);
	DEFINE_HL_PRIM (_F64, hl_data_pointer_offset, _F64 _I32);
	DEFINE_HL_PRIM (_TBYTES, hl_deflate_compress, _TBYTES _TBYTES);
	DEFINE_HL_PRIM (_TBYTES, hl_deflate_decompress, _TBYTES _TBYTES);
	DEFINE_HL_PRIM (_VOID, hl_drop_event_manager_register, _FUN(_VOID, _NO_ARG) _TDROP_EVENT);
	DEFINE_HL_PRIM (_BYTES, hl_file_dialog_open_directory, _STRING _STRING _STRING);
	DEFINE_HL_PRIM (_BYTES, hl_file_dialog_open_file, _STRING _STRING _STRING);
	DEFINE_HL_PRIM (_ARR, hl_file_dialog_open_files, _STRING _STRING _STRING);
	DEFINE_HL_PRIM (_BYTES, hl_file_dialog_save_file, _STRING _STRING _STRING);
	DEFINE_HL_PRIM (_TCFFIPOINTER, hl_file_watcher_create, _DYN);
	DEFINE_HL_PRIM (_I32, hl_file_watcher_add_directory, _TCFFIPOINTER _STRING _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_file_watcher_remove_directory, _TCFFIPOINTER _I32);
	DEFINE_HL_PRIM (_VOID, hl_file_watcher_update, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_ascender, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_descender, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_BYTES, hl_font_get_family_name, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_glyph_index, _TCFFIPOINTER _STRING);
	DEFINE_HL_PRIM (_ARR, hl_font_get_glyph_indices, _TCFFIPOINTER _STRING);
	DEFINE_HL_PRIM (_DYN, hl_font_get_glyph_metrics, _TCFFIPOINTER _I32);
	DEFINE_HL_PRIM (_I32, hl_font_get_height, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_num_glyphs, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_underline_position, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_underline_thickness, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_strikethrough_position, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_strikethrough_thickness, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_font_get_units_per_em, _TCFFIPOINTER);
	// DEFINE_PRIME1 (lime_font_load);
	DEFINE_HL_PRIM (_TCFFIPOINTER, hl_font_load_bytes, _TBYTES);
	DEFINE_HL_PRIM (_TCFFIPOINTER, hl_font_load_file, _STRING);
	DEFINE_HL_PRIM (_DYN, hl_font_outline_decompose, _TCFFIPOINTER _I32);
	DEFINE_HL_PRIM (_TBYTES, hl_font_render_glyph, _TCFFIPOINTER _I32 _TBYTES);
	DEFINE_HL_PRIM (_TBYTES, hl_font_render_glyphs, _TCFFIPOINTER _ARR _TBYTES);
	DEFINE_HL_PRIM (_VOID, hl_font_set_size, _TCFFIPOINTER _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_gamepad_add_mappings, _ARR);
	DEFINE_HL_PRIM (_VOID, hl_gamepad_event_manager_register, _FUN(_VOID, _NO_ARG) _TGAMEPAD_EVENT);
	DEFINE_HL_PRIM (_BYTES, hl_gamepad_get_device_guid, _I32);
	DEFINE_HL_PRIM (_BYTES, hl_gamepad_get_device_name, _I32);
	DEFINE_HL_PRIM (_VOID, hl_gamepad_rumble, _I32 _F64 _F64 _I32);
	DEFINE_HL_PRIM (_TBYTES, hl_gzip_compress, _TBYTES _TBYTES);
	DEFINE_HL_PRIM (_TBYTES, hl_gzip_decompress, _TBYTES _TBYTES);
	DEFINE_HL_PRIM (_VOID, hl_haptic_vibrate, _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_color_transform, _TIMAGE _TRECTANGLE _TARRAYBUFFERVIEW);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_copy_channel, _TIMAGE _TIMAGE _TRECTANGLE _TVECTOR2 _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_copy_pixels, _TIMAGE _TIMAGE _TRECTANGLE _TVECTOR2 _TIMAGE _TVECTOR2 _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_fill_rect, _TIMAGE _TRECTANGLE _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_flood_fill, _TIMAGE _I32 _I32 _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_get_pixels, _TIMAGE _TRECTANGLE _I32 _TBYTES);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_merge, _TIMAGE _TIMAGE _TRECTANGLE _TVECTOR2 _I32 _I32 _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_multiply_alpha, _TIMAGE);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_resize, _TIMAGE _TIMAGEBUFFER _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_set_format, _TIMAGE _I32);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_set_pixels, _TIMAGE _TRECTANGLE _TBYTES _I32 _I32 _I32);
	DEFINE_HL_PRIM (_I32, hl_image_data_util_threshold, _TIMAGE _TIMAGE _TRECTANGLE _TVECTOR2 _I32 _I32 _I32 _I32 _I32 _I32 _I32 _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_image_data_util_unmultiply_alpha, _TIMAGE);
	DEFINE_HL_PRIM (_TBYTES, hl_image_encode, _TIMAGEBUFFER _I32 _I32 _TBYTES);
	// DEFINE_PRIME2 (lime_image_load);
	DEFINE_HL_PRIM (_TIMAGEBUFFER, hl_image_load_bytes, _TBYTES _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_TIMAGEBUFFER, hl_image_load_file, _STRING _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_F64, hl_jni_getenv, _NO_ARG);
	DEFINE_HL_PRIM (_VOID, hl_joystick_event_manager_register, _FUN(_VOID, _NO_ARG) _TJOYSTICK_EVENT);
	DEFINE_HL_PRIM (_BYTES, hl_joystick_get_device_guid, _I32);
	DEFINE_HL_PRIM (_BYTES, hl_joystick_get_device_name, _I32);
	DEFINE_HL_PRIM (_I32, hl_joystick_get_num_axes, _I32);
	DEFINE_HL_PRIM (_I32, hl_joystick_get_num_buttons, _I32);
	DEFINE_HL_PRIM (_I32, hl_joystick_get_num_hats, _I32);
	DEFINE_HL_PRIM (_TIMAGEBUFFER, hl_jpeg_decode_bytes, _TBYTES _BOOL _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_TIMAGEBUFFER, hl_jpeg_decode_file, _STRING _BOOL _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_I32, hl_key_code_from_scan_code, _I32);
	DEFINE_HL_PRIM (_I32, hl_key_code_to_scan_code, _I32);
	DEFINE_HL_PRIM (_VOID, hl_key_event_manager_register, _FUN (_VOID, _NO_ARG) _TKEY_EVENT);
	DEFINE_HL_PRIM (_BYTES, hl_locale_get_system_locale, _NO_ARG);
	DEFINE_HL_PRIM (_TBYTES, hl_lzma_compress, _TBYTES _TBYTES);
	DEFINE_HL_PRIM (_TBYTES, hl_lzma_decompress, _TBYTES _TBYTES);
	DEFINE_HL_PRIM (_VOID, hl_mouse_event_manager_register, _FUN (_VOID, _NO_ARG) _TMOUSE_EVENT);
	// DEFINE_PRIME1v (lime_neko_execute);
	DEFINE_HL_PRIM (_VOID, hl_orientation_event_manager_register, _FUN (_VOID, _NO_ARG) _TORIENTATION_EVENT);
	DEFINE_HL_PRIM (_TIMAGEBUFFER, hl_png_decode_bytes, _TBYTES _BOOL _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_TIMAGEBUFFER, hl_png_decode_file, _STRING _BOOL _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_VOID, hl_render_event_manager_register, _FUN (_VOID, _NO_ARG) _TRENDER_EVENT);
	DEFINE_HL_PRIM (_VOID, hl_sensor_event_manager_register, _FUN (_VOID, _NO_ARG) _TSENSOR_EVENT);
	DEFINE_HL_PRIM (_BOOL, hl_system_get_allow_screen_timeout, _NO_ARG);
	DEFINE_HL_PRIM (_BYTES, hl_system_get_device_model, _NO_ARG);
	DEFINE_HL_PRIM (_BYTES, hl_system_get_device_vendor, _NO_ARG);
	DEFINE_HL_PRIM (_BYTES, hl_system_get_directory, _I32 _STRING _STRING);
	DEFINE_HL_PRIM (_DYN, hl_system_get_display, _I32);
	DEFINE_HL_PRIM (_BOOL, hl_system_get_ios_tablet, _NO_ARG);
	DEFINE_HL_PRIM (_I32, hl_system_get_num_displays, _NO_ARG);
	DEFINE_HL_PRIM (_I32, hl_system_get_device_orientation, _NO_ARG);
	DEFINE_HL_PRIM (_BYTES, hl_system_get_platform_label, _NO_ARG);
	DEFINE_HL_PRIM (_BYTES, hl_system_get_platform_name, _NO_ARG);
	DEFINE_HL_PRIM (_BYTES, hl_system_get_platform_version, _NO_ARG);
	DEFINE_HL_PRIM (_F64, hl_system_get_timer, _NO_ARG);
	DEFINE_HL_PRIM (_I32, hl_system_get_windows_console_mode, _I32);
	DEFINE_HL_PRIM (_VOID, hl_system_open_file, _STRING);
	DEFINE_HL_PRIM (_VOID, hl_system_open_url, _STRING _STRING);
	DEFINE_HL_PRIM (_BOOL, hl_system_set_allow_screen_timeout, _BOOL);
	DEFINE_HL_PRIM (_BOOL, hl_system_set_windows_console_mode, _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_text_event_manager_register, _FUN (_VOID, _NO_ARG) _TTEXT_EVENT);
	DEFINE_HL_PRIM (_VOID, hl_touch_event_manager_register, _FUN (_VOID, _NO_ARG) _TTOUCH_EVENT);
	DEFINE_HL_PRIM (_VOID, hl_window_alert, _TCFFIPOINTER _STRING _STRING);
	DEFINE_HL_PRIM (_VOID, hl_window_close, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_window_context_flip, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_DYN, hl_window_context_lock, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_window_context_make_current, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_window_context_unlock, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_TCFFIPOINTER, hl_window_create, _TCFFIPOINTER _I32 _I32 _I32 _STRING);
	DEFINE_HL_PRIM (_VOID, hl_window_event_manager_register, _FUN (_VOID, _NO_ARG) _TWINDOW_EVENT);
	DEFINE_HL_PRIM (_VOID, hl_window_focus, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_F64, hl_window_get_context, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_BYTES, hl_window_get_context_type, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_window_get_display, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_window_get_display_mode, _TCFFIPOINTER _TDISPLAYMODE);
	DEFINE_HL_PRIM (_I32, hl_window_get_height, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_window_get_id, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_BOOL, hl_window_get_mouse_lock, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_F64, hl_window_get_scale, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_BOOL, hl_window_get_text_input_enabled, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_window_get_width, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_window_get_x, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_I32, hl_window_get_y, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_window_move, _TCFFIPOINTER _I32 _I32);
	DEFINE_HL_PRIM (_DYN, hl_window_read_pixels, _TCFFIPOINTER _TRECTANGLE _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_VOID, hl_window_resize, _TCFFIPOINTER _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_window_set_minimum_size, _TCFFIPOINTER _I32 _I32);
	DEFINE_HL_PRIM (_VOID, hl_window_set_maximum_size, _TCFFIPOINTER _I32 _I32);
	DEFINE_HL_PRIM (_BOOL, hl_window_set_borderless, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_window_set_cursor, _TCFFIPOINTER _I32);
	DEFINE_HL_PRIM (_VOID, hl_window_set_display_mode, _TCFFIPOINTER _TDISPLAYMODE _TDISPLAYMODE);
	DEFINE_HL_PRIM (_BOOL, hl_window_set_fullscreen, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_window_set_icon, _TCFFIPOINTER _TIMAGEBUFFER);
	DEFINE_HL_PRIM (_BOOL, hl_window_set_maximized, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_BOOL, hl_window_set_minimized, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_window_set_mouse_lock, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_BOOL, hl_window_set_resizable, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_window_set_text_input_enabled, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_window_set_text_input_rect, _TCFFIPOINTER _TRECTANGLE);
	DEFINE_HL_PRIM (_STRING, hl_window_set_title, _TCFFIPOINTER _STRING);
	DEFINE_HL_PRIM (_BOOL, hl_window_set_visible, _TCFFIPOINTER _BOOL);
	DEFINE_HL_PRIM (_VOID, hl_window_warp_mouse, _TCFFIPOINTER _I32 _I32);
	DEFINE_HL_PRIM (_F64, hl_window_get_opacity, _TCFFIPOINTER);
	DEFINE_HL_PRIM (_VOID, hl_window_set_opacity, _TCFFIPOINTER _F64);
	DEFINE_HL_PRIM (_TBYTES, hl_zlib_compress, _TBYTES _TBYTES);
	DEFINE_HL_PRIM (_TBYTES, hl_zlib_decompress, _TBYTES _TBYTES);


}


#ifdef LIME_CAIRO
extern "C" int lime_cairo_register_prims ();
#else
extern "C" int lime_cairo_register_prims () { return 0; }
#endif

#ifdef LIME_CURL
extern "C" int lime_curl_register_prims ();
#else
extern "C" int lime_curl_register_prims () { return 0; }
#endif

#ifdef LIME_HARFBUZZ
extern "C" int lime_harfbuzz_register_prims ();
#else
extern "C" int lime_harfbuzz_register_prims () { return 0; }
#endif

#ifdef LIME_OPENAL
extern "C" int lime_openal_register_prims ();
#else
extern "C" int lime_openal_register_prims () { return 0; }
#endif

#ifdef LIME_OPENGL
extern "C" int lime_opengl_register_prims ();
#else
extern "C" int lime_opengl_register_prims () { return 0; }
#endif

#ifdef LIME_VORBIS
extern "C" int lime_vorbis_register_prims ();
#else
extern "C" int lime_vorbis_register_prims () { return 0; }
#endif


extern "C" int lime_register_prims () {

	lime_cairo_register_prims ();
	lime_curl_register_prims ();
	lime_harfbuzz_register_prims ();
	lime_openal_register_prims ();
	lime_opengl_register_prims ();
	lime_vorbis_register_prims ();

	return 0;

}