First commit

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ConsoleRenderContext.js

@@ -0,0 +1,83 @@
+// Class: lime.graphics.ConsoleRenderContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_graphics_console_IndexBuffer() {return require("./../../lime/graphics/console/IndexBuffer");}
+function lime_graphics_console_VertexBuffer() {return require("./../../lime/graphics/console/VertexBuffer");}
+function lime_graphics_console_Shader() {return require("./../../lime/graphics/console/Shader");}
+
+// Constructor
+
+var ConsoleRenderContext = function() {
+}
+
+// Meta
+
+ConsoleRenderContext.__name__ = ["lime","graphics","ConsoleRenderContext"];
+ConsoleRenderContext.prototype = {
+	createIndexBuffer: function(indices,count) {
+		return new (lime_graphics_console_IndexBuffer().default)();
+	},
+	createVertexBuffer: function(decl,count) {
+		return new (lime_graphics_console_VertexBuffer().default)();
+	},
+	lookupShader: function(name) {
+		return new (lime_graphics_console_Shader().default)();
+	},
+	clear: function(r,g,b,a,depth,stencil) {
+		if(stencil == null) {
+			stencil = 0;
+		}
+		if(depth == null) {
+			depth = 1.0;
+		}
+	},
+	bindShader: function(shader) {
+	},
+	setViewport: function(x,y,width,height,nearPlane,farPlane) {
+		if(farPlane == null) {
+			farPlane = 1.0;
+		}
+		if(nearPlane == null) {
+			nearPlane = 0.0;
+		}
+	},
+	setVertexShaderConstantF: function(startRegister,vec4,vec4count) {
+	},
+	setVertexSource: function(vb) {
+	},
+	setIndexSource: function(ib) {
+	},
+	draw: function(primitive,startVertex,primitiveCount) {
+	},
+	drawIndexed: function(primitive,vertexCount,startIndex,primitiveCount) {
+	},
+	get_width: function() {
+		return 0;
+	},
+	get_height: function() {
+		return 0;
+	}
+};
+ConsoleRenderContext.prototype.__class__ = $hxClasses["lime.graphics.ConsoleRenderContext"] = ConsoleRenderContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ConsoleRenderContext;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/FlashRenderContext.js

@@ -0,0 +1,154 @@
+// Class: lime.graphics.FlashRenderContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Constructor
+
+var FlashRenderContext = function() {
+}
+
+// Meta
+
+FlashRenderContext.__name__ = ["lime","graphics","FlashRenderContext"];
+FlashRenderContext.prototype = {
+	addChild: function(child) {
+		return null;
+	},
+	addChildAt: function(child,index) {
+		return null;
+	},
+	addEventListener: function(type,listener,useCapture,priority,useWeakReference) {
+		if(useWeakReference == null) {
+			useWeakReference = false;
+		}
+		if(priority == null) {
+			priority = 0;
+		}
+		if(useCapture == null) {
+			useCapture = false;
+		}
+	},
+	areInaccessibleObjectsUnderPoint: function(point) {
+		return false;
+	},
+	contains: function(child) {
+		return false;
+	},
+	dispatchEvent: function(event) {
+		return false;
+	},
+	getBounds: function(targetCoordinateSpace) {
+		return null;
+	},
+	getChildAt: function(index) {
+		return null;
+	},
+	getChildByName: function(name) {
+		return null;
+	},
+	getChildIndex: function(child) {
+		return 0;
+	},
+	getObjectsUnderPoint: function(point) {
+		return null;
+	},
+	getRect: function(targetCoordinateSpace) {
+		return null;
+	},
+	globalToLocal: function(point) {
+		return null;
+	},
+	globalToLocal3D: function(point) {
+		return null;
+	},
+	hasEventListener: function(type) {
+		return false;
+	},
+	hitTestObject: function(obj) {
+		return false;
+	},
+	hitTestPoint: function(x,y,shapeFlag) {
+		if(shapeFlag == null) {
+			shapeFlag = false;
+		}
+		return false;
+	},
+	local3DToGlobal: function(point3d) {
+		return null;
+	},
+	localToGlobal: function(point) {
+		return null;
+	},
+	removeChild: function(child) {
+		return null;
+	},
+	removeChildAt: function(index) {
+		return null;
+	},
+	removeChildren: function(beginIndex,endIndex) {
+		if(endIndex == null) {
+			endIndex = 2147483647;
+		}
+		if(beginIndex == null) {
+			beginIndex = 0;
+		}
+	},
+	removeEventListener: function(type,listener,useCapture) {
+		if(useCapture == null) {
+			useCapture = false;
+		}
+	},
+	requestSoftKeyboard: function() {
+		return false;
+	},
+	setChildIndex: function(child,index) {
+	},
+	startDrag: function(lockCenter,bounds) {
+		if(lockCenter == null) {
+			lockCenter = false;
+		}
+	},
+	startTouchDrag: function(touchPointID,lockCenter,bounds) {
+		if(lockCenter == null) {
+			lockCenter = false;
+		}
+	},
+	stopAllMovieClips: function() {
+	},
+	stopDrag: function() {
+	},
+	stopTouchDrag: function(touchPointID) {
+	},
+	swapChildren: function(child1,child2) {
+	},
+	swapChildrenAt: function(index1,index2) {
+	},
+	toString: function() {
+		return null;
+	},
+	willTrigger: function(type) {
+		return false;
+	}
+};
+FlashRenderContext.prototype.__class__ = $hxClasses["lime.graphics.FlashRenderContext"] = FlashRenderContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = FlashRenderContext;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ImageBuffer.js

@@ -0,0 +1,119 @@
+// Class: lime.graphics.ImageBuffer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function js_Browser() {return require("./../../js/Browser");}
+function Std() {return require("./../../Std");}
+
+// Constructor
+
+var ImageBuffer = function(data,width,height,bitsPerPixel,format) {
+	if(bitsPerPixel == null) {
+		bitsPerPixel = 32;
+	}
+	if(height == null) {
+		height = 0;
+	}
+	if(width == null) {
+		width = 0;
+	}
+	this.data = data;
+	this.width = width;
+	this.height = height;
+	this.bitsPerPixel = bitsPerPixel;
+	this.format = format == null ? 0 : format;
+	this.premultiplied = false;
+	this.transparent = true;
+}
+
+// Meta
+
+ImageBuffer.__name__ = ["lime","graphics","ImageBuffer"];
+ImageBuffer.prototype = {
+	clone: function() {
+		var buffer = new ImageBuffer(this.data,this.width,this.height,this.bitsPerPixel);
+		if(this.data != null) {
+			var elements = this.data.byteLength;
+			var this1;
+			if(elements != null) {
+				this1 = new Uint8Array(elements);
+			} else {
+				this1 = null;
+			}
+			buffer.data = this1;
+			var view = this.data;
+			var this2;
+			if(view != null) {
+				this2 = new Uint8Array(view);
+			} else {
+				this2 = null;
+			}
+			var copy = this2;
+			buffer.data.set(copy);
+		} else if(this.__srcImageData != null) {
+			buffer.__srcCanvas = (js_Browser().default).get_document().createElement("canvas");
+			buffer.__srcContext = buffer.__srcCanvas.getContext("2d");
+			buffer.__srcCanvas.width = this.__srcImageData.width;
+			buffer.__srcCanvas.height = this.__srcImageData.height;
+			buffer.__srcImageData = buffer.__srcContext.createImageData(this.__srcImageData.width,this.__srcImageData.height);
+			var copy1 = new Uint8ClampedArray(this.__srcImageData.data);
+			buffer.__srcImageData.data.set(copy1);
+		} else if(this.__srcCanvas != null) {
+			buffer.__srcCanvas = (js_Browser().default).get_document().createElement("canvas");
+			buffer.__srcContext = buffer.__srcCanvas.getContext("2d");
+			buffer.__srcCanvas.width = this.__srcCanvas.width;
+			buffer.__srcCanvas.height = this.__srcCanvas.height;
+			buffer.__srcContext.drawImage(this.__srcCanvas,0,0);
+		} else {
+			buffer.__srcImage = this.__srcImage;
+		}
+		buffer.bitsPerPixel = this.bitsPerPixel;
+		buffer.format = this.format;
+		buffer.premultiplied = this.premultiplied;
+		buffer.transparent = this.transparent;
+		return buffer;
+	},
+	get_src: function() {
+		if(this.__srcImage != null) {
+			return this.__srcImage;
+		}
+		return this.__srcCanvas;
+	},
+	set_src: function(value) {
+		if((Std().default)["is"](value,Image)) {
+			this.__srcImage = value;
+		} else if((Std().default)["is"](value,HTMLCanvasElement)) {
+			this.__srcCanvas = value;
+			this.__srcContext = this.__srcCanvas.getContext("2d");
+		}
+		return value;
+	},
+	get_stride: function() {
+		return this.width * 4;
+	}
+};
+ImageBuffer.prototype.__class__ = $hxClasses["lime.graphics.ImageBuffer"] = ImageBuffer;
+
+// Init
+
+{
+	var p = ImageBuffer.prototype;
+	Object.defineProperties(p,{ "src" : { get : p.get_src, set : p.set_src}, "stride" : { get : p.get_stride}});
+};
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ImageBuffer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ImageChannel.js

@@ -0,0 +1,33 @@
+// Enum: lime.graphics.ImageChannel
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var ImageChannel = $hxClasses["lime.graphics.ImageChannel"] = { __ename__: ["lime","graphics","ImageChannel"], __constructs__: ["RED","GREEN","BLUE","ALPHA"] }
+
+ImageChannel.BLUE = ["BLUE",2];
+ImageChannel.BLUE.toString = $estr;
+ImageChannel.BLUE.__enum__ = ImageChannel;
+
+ImageChannel.GREEN = ["GREEN",1];
+ImageChannel.GREEN.toString = $estr;
+ImageChannel.GREEN.__enum__ = ImageChannel;
+
+ImageChannel.RED = ["RED",0];
+ImageChannel.RED.toString = $estr;
+ImageChannel.RED.__enum__ = ImageChannel;
+
+ImageChannel.ALPHA = ["ALPHA",3];
+ImageChannel.ALPHA.toString = $estr;
+ImageChannel.ALPHA.__enum__ = ImageChannel;
+
+
+exports.default = ImageChannel;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ImageType.js

@@ -0,0 +1,33 @@
+// Enum: lime.graphics.ImageType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var ImageType = $hxClasses["lime.graphics.ImageType"] = { __ename__: ["lime","graphics","ImageType"], __constructs__: ["CANVAS","DATA","FLASH","CUSTOM"] }
+
+ImageType.CANVAS = ["CANVAS",0];
+ImageType.CANVAS.toString = $estr;
+ImageType.CANVAS.__enum__ = ImageType;
+
+ImageType.FLASH = ["FLASH",2];
+ImageType.FLASH.toString = $estr;
+ImageType.FLASH.__enum__ = ImageType;
+
+ImageType.DATA = ["DATA",1];
+ImageType.DATA.toString = $estr;
+ImageType.DATA.__enum__ = ImageType;
+
+ImageType.CUSTOM = ["CUSTOM",3];
+ImageType.CUSTOM.toString = $estr;
+ImageType.CUSTOM.__enum__ = ImageType;
+
+
+exports.default = ImageType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/RenderContext.js

@@ -0,0 +1,28 @@
+// Enum: lime.graphics.RenderContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var RenderContext = $hxClasses["lime.graphics.RenderContext"] = { __ename__: ["lime","graphics","RenderContext"], __constructs__: ["OPENGL","CANVAS","DOM","FLASH","CAIRO","CONSOLE","CUSTOM","NONE"] }
+
+RenderContext.OPENGL = function(gl) { var $x = ["OPENGL",0,gl]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CANVAS = function(context) { var $x = ["CANVAS",1,context]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.DOM = function(element) { var $x = ["DOM",2,element]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.NONE = ["NONE",7];
+RenderContext.NONE.toString = $estr;
+RenderContext.NONE.__enum__ = RenderContext;
+
+RenderContext.FLASH = function(stage) { var $x = ["FLASH",3,stage]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CONSOLE = function(context) { var $x = ["CONSOLE",5,context]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CAIRO = function(cairo) { var $x = ["CAIRO",4,cairo]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CUSTOM = function(data) { var $x = ["CUSTOM",6,data]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+
+exports.default = RenderContext;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/Renderer.js

@@ -0,0 +1,58 @@
+// Class: lime.graphics.Renderer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_app__$Event_$Void_$Void() {return require("./../../lime/app/_Event_Void_Void");}
+function lime_app__$Event_$lime_$graphics_$RenderContext_$Void() {return require("./../../lime/app/_Event_lime_graphics_RenderContext_Void");}
+function lime__$backend_html5_HTML5Renderer() {return require("./../../lime/_backend/html5/HTML5Renderer");}
+
+// Constructor
+
+var Renderer = function(window) {
+	this.onRender = new (lime_app__$Event_$Void_$Void().default)();
+	this.onContextRestored = new (lime_app__$Event_$lime_$graphics_$RenderContext_$Void().default)();
+	this.onContextLost = new (lime_app__$Event_$Void_$Void().default)();
+	this.window = window;
+	this.backend = new (lime__$backend_html5_HTML5Renderer().default)(this);
+	this.window.renderer = this;
+}
+
+// Meta
+
+Renderer.__name__ = ["lime","graphics","Renderer"];
+Renderer.prototype = {
+	create: function() {
+		this.backend.create();
+	},
+	flip: function() {
+		this.backend.flip();
+	},
+	readPixels: function(rect) {
+		return this.backend.readPixels(rect);
+	},
+	render: function() {
+		this.backend.render();
+	}
+};
+Renderer.prototype.__class__ = $hxClasses["lime.graphics.Renderer"] = Renderer;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Renderer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/RendererType.js

@@ -0,0 +1,45 @@
+// Enum: lime.graphics.RendererType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var RendererType = $hxClasses["lime.graphics.RendererType"] = { __ename__: ["lime","graphics","RendererType"], __constructs__: ["OPENGL","CANVAS","DOM","FLASH","CAIRO","CONSOLE","CUSTOM"] }
+
+RendererType.OPENGL = ["OPENGL",0];
+RendererType.OPENGL.toString = $estr;
+RendererType.OPENGL.__enum__ = RendererType;
+
+RendererType.CANVAS = ["CANVAS",1];
+RendererType.CANVAS.toString = $estr;
+RendererType.CANVAS.__enum__ = RendererType;
+
+RendererType.DOM = ["DOM",2];
+RendererType.DOM.toString = $estr;
+RendererType.DOM.__enum__ = RendererType;
+
+RendererType.FLASH = ["FLASH",3];
+RendererType.FLASH.toString = $estr;
+RendererType.FLASH.__enum__ = RendererType;
+
+RendererType.CONSOLE = ["CONSOLE",5];
+RendererType.CONSOLE.toString = $estr;
+RendererType.CONSOLE.__enum__ = RendererType;
+
+RendererType.CAIRO = ["CAIRO",4];
+RendererType.CAIRO.toString = $estr;
+RendererType.CAIRO.__enum__ = RendererType;
+
+RendererType.CUSTOM = ["CUSTOM",6];
+RendererType.CUSTOM.toString = $estr;
+RendererType.CUSTOM.__enum__ = RendererType;
+
+
+exports.default = RendererType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/Cairo.js

@@ -0,0 +1,240 @@
+// Class: lime.graphics.cairo.Cairo
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var Cairo = function(surface) {
+	var tmp = surface != null;
+}
+
+// Meta
+
+Cairo.__name__ = ["lime","graphics","cairo","Cairo"];
+Cairo.prototype = {
+	arc: function(xc,yc,radius,angle1,angle2) {
+	},
+	arcNegative: function(xc,yc,radius,angle1,angle2) {
+	},
+	clip: function() {
+	},
+	clipExtents: function(x1,y1,x2,y2) {
+	},
+	clipPreserve: function() {
+	},
+	closePath: function() {
+	},
+	copyPage: function() {
+	},
+	curveTo: function(x1,y1,x2,y2,x3,y3) {
+	},
+	fill: function() {
+	},
+	fillExtents: function(x1,y1,x2,y2) {
+	},
+	fillPreserve: function() {
+	},
+	identityMatrix: function() {
+	},
+	inClip: function(x,y) {
+		return false;
+	},
+	inFill: function(x,y) {
+		return false;
+	},
+	inStroke: function(x,y) {
+		return false;
+	},
+	lineTo: function(x,y) {
+	},
+	moveTo: function(x,y) {
+	},
+	mask: function(pattern) {
+	},
+	maskSurface: function(surface,x,y) {
+	},
+	newPath: function() {
+	},
+	paint: function() {
+	},
+	paintWithAlpha: function(alpha) {
+	},
+	popGroup: function() {
+		return null;
+	},
+	popGroupToSource: function() {
+	},
+	pushGroup: function() {
+	},
+	pushGroupWithContent: function(content) {
+	},
+	recreate: function(surface) {
+	},
+	rectangle: function(x,y,width,height) {
+	},
+	relCurveTo: function(dx1,dy1,dx2,dy2,dx3,dy3) {
+	},
+	relLineTo: function(dx,dy) {
+	},
+	relMoveTo: function(dx,dy) {
+	},
+	resetClip: function() {
+	},
+	restore: function() {
+	},
+	save: function() {
+	},
+	setFontSize: function(size) {
+	},
+	setSourceRGB: function(r,g,b) {
+	},
+	setSourceRGBA: function(r,g,b,a) {
+	},
+	setSourceSurface: function(surface,x,y) {
+	},
+	showGlyphs: function(glyphs) {
+	},
+	showPage: function() {
+	},
+	showText: function(utf8) {
+	},
+	status: function() {
+		return 0;
+	},
+	stroke: function() {
+	},
+	strokeExtents: function(x1,y1,x2,y2) {
+	},
+	strokePreserve: function() {
+	},
+	textPath: function(utf8) {
+	},
+	transform: function(matrix) {
+	},
+	rotate: function(amount) {
+	},
+	scale: function(x,y) {
+	},
+	translate: function(x,y) {
+	},
+	get_antialias: function() {
+		return 0;
+	},
+	set_antialias: function(value) {
+		return value;
+	},
+	get_currentPoint: function() {
+		return null;
+	},
+	get_dash: function() {
+		return [];
+	},
+	set_dash: function(value) {
+		return value;
+	},
+	get_dashCount: function() {
+		return 0;
+	},
+	get_fillRule: function() {
+		return 0;
+	},
+	set_fillRule: function(value) {
+		return value;
+	},
+	get_fontFace: function() {
+		return 0;
+	},
+	set_fontFace: function(value) {
+		return value;
+	},
+	get_fontOptions: function() {
+		return null;
+	},
+	set_fontOptions: function(value) {
+		return value;
+	},
+	get_groupTarget: function() {
+		return 0;
+	},
+	get_hasCurrentPoint: function() {
+		return false;
+	},
+	get_lineCap: function() {
+		return 0;
+	},
+	set_lineCap: function(value) {
+		return value;
+	},
+	get_lineJoin: function() {
+		return 0;
+	},
+	set_lineJoin: function(value) {
+		return value;
+	},
+	get_lineWidth: function() {
+		return 0;
+	},
+	set_lineWidth: function(value) {
+		return value;
+	},
+	get_matrix: function() {
+		return null;
+	},
+	set_matrix: function(value) {
+		return value;
+	},
+	get_miterLimit: function() {
+		return 0;
+	},
+	set_miterLimit: function(value) {
+		return value;
+	},
+	get_operator: function() {
+		return 0;
+	},
+	set_operator: function(value) {
+		return value;
+	},
+	get_source: function() {
+		return 0;
+	},
+	set_source: function(value) {
+		return value;
+	},
+	get_target: function() {
+		return 0;
+	},
+	get_tolerance: function() {
+		return 0;
+	},
+	set_tolerance: function(value) {
+		return value;
+	}
+};
+Cairo.prototype.__class__ = $hxClasses["lime.graphics.cairo.Cairo"] = Cairo;
+
+// Init
+
+
+
+// Statics
+
+Cairo.get_version = function() {
+	return 0;
+}
+Cairo.get_versionString = function() {
+	return "";
+}
+
+
+// Export
+
+exports.default = Cairo;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/CairoGlyph.js

@@ -0,0 +1,46 @@
+// Class: lime.graphics.cairo.CairoGlyph
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var CairoGlyph = function(index,x,y) {
+	if(y == null) {
+		y = 0;
+	}
+	if(x == null) {
+		x = 0;
+	}
+	this.index = index;
+	this.x = x;
+	this.y = y;
+}
+
+// Meta
+
+CairoGlyph.__name__ = ["lime","graphics","cairo","CairoGlyph"];
+CairoGlyph.prototype = {
+	
+};
+CairoGlyph.prototype.__class__ = $hxClasses["lime.graphics.cairo.CairoGlyph"] = CairoGlyph;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = CairoGlyph;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoFTFontFace/CairoFTFontFace_Impl_.js

@@ -0,0 +1,42 @@
+// Class: lime.graphics.cairo._CairoFTFontFace.CairoFTFontFace_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+
+// Constructor
+
+var CairoFTFontFace_Impl_ = function(){}
+
+// Meta
+
+CairoFTFontFace_Impl_.__name__ = ["lime","graphics","cairo","_CairoFTFontFace","CairoFTFontFace_Impl_"];
+CairoFTFontFace_Impl_.prototype = {
+	
+};
+CairoFTFontFace_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoFTFontFace.CairoFTFontFace_Impl_"] = CairoFTFontFace_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoFTFontFace_Impl_._new = function() {
+	var this1 = 0;
+	return this1;
+}
+CairoFTFontFace_Impl_.create = function(face,loadFlags) {
+	return 0;
+}
+CairoFTFontFace_Impl_.FT_LOAD_FORCE_AUTOHINT = 32
+
+// Export
+
+exports.default = CairoFTFontFace_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoFontFace/CairoFontFace_Impl_.js

@@ -0,0 +1,42 @@
+// Class: lime.graphics.cairo._CairoFontFace.CairoFontFace_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+
+// Constructor
+
+var CairoFontFace_Impl_ = function(){}
+
+// Meta
+
+CairoFontFace_Impl_.__name__ = ["lime","graphics","cairo","_CairoFontFace","CairoFontFace_Impl_"];
+CairoFontFace_Impl_.prototype = {
+	
+};
+CairoFontFace_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoFontFace.CairoFontFace_Impl_"] = CairoFontFace_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoFontFace_Impl_._new = function() {
+	var this1 = null;
+	return this1;
+}
+CairoFontFace_Impl_.status = function(this1) {
+	return 0;
+}
+
+
+// Export
+
+exports.default = CairoFontFace_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoFontOptions/CairoFontOptions_Impl_.js

@@ -0,0 +1,63 @@
+// Class: lime.graphics.cairo._CairoFontOptions.CairoFontOptions_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+
+// Constructor
+
+var CairoFontOptions_Impl_ = function(){}
+
+// Meta
+
+CairoFontOptions_Impl_.__name__ = ["lime","graphics","cairo","_CairoFontOptions","CairoFontOptions_Impl_"];
+CairoFontOptions_Impl_.prototype = {
+	
+};
+CairoFontOptions_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoFontOptions.CairoFontOptions_Impl_"] = CairoFontOptions_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoFontOptions_Impl_._new = function() {
+	var this1 = null;
+	return this1;
+}
+CairoFontOptions_Impl_.get_antialias = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_antialias = function(this1,value) {
+	return value;
+}
+CairoFontOptions_Impl_.get_hintMetrics = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_hintMetrics = function(this1,value) {
+	return value;
+}
+CairoFontOptions_Impl_.get_hintStyle = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_hintStyle = function(this1,value) {
+	return value;
+}
+CairoFontOptions_Impl_.get_subpixelOrder = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_subpixelOrder = function(this1,value) {
+	return value;
+}
+
+
+// Export
+
+exports.default = CairoFontOptions_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoImageSurface/CairoImageSurface_Impl_.js

@@ -0,0 +1,62 @@
+// Class: lime.graphics.cairo._CairoImageSurface.CairoImageSurface_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+var $import = require("./../../../../import_stub").default;
+function lime_utils__$DataPointer_DataPointer_$Impl_$() {return require("./../../../../lime/utils/_DataPointer/DataPointer_Impl_");}
+
+// Constructor
+
+var CairoImageSurface_Impl_ = function(){}
+
+// Meta
+
+CairoImageSurface_Impl_.__name__ = ["lime","graphics","cairo","_CairoImageSurface","CairoImageSurface_Impl_"];
+CairoImageSurface_Impl_.prototype = {
+	
+};
+CairoImageSurface_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoImageSurface.CairoImageSurface_Impl_"] = CairoImageSurface_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoImageSurface_Impl_._new = function(format,width,height) {
+	var this1 = 0;
+	return this1;
+}
+CairoImageSurface_Impl_.create = function(data,format,width,height,stride) {
+	return 0;
+}
+CairoImageSurface_Impl_.fromImage = function(image) {
+	return null;
+}
+CairoImageSurface_Impl_.get_data = function(this1) {
+	return (lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt(0);
+}
+CairoImageSurface_Impl_.get_format = function(this1) {
+	return 0;
+}
+CairoImageSurface_Impl_.get_height = function(this1) {
+	return 0;
+}
+CairoImageSurface_Impl_.get_stride = function(this1) {
+	return 0;
+}
+CairoImageSurface_Impl_.get_width = function(this1) {
+	return 0;
+}
+
+
+// Export
+
+exports.default = CairoImageSurface_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoPattern/CairoPattern_Impl_.js

@@ -0,0 +1,79 @@
+// Class: lime.graphics.cairo._CairoPattern.CairoPattern_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+
+// Constructor
+
+var CairoPattern_Impl_ = function(){}
+
+// Meta
+
+CairoPattern_Impl_.__name__ = ["lime","graphics","cairo","_CairoPattern","CairoPattern_Impl_"];
+CairoPattern_Impl_.prototype = {
+	
+};
+CairoPattern_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoPattern.CairoPattern_Impl_"] = CairoPattern_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoPattern_Impl_._new = function(handle) {
+	var this1 = handle;
+	return this1;
+}
+CairoPattern_Impl_.addColorStopRGB = function(this1,offset,r,g,b) {
+}
+CairoPattern_Impl_.addColorStopRGBA = function(this1,offset,r,g,b,a) {
+}
+CairoPattern_Impl_.createForSurface = function(surface) {
+	return 0;
+}
+CairoPattern_Impl_.createLinear = function(x0,y0,x1,y1) {
+	return 0;
+}
+CairoPattern_Impl_.createRadial = function(cx0,cy0,radius0,cx1,cy1,radius1) {
+	return 0;
+}
+CairoPattern_Impl_.createRGB = function(r,g,b) {
+	return 0;
+}
+CairoPattern_Impl_.createRGBA = function(r,g,b,a) {
+	return 0;
+}
+CairoPattern_Impl_.get_colorStopCount = function(this1) {
+	return 0;
+}
+CairoPattern_Impl_.get_extend = function(this1) {
+	return 0;
+}
+CairoPattern_Impl_.set_extend = function(this1,value) {
+	return value;
+}
+CairoPattern_Impl_.get_filter = function(this1) {
+	return 0;
+}
+CairoPattern_Impl_.set_filter = function(this1,value) {
+	return value;
+}
+CairoPattern_Impl_.get_matrix = function(this1) {
+	return null;
+}
+CairoPattern_Impl_.set_matrix = function(this1,value) {
+	return value;
+}
+
+
+// Export
+
+exports.default = CairoPattern_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoSurface/CairoSurface_Impl_.js

@@ -0,0 +1,37 @@
+// Class: lime.graphics.cairo._CairoSurface.CairoSurface_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+
+// Constructor
+
+var CairoSurface_Impl_ = function(){}
+
+// Meta
+
+CairoSurface_Impl_.__name__ = ["lime","graphics","cairo","_CairoSurface","CairoSurface_Impl_"];
+CairoSurface_Impl_.prototype = {
+	
+};
+CairoSurface_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoSurface.CairoSurface_Impl_"] = CairoSurface_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoSurface_Impl_.flush = function(this1) {
+}
+
+
+// Export
+
+exports.default = CairoSurface_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/IndexBuffer.js

@@ -0,0 +1,37 @@
+// Class: lime.graphics.console.IndexBuffer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var IndexBuffer = function() {
+}
+
+// Meta
+
+IndexBuffer.__name__ = ["lime","graphics","console","IndexBuffer"];
+IndexBuffer.prototype = {
+	
+};
+IndexBuffer.prototype.__class__ = $hxClasses["lime.graphics.console.IndexBuffer"] = IndexBuffer;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = IndexBuffer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/Primitive.js

@@ -0,0 +1,37 @@
+// Enum: lime.graphics.console.Primitive
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../../estr_stub").default;
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Definition
+
+var Primitive = $hxClasses["lime.graphics.console.Primitive"] = { __ename__: ["lime","graphics","console","Primitive"], __constructs__: ["Point","Line","LineStrip","Triangle","TriangleStrip"] }
+
+Primitive.Line = ["Line",1];
+Primitive.Line.toString = $estr;
+Primitive.Line.__enum__ = Primitive;
+
+Primitive.Triangle = ["Triangle",3];
+Primitive.Triangle.toString = $estr;
+Primitive.Triangle.__enum__ = Primitive;
+
+Primitive.TriangleStrip = ["TriangleStrip",4];
+Primitive.TriangleStrip.toString = $estr;
+Primitive.TriangleStrip.__enum__ = Primitive;
+
+Primitive.Point = ["Point",0];
+Primitive.Point.toString = $estr;
+Primitive.Point.__enum__ = Primitive;
+
+Primitive.LineStrip = ["LineStrip",2];
+Primitive.LineStrip.toString = $estr;
+Primitive.LineStrip.__enum__ = Primitive;
+
+
+exports.default = Primitive;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/Shader.js

@@ -0,0 +1,37 @@
+// Class: lime.graphics.console.Shader
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var Shader = function() {
+}
+
+// Meta
+
+Shader.__name__ = ["lime","graphics","console","Shader"];
+Shader.prototype = {
+	
+};
+Shader.prototype.__class__ = $hxClasses["lime.graphics.console.Shader"] = Shader;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Shader;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/VertexBuffer.js

@@ -0,0 +1,43 @@
+// Class: lime.graphics.console.VertexBuffer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_graphics_console_VertexOutput() {return require("./../../../lime/graphics/console/VertexOutput");}
+
+// Constructor
+
+var VertexBuffer = function() {
+}
+
+// Meta
+
+VertexBuffer.__name__ = ["lime","graphics","console","VertexBuffer"];
+VertexBuffer.prototype = {
+	lock: function() {
+		return new (lime_graphics_console_VertexOutput().default)();
+	},
+	unlock: function() {
+	}
+};
+VertexBuffer.prototype.__class__ = $hxClasses["lime.graphics.console.VertexBuffer"] = VertexBuffer;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = VertexBuffer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/VertexOutput.js

@@ -0,0 +1,42 @@
+// Class: lime.graphics.console.VertexOutput
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var VertexOutput = function() {
+}
+
+// Meta
+
+VertexOutput.__name__ = ["lime","graphics","console","VertexOutput"];
+VertexOutput.prototype = {
+	vec2: function(x,y) {
+	},
+	vec3: function(x,y,z) {
+	},
+	color: function(r,g,b,a) {
+	}
+};
+VertexOutput.prototype.__class__ = $hxClasses["lime.graphics.console.VertexOutput"] = VertexOutput;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = VertexOutput;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/BMP.js

@@ -0,0 +1,205 @@
+// Class: lime.graphics.format.BMP
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_graphics_format_BMPType() {return require("./../../../lime/graphics/format/BMPType");}
+function Type() {return require("./../../../Type");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function lime_math_Rectangle() {return require("./../../../lime/math/Rectangle");}
+
+// Constructor
+
+var BMP = function(){}
+
+// Meta
+
+BMP.__name__ = ["lime","graphics","format","BMP"];
+BMP.prototype = {
+	
+};
+BMP.prototype.__class__ = $hxClasses["lime.graphics.format.BMP"] = BMP;
+
+// Init
+
+
+
+// Statics
+
+BMP.encode = function(image,type) {
+	if(image.get_premultiplied() || image.get_format() != 0) {
+		image = image.clone();
+		image.set_premultiplied(false);
+		image.set_format(0);
+	}
+	if(type == null) {
+		type = (lime_graphics_format_BMPType().default).RGB;
+	}
+	var fileHeaderLength = 14;
+	var infoHeaderLength = 40;
+	var pixelValuesLength = image.width * image.height * 4;
+	if(type != null) {
+		switch((Type().default).enumIndex(type)) {
+		case 0:
+			pixelValuesLength = image.width * 3 + image.width * 3 % 4 + image.height * 3 + image.height * 3;
+			break;
+		case 1:
+			infoHeaderLength = 108;
+			break;
+		case 2:
+			fileHeaderLength = 0;
+			pixelValuesLength += image.width * image.height;
+			break;
+		}
+	}
+	var data = (haxe_io_Bytes().default).alloc(fileHeaderLength + infoHeaderLength + pixelValuesLength);
+	var position = 0;
+	if(fileHeaderLength > 0) {
+		data.set(position++,66);
+		data.set(position++,77);
+		data.setInt32(position,data.get_length());
+		position += 4;
+		data.setUInt16(position,0);
+		position += 2;
+		data.setUInt16(position,0);
+		position += 2;
+		data.setInt32(position,fileHeaderLength + infoHeaderLength);
+		position += 4;
+	}
+	data.setInt32(position,infoHeaderLength);
+	position += 4;
+	data.setInt32(position,image.width);
+	position += 4;
+	data.setInt32(position,type == (lime_graphics_format_BMPType().default).ICO ? image.height * 2 : image.height);
+	position += 4;
+	data.setUInt16(position,1);
+	position += 2;
+	data.setUInt16(position,type == (lime_graphics_format_BMPType().default).RGB ? 24 : 32);
+	position += 2;
+	data.setInt32(position,type == (lime_graphics_format_BMPType().default).BITFIELD ? 3 : 0);
+	position += 4;
+	data.setInt32(position,pixelValuesLength);
+	position += 4;
+	data.setInt32(position,11824);
+	position += 4;
+	data.setInt32(position,11824);
+	position += 4;
+	data.setInt32(position,0);
+	position += 4;
+	data.setInt32(position,0);
+	position += 4;
+	if(type == (lime_graphics_format_BMPType().default).BITFIELD) {
+		data.setInt32(position,16711680);
+		position += 4;
+		data.setInt32(position,65280);
+		position += 4;
+		data.setInt32(position,255);
+		position += 4;
+		data.setInt32(position,-16777216);
+		position += 4;
+		data.set(position++,32);
+		data.set(position++,110);
+		data.set(position++,105);
+		data.set(position++,87);
+		var _g = 0;
+		while(_g < 48) {
+			var i = _g++;
+			data.set(position++,0);
+		}
+	}
+	var pixels = image.getPixels(new (lime_math_Rectangle().default)(0,0,image.width,image.height),1);
+	var readPosition = 0;
+	var a;
+	var r;
+	var g;
+	var b;
+	if(type != null) {
+		switch((Type().default).enumIndex(type)) {
+		case 0:
+			var _g1 = 0;
+			var _g2 = image.height;
+			while(_g1 < _g2) {
+				var y = _g1++;
+				readPosition = (image.height - 1 - y) * 4 * image.width;
+				var _g3 = 0;
+				var _g21 = image.width;
+				while(_g3 < _g21) {
+					var x = _g3++;
+					a = pixels.get(readPosition++);
+					r = pixels.get(readPosition++);
+					g = pixels.get(readPosition++);
+					b = pixels.get(readPosition++);
+					data.set(position++,b);
+					data.set(position++,g);
+					data.set(position++,r);
+				}
+				var _g31 = 0;
+				var _g22 = image.width * 3 % 4;
+				while(_g31 < _g22) {
+					var i1 = _g31++;
+					data.set(position++,0);
+				}
+			}
+			break;
+		case 1:
+			var _g11 = 0;
+			var _g4 = image.height;
+			while(_g11 < _g4) {
+				var y1 = _g11++;
+				readPosition = (image.height - 1 - y1) * 4 * image.width;
+				var _g32 = 0;
+				var _g23 = image.width;
+				while(_g32 < _g23) {
+					var x1 = _g32++;
+					a = pixels.get(readPosition++);
+					r = pixels.get(readPosition++);
+					g = pixels.get(readPosition++);
+					b = pixels.get(readPosition++);
+					data.set(position++,b);
+					data.set(position++,g);
+					data.set(position++,r);
+					data.set(position++,a);
+				}
+			}
+			break;
+		case 2:
+			var andMask = (haxe_io_Bytes().default).alloc(image.width * image.height);
+			var maskPosition = 0;
+			var _g12 = 0;
+			var _g5 = image.height;
+			while(_g12 < _g5) {
+				var y2 = _g12++;
+				readPosition = (image.height - 1 - y2) * 4 * image.width;
+				var _g33 = 0;
+				var _g24 = image.width;
+				while(_g33 < _g24) {
+					var x2 = _g33++;
+					a = pixels.get(readPosition++);
+					r = pixels.get(readPosition++);
+					g = pixels.get(readPosition++);
+					b = pixels.get(readPosition++);
+					data.set(position++,b);
+					data.set(position++,g);
+					data.set(position++,r);
+					data.set(position++,a);
+					andMask.set(maskPosition++,0);
+				}
+			}
+			data.blit(position,andMask,0,image.width * image.height);
+			break;
+		}
+	}
+	return data;
+}
+
+
+// Export
+
+exports.default = BMP;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/BMPType.js

@@ -0,0 +1,29 @@
+// Enum: lime.graphics.format.BMPType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../../estr_stub").default;
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Definition
+
+var BMPType = $hxClasses["lime.graphics.format.BMPType"] = { __ename__: ["lime","graphics","format","BMPType"], __constructs__: ["RGB","BITFIELD","ICO"] }
+
+BMPType.ICO = ["ICO",2];
+BMPType.ICO.toString = $estr;
+BMPType.ICO.__enum__ = BMPType;
+
+BMPType.BITFIELD = ["BITFIELD",1];
+BMPType.BITFIELD.toString = $estr;
+BMPType.BITFIELD.__enum__ = BMPType;
+
+BMPType.RGB = ["RGB",0];
+BMPType.RGB.toString = $estr;
+BMPType.RGB.__enum__ = BMPType;
+
+
+exports.default = BMPType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/JPEG.js

@@ -0,0 +1,75 @@
+// Class: lime.graphics.format.JPEG
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_graphics_ImageType() {return require("./../../../lime/graphics/ImageType");}
+function lime_graphics_utils_ImageCanvasUtil() {return require("./../../../lime/graphics/utils/ImageCanvasUtil");}
+function js_Browser() {return require("./../../../js/Browser");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function HxOverrides() {return require("./../../../HxOverrides");}
+
+// Constructor
+
+var JPEG = function(){}
+
+// Meta
+
+JPEG.__name__ = ["lime","graphics","format","JPEG"];
+JPEG.prototype = {
+	
+};
+JPEG.prototype.__class__ = $hxClasses["lime.graphics.format.JPEG"] = JPEG;
+
+// Init
+
+
+
+// Statics
+
+JPEG.decodeBytes = function(bytes,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+JPEG.decodeFile = function(path,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+JPEG.encode = function(image,quality) {
+	if(image.get_premultiplied() || image.get_format() != 0) {
+		image = image.clone();
+		image.set_premultiplied(false);
+		image.set_format(0);
+	}
+	image.type = (lime_graphics_ImageType().default).CANVAS;
+	(lime_graphics_utils_ImageCanvasUtil().default).sync(image,false);
+	if(image.buffer.__srcCanvas != null) {
+		var data = image.buffer.__srcCanvas.toDataURL("image/jpeg",quality / 100);
+		var buffer = (js_Browser().default).get_window().atob(data.split(";base64,")[1]);
+		var bytes = (haxe_io_Bytes().default).alloc(buffer.length);
+		var _g1 = 0;
+		var _g = buffer.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			bytes.set(i,(HxOverrides().default).cca(buffer,i));
+		}
+		return bytes;
+	}
+	return null;
+}
+
+
+// Export
+
+exports.default = JPEG;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/PNG.js

@@ -0,0 +1,75 @@
+// Class: lime.graphics.format.PNG
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_graphics_ImageType() {return require("./../../../lime/graphics/ImageType");}
+function lime_graphics_utils_ImageCanvasUtil() {return require("./../../../lime/graphics/utils/ImageCanvasUtil");}
+function js_Browser() {return require("./../../../js/Browser");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function HxOverrides() {return require("./../../../HxOverrides");}
+
+// Constructor
+
+var PNG = function(){}
+
+// Meta
+
+PNG.__name__ = ["lime","graphics","format","PNG"];
+PNG.prototype = {
+	
+};
+PNG.prototype.__class__ = $hxClasses["lime.graphics.format.PNG"] = PNG;
+
+// Init
+
+
+
+// Statics
+
+PNG.decodeBytes = function(bytes,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+PNG.decodeFile = function(path,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+PNG.encode = function(image) {
+	if(image.get_premultiplied() || image.get_format() != 0) {
+		image = image.clone();
+		image.set_premultiplied(false);
+		image.set_format(0);
+	}
+	image.type = (lime_graphics_ImageType().default).CANVAS;
+	(lime_graphics_utils_ImageCanvasUtil().default).sync(image,false);
+	if(image.buffer.__srcCanvas != null) {
+		var data = image.buffer.__srcCanvas.toDataURL("image/png");
+		var buffer = (js_Browser().default).get_window().atob(data.split(";base64,")[1]);
+		var bytes = (haxe_io_Bytes().default).alloc(buffer.length);
+		var _g1 = 0;
+		var _g = buffer.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			bytes.set(i,(HxOverrides().default).cca(buffer,i));
+		}
+		return bytes;
+	}
+	return null;
+}
+
+
+// Export
+
+exports.default = PNG;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/opengl/GLContextType.js

@@ -0,0 +1,29 @@
+// Enum: lime.graphics.opengl.GLContextType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../../estr_stub").default;
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Definition
+
+var GLContextType = $hxClasses["lime.graphics.opengl.GLContextType"] = { __ename__: ["lime","graphics","opengl","GLContextType"], __constructs__: ["OPENGL","GLES","WEBGL"] }
+
+GLContextType.OPENGL = ["OPENGL",0];
+GLContextType.OPENGL.toString = $estr;
+GLContextType.OPENGL.__enum__ = GLContextType;
+
+GLContextType.WEBGL = ["WEBGL",2];
+GLContextType.WEBGL.toString = $estr;
+GLContextType.WEBGL.__enum__ = GLContextType;
+
+GLContextType.GLES = ["GLES",1];
+GLContextType.GLES.toString = $estr;
+GLContextType.GLES.__enum__ = GLContextType;
+
+
+exports.default = GLContextType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/opengl/_GLES2Context/GLES2Context_Impl_.js

@@ -0,0 +1,40 @@
+// Class: lime.graphics.opengl._GLES2Context.GLES2Context_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+var $import = require("./../../../../import_stub").default;
+function lime_graphics_opengl_GL() {return require("./../../../../lime/graphics/opengl/GL");}
+
+// Constructor
+
+var GLES2Context_Impl_ = function(){}
+
+// Meta
+
+GLES2Context_Impl_.__name__ = ["lime","graphics","opengl","_GLES2Context","GLES2Context_Impl_"];
+GLES2Context_Impl_.prototype = {
+	
+};
+GLES2Context_Impl_.prototype.__class__ = $hxClasses["lime.graphics.opengl._GLES2Context.GLES2Context_Impl_"] = GLES2Context_Impl_;
+
+// Init
+
+
+
+// Statics
+
+GLES2Context_Impl_.fromGL = function(gl) {
+	return (lime_graphics_opengl_GL().default).context;
+}
+
+
+// Export
+
+exports.default = GLES2Context_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/opengl/_WebGLContext/WebGLContext_Impl_.js

@@ -0,0 +1,76 @@
+// Class: lime.graphics.opengl._WebGLContext.WebGLContext_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+var $import = require("./../../../../import_stub").default;
+function lime_graphics_opengl_GL() {return require("./../../../../lime/graphics/opengl/GL");}
+
+// Constructor
+
+var WebGLContext_Impl_ = function(){}
+
+// Meta
+
+WebGLContext_Impl_.__name__ = ["lime","graphics","opengl","_WebGLContext","WebGLContext_Impl_"];
+WebGLContext_Impl_.prototype = {
+	
+};
+WebGLContext_Impl_.prototype.__class__ = $hxClasses["lime.graphics.opengl._WebGLContext.WebGLContext_Impl_"] = WebGLContext_Impl_;
+
+// Init
+
+
+
+// Statics
+
+WebGLContext_Impl_.bufferData = function(this1,target,srcData,usage) {
+	this1.bufferDataWEBGL(target,srcData,usage,null,null);
+}
+WebGLContext_Impl_.bufferSubData = function(this1,target,offset,srcData) {
+	this1.bufferSubDataWEBGL(target,offset,srcData,null,null);
+}
+WebGLContext_Impl_.compressedTexImage2D = function(this1,target,level,internalformat,width,height,border,srcData) {
+	this1.compressedTexImage2DWEBGL(target,level,internalformat,width,height,border,srcData,null,null);
+}
+WebGLContext_Impl_.compressedTexSubImage2D = function(this1,target,level,xoffset,yoffset,width,height,format,srcData) {
+	this1.compressedTexSubImage2DWEBGL(target,level,xoffset,yoffset,width,height,format,srcData,null,null);
+}
+WebGLContext_Impl_.readPixels = function(this1,x,y,width,height,format,type,pixels) {
+	this1.readPixelsWEBGL(x,y,width,height,format,type,pixels,null);
+}
+WebGLContext_Impl_.texImage2D = function(this1,target,level,internalformat,width,height,border,format,type,srcData) {
+	this1.texImage2DWEBGL(target,level,internalformat,width,height,border,format,type,srcData,null);
+}
+WebGLContext_Impl_.texSubImage2D = function(this1,target,level,xoffset,yoffset,width,height,format,type,srcData) {
+	this1.texSubImage2DWEBGL(target,level,xoffset,yoffset,width,height,format,type,srcData,null);
+}
+WebGLContext_Impl_.uniformMatrix2fv = function(this1,location,transpose,v) {
+	this1.uniformMatrix2fvWEBGL(location,transpose,v,null,null);
+}
+WebGLContext_Impl_.uniformMatrix3fv = function(this1,location,transpose,v) {
+	this1.uniformMatrix3fvWEBGL(location,transpose,v,null,null);
+}
+WebGLContext_Impl_.uniformMatrix4fv = function(this1,location,transpose,v) {
+	this1.uniformMatrix4fvWEBGL(location,transpose,v,null,null);
+}
+WebGLContext_Impl_.fromGL = function(gl) {
+	return (lime_graphics_opengl_GL().default).context;
+}
+WebGLContext_Impl_.fromGLES2Context = function(gl) {
+	return gl;
+}
+WebGLContext_Impl_.fromGLES3Context = function(gl) {
+	return gl;
+}
+
+
+// Export
+
+exports.default = WebGLContext_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/utils/ImageCanvasUtil.js

@@ -0,0 +1,294 @@
+// Class: lime.graphics.utils.ImageCanvasUtil
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_graphics_utils_ImageDataUtil() {return require("./../../../lime/graphics/utils/ImageDataUtil");}
+function lime_graphics_ImageType() {return require("./../../../lime/graphics/ImageType");}
+function lime_math_Vector2() {return require("./../../../lime/math/Vector2");}
+function lime_math_Rectangle() {return require("./../../../lime/math/Rectangle");}
+function lime_graphics_ImageChannel() {return require("./../../../lime/graphics/ImageChannel");}
+function Std() {return require("./../../../Std");}
+function js_Browser() {return require("./../../../js/Browser");}
+
+// Constructor
+
+var ImageCanvasUtil = function(){}
+
+// Meta
+
+ImageCanvasUtil.__name__ = ["lime","graphics","utils","ImageCanvasUtil"];
+ImageCanvasUtil.prototype = {
+	
+};
+ImageCanvasUtil.prototype.__class__ = $hxClasses["lime.graphics.utils.ImageCanvasUtil"] = ImageCanvasUtil;
+
+// Init
+
+
+
+// Statics
+
+ImageCanvasUtil.colorTransform = function(image,rect,colorMatrix) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).colorTransform(image,rect,colorMatrix);
+}
+ImageCanvasUtil.convertToCanvas = function(image,clear) {
+	if(clear == null) {
+		clear = false;
+	}
+	var buffer = image.buffer;
+	if(buffer.__srcImage != null) {
+		if(buffer.__srcCanvas == null) {
+			ImageCanvasUtil.createCanvas(image,buffer.__srcImage.width,buffer.__srcImage.height);
+			buffer.__srcContext.drawImage(buffer.__srcImage,0,0);
+		}
+		buffer.__srcImage = null;
+	} else if(buffer.__srcCanvas == null && buffer.data != null) {
+		image.set_transparent(true);
+		ImageCanvasUtil.createCanvas(image,buffer.width,buffer.height);
+		ImageCanvasUtil.createImageData(image);
+		buffer.__srcContext.putImageData(buffer.__srcImageData,0,0);
+	} else if(image.type == (lime_graphics_ImageType().default).DATA && buffer.__srcImageData != null && image.dirty) {
+		buffer.__srcContext.putImageData(buffer.__srcImageData,0,0);
+		image.dirty = false;
+	}
+	if(clear) {
+		buffer.data = null;
+		buffer.__srcImageData = null;
+	} else if(buffer.data == null && buffer.__srcImageData != null) {
+		buffer.data = buffer.__srcImageData.data;
+	}
+	image.type = (lime_graphics_ImageType().default).CANVAS;
+}
+ImageCanvasUtil.convertToData = function(image,clear) {
+	if(clear == null) {
+		clear = false;
+	}
+	var buffer = image.buffer;
+	if(buffer.__srcImage != null) {
+		ImageCanvasUtil.convertToCanvas(image);
+	}
+	if(buffer.__srcCanvas != null && buffer.data == null) {
+		ImageCanvasUtil.createImageData(image);
+		if(image.type == (lime_graphics_ImageType().default).CANVAS) {
+			image.dirty = false;
+		}
+	} else if(image.type == (lime_graphics_ImageType().default).CANVAS && buffer.__srcCanvas != null && image.dirty) {
+		if(buffer.__srcImageData == null) {
+			ImageCanvasUtil.createImageData(image);
+		} else {
+			buffer.__srcImageData = buffer.__srcContext.getImageData(0,0,buffer.width,buffer.height);
+			var elements = buffer.__srcImageData.data.buffer;
+			var this1;
+			if(elements != null) {
+				this1 = new Uint8Array(elements);
+			} else {
+				this1 = null;
+			}
+			buffer.data = this1;
+		}
+		image.dirty = false;
+	}
+	if(clear) {
+		image.buffer.__srcCanvas = null;
+		image.buffer.__srcContext = null;
+	}
+	image.type = (lime_graphics_ImageType().default).DATA;
+}
+ImageCanvasUtil.copyChannel = function(image,sourceImage,sourceRect,destPoint,sourceChannel,destChannel) {
+	ImageCanvasUtil.convertToData(sourceImage);
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).copyChannel(image,sourceImage,sourceRect,destPoint,sourceChannel,destChannel);
+}
+ImageCanvasUtil.copyPixels = function(image,sourceImage,sourceRect,destPoint,alphaImage,alphaPoint,mergeAlpha) {
+	if(mergeAlpha == null) {
+		mergeAlpha = false;
+	}
+	if(destPoint == null || destPoint.x >= image.width || destPoint.y >= image.height || sourceRect == null || sourceRect.width < 1 || sourceRect.height < 1) {
+		return;
+	}
+	if(alphaImage != null && alphaImage.get_transparent()) {
+		if(alphaPoint == null) {
+			alphaPoint = new (lime_math_Vector2().default)();
+		}
+		var tempData = image.clone();
+		tempData.copyChannel(alphaImage,new (lime_math_Rectangle().default)(alphaPoint.x,alphaPoint.y,sourceRect.width,sourceRect.height),new (lime_math_Vector2().default)(sourceRect.x,sourceRect.y),(lime_graphics_ImageChannel().default).ALPHA,(lime_graphics_ImageChannel().default).ALPHA);
+		sourceImage = tempData;
+	}
+	ImageCanvasUtil.convertToCanvas(image,true);
+	if(!mergeAlpha) {
+		if(image.get_transparent() && sourceImage.get_transparent()) {
+			image.buffer.__srcContext.clearRect(destPoint.x + image.offsetX,destPoint.y + image.offsetY,sourceRect.width + image.offsetX,sourceRect.height + image.offsetY);
+		}
+	}
+	ImageCanvasUtil.convertToCanvas(sourceImage);
+	if(sourceImage.buffer.get_src() != null) {
+		image.buffer.__srcContext.globalCompositeOperation = "source-over";
+		image.buffer.__srcContext.drawImage(sourceImage.buffer.get_src(),(Std().default)["int"](sourceRect.x + sourceImage.offsetX),(Std().default)["int"](sourceRect.y + sourceImage.offsetY),(Std().default)["int"](sourceRect.width),(Std().default)["int"](sourceRect.height),(Std().default)["int"](destPoint.x + image.offsetX),(Std().default)["int"](destPoint.y + image.offsetY),(Std().default)["int"](sourceRect.width),(Std().default)["int"](sourceRect.height));
+	}
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.createCanvas = function(image,width,height) {
+	var buffer = image.buffer;
+	if(buffer.__srcCanvas == null) {
+		buffer.__srcCanvas = (js_Browser().default).get_document().createElement("canvas");
+		buffer.__srcCanvas.width = width;
+		buffer.__srcCanvas.height = height;
+		if(!image.get_transparent()) {
+			if(!image.get_transparent()) {
+				buffer.__srcCanvas.setAttribute("moz-opaque","true");
+			}
+			buffer.__srcContext = buffer.__srcCanvas.getContext ("2d", { alpha: false });
+		} else {
+			buffer.__srcContext = buffer.__srcCanvas.getContext("2d");
+		}
+		buffer.__srcContext.mozImageSmoothingEnabled = false;
+		buffer.__srcContext.msImageSmoothingEnabled = false;
+		buffer.__srcContext.imageSmoothingEnabled = false;
+	}
+}
+ImageCanvasUtil.createImageData = function(image) {
+	var buffer = image.buffer;
+	if(buffer.__srcImageData == null) {
+		if(buffer.data == null) {
+			buffer.__srcImageData = buffer.__srcContext.getImageData(0,0,buffer.width,buffer.height);
+		} else {
+			buffer.__srcImageData = buffer.__srcContext.createImageData(buffer.width,buffer.height);
+			buffer.__srcImageData.data.set(buffer.data);
+		}
+		var elements = buffer.__srcImageData.data.buffer;
+		var this1;
+		if(elements != null) {
+			this1 = new Uint8Array(elements);
+		} else {
+			this1 = null;
+		}
+		buffer.data = this1;
+	}
+}
+ImageCanvasUtil.fillRect = function(image,rect,color,format) {
+	ImageCanvasUtil.convertToCanvas(image);
+	var r;
+	var g;
+	var b;
+	var a;
+	if(format == 1) {
+		r = color >> 16 & 255;
+		g = color >> 8 & 255;
+		b = color & 255;
+		if(image.get_transparent()) {
+			a = color >> 24 & 255;
+		} else {
+			a = 255;
+		}
+	} else {
+		r = color >> 24 & 255;
+		g = color >> 16 & 255;
+		b = color >> 8 & 255;
+		if(image.get_transparent()) {
+			a = color & 255;
+		} else {
+			a = 255;
+		}
+	}
+	if(rect.x == 0 && rect.y == 0 && rect.width == image.width && rect.height == image.height) {
+		if(image.get_transparent() && a == 0) {
+			image.buffer.__srcCanvas.width = image.buffer.width;
+			return;
+		}
+	}
+	if(a < 255) {
+		image.buffer.__srcContext.clearRect(rect.x + image.offsetX,rect.y + image.offsetY,rect.width + image.offsetX,rect.height + image.offsetY);
+	}
+	if(a > 0) {
+		image.buffer.__srcContext.fillStyle = "rgba(" + r + ", " + g + ", " + b + ", " + a / 255 + ")";
+		image.buffer.__srcContext.fillRect(rect.x + image.offsetX,rect.y + image.offsetY,rect.width + image.offsetX,rect.height + image.offsetY);
+	}
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.floodFill = function(image,x,y,color,format) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).floodFill(image,x,y,color,format);
+}
+ImageCanvasUtil.getPixel = function(image,x,y,format) {
+	ImageCanvasUtil.convertToData(image);
+	return (lime_graphics_utils_ImageDataUtil().default).getPixel(image,x,y,format);
+}
+ImageCanvasUtil.getPixel32 = function(image,x,y,format) {
+	ImageCanvasUtil.convertToData(image);
+	return (lime_graphics_utils_ImageDataUtil().default).getPixel32(image,x,y,format);
+}
+ImageCanvasUtil.getPixels = function(image,rect,format) {
+	ImageCanvasUtil.convertToData(image);
+	return (lime_graphics_utils_ImageDataUtil().default).getPixels(image,rect,format);
+}
+ImageCanvasUtil.merge = function(image,sourceImage,sourceRect,destPoint,redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier) {
+	ImageCanvasUtil.convertToData(sourceImage);
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).merge(image,sourceImage,sourceRect,destPoint,redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier);
+}
+ImageCanvasUtil.resize = function(image,newWidth,newHeight) {
+	var buffer = image.buffer;
+	if(buffer.__srcCanvas == null) {
+		ImageCanvasUtil.createCanvas(image,newWidth,newHeight);
+		buffer.__srcContext.drawImage(buffer.get_src(),0,0,newWidth,newHeight);
+	} else {
+		ImageCanvasUtil.convertToCanvas(image,true);
+		var sourceCanvas = buffer.__srcCanvas;
+		buffer.__srcCanvas = null;
+		ImageCanvasUtil.createCanvas(image,newWidth,newHeight);
+		buffer.__srcContext.drawImage(sourceCanvas,0,0,newWidth,newHeight);
+	}
+	buffer.__srcImageData = null;
+	buffer.data = null;
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.scroll = function(image,x,y) {
+	if(x % image.width == 0 && y % image.height == 0) {
+		return;
+	}
+	var copy = image.clone();
+	ImageCanvasUtil.convertToCanvas(image,true);
+	image.buffer.__srcContext.clearRect(x,y,image.width,image.height);
+	image.buffer.__srcContext.drawImage(copy.get_src(),x,y);
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.setPixel = function(image,x,y,color,format) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).setPixel(image,x,y,color,format);
+}
+ImageCanvasUtil.setPixel32 = function(image,x,y,color,format) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).setPixel32(image,x,y,color,format);
+}
+ImageCanvasUtil.setPixels = function(image,rect,bytePointer,format,endian) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).setPixels(image,rect,bytePointer,format,endian);
+}
+ImageCanvasUtil.sync = function(image,clear) {
+	if(image == null) {
+		return;
+	}
+	if(image.type == (lime_graphics_ImageType().default).CANVAS) {
+		ImageCanvasUtil.convertToCanvas(image,clear);
+	} else {
+		ImageCanvasUtil.convertToData(image,clear);
+	}
+}
+
+
+// Export
+
+exports.default = ImageCanvasUtil;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/utils/_ImageDataUtil/ImageDataView.js

@@ -0,0 +1,105 @@
+// Class: lime.graphics.utils._ImageDataUtil.ImageDataView
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../../hxClasses_stub").default;
+var $import = require("./../../../../import_stub").default;
+
+// Constructor
+
+var ImageDataView = function(image,rect) {
+	this.image = image;
+	if(rect == null) {
+		this.rect = image.get_rect();
+	} else {
+		if(rect.x < 0) {
+			rect.x = 0;
+		}
+		if(rect.y < 0) {
+			rect.y = 0;
+		}
+		if(rect.x + rect.width > image.width) {
+			rect.width = image.width - rect.x;
+		}
+		if(rect.y + rect.height > image.height) {
+			rect.height = image.height - rect.y;
+		}
+		if(rect.width < 0) {
+			rect.width = 0;
+		}
+		if(rect.height < 0) {
+			rect.height = 0;
+		}
+		this.rect = rect;
+	}
+	this.stride = image.buffer.get_stride();
+	this.__update();
+}
+
+// Meta
+
+ImageDataView.__name__ = ["lime","graphics","utils","_ImageDataUtil","ImageDataView"];
+ImageDataView.prototype = {
+	clip: function(x,y,width,height) {
+		this.rect.__contract(x,y,width,height);
+		this.__update();
+	},
+	hasRow: function(y) {
+		if(y >= 0) {
+			return y < this.height;
+		} else {
+			return false;
+		}
+	},
+	offset: function(x,y) {
+		if(x < 0) {
+			this.rect.x += x;
+			if(this.rect.x < 0) {
+				this.rect.x = 0;
+			}
+		} else {
+			this.rect.x += x;
+			this.rect.width -= x;
+		}
+		if(y < 0) {
+			this.rect.y += y;
+			if(this.rect.y < 0) {
+				this.rect.y = 0;
+			}
+		} else {
+			this.rect.y += y;
+			this.rect.height -= y;
+		}
+		this.__update();
+	},
+	row: function(y) {
+		return this.byteOffset + this.stride * y;
+	},
+	__update: function() {
+		this.x = Math.ceil(this.rect.x);
+		this.y = Math.ceil(this.rect.y);
+		this.width = Math.floor(this.rect.width);
+		this.height = Math.floor(this.rect.height);
+		this.byteOffset = this.stride * (this.y + this.image.offsetY) + (this.x + this.image.offsetX) * 4;
+	}
+};
+ImageDataView.prototype.__class__ = $hxClasses["lime.graphics.utils._ImageDataUtil.ImageDataView"] = ImageDataView;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ImageDataView;