First commit

hGameTest/node_modules/openfl/lib/_gen/js/html/_CanvasElement/CanvasUtil.js

@@ -0,0 +1,48 @@
+// Class: js.html._CanvasElement.CanvasUtil
+
+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 CanvasUtil = function(){}
+
+// Meta
+
+CanvasUtil.__name__ = ["js","html","_CanvasElement","CanvasUtil"];
+CanvasUtil.prototype = {
+	
+};
+CanvasUtil.prototype.__class__ = $hxClasses["js.html._CanvasElement.CanvasUtil"] = CanvasUtil;
+
+// Init
+
+
+
+// Statics
+
+CanvasUtil.getContextWebGL = function(canvas,attribs) {
+	var _g = 0;
+	var _g1 = ["webgl","experimental-webgl"];
+	while(_g < _g1.length) {
+		var name = _g1[_g];
+		++_g;
+		var ctx = canvas.getContext(name,attribs);
+		if(ctx != null) {
+			return ctx;
+		}
+	}
+	return null;
+}
+
+
+// Export
+
+exports.default = CanvasUtil;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/ArrayBuffer.js

@@ -0,0 +1,65 @@
+// Class: js.html.compat.ArrayBuffer
+
+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 ArrayBuffer = function(a) {
+	if((a instanceof Array) && a.__enum__ == null) {
+		this.a = a;
+		this.byteLength = a.length;
+	} else {
+		var len = a;
+		this.a = [];
+		var _g1 = 0;
+		var _g = len;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this.a[i] = 0;
+		}
+		this.byteLength = len;
+	}
+}
+
+// Meta
+
+ArrayBuffer.__name__ = ["js","html","compat","ArrayBuffer"];
+ArrayBuffer.prototype = {
+	slice: function(begin,end) {
+		return new ArrayBuffer(this.a.slice(begin,end));
+	}
+};
+ArrayBuffer.prototype.__class__ = $hxClasses["js.html.compat.ArrayBuffer"] = ArrayBuffer;
+
+// Init
+
+{
+	var ArrayBuffer = $global.ArrayBuffer || ArrayBuffer
+	if(ArrayBuffer.prototype.slice == null) {
+		ArrayBuffer.prototype.slice = ArrayBuffer.sliceImpl;
+	}
+};
+
+// Statics
+
+ArrayBuffer.sliceImpl = function(begin,end) {
+	var u = new Uint8Array(this,begin,end == null ? null : end - begin);
+	var result = new ArrayBuffer(u.byteLength);
+	var resultArray = new Uint8Array(result);
+	resultArray.set(u);
+	return result;
+}
+
+
+// Export
+
+exports.default = ArrayBuffer;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/DataView.js

@@ -0,0 +1,152 @@
+// Class: js.html.compat.DataView
+
+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 haxe_io_FPHelper() {return require("./../../../haxe/io/FPHelper");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+function haxe_io_Error() {return require("./../../../haxe/io/Error");}
+
+// Constructor
+
+var DataView = function(buffer,byteOffset,byteLength) {
+	this.buf = buffer;
+	this.offset = byteOffset == null ? 0 : byteOffset;
+	this.length = byteLength == null ? buffer.byteLength - this.offset : byteLength;
+	if(this.offset < 0 || this.length < 0 || this.offset + this.length > buffer.byteLength) {
+		throw new (js__$Boot_HaxeError().default)((haxe_io_Error().default).OutsideBounds);
+	}
+	this.byteLength = this.length;
+	this.byteOffset = this.offset;
+	this.buffer = this.buf;
+}
+
+// Meta
+
+DataView.__name__ = ["js","html","compat","DataView"];
+DataView.prototype = {
+	getInt8: function(byteOffset) {
+		var v = this.buf.a[this.offset + byteOffset];
+		if(v >= 128) {
+			return v - 256;
+		} else {
+			return v;
+		}
+	},
+	getUint8: function(byteOffset) {
+		return this.buf.a[this.offset + byteOffset];
+	},
+	getInt16: function(byteOffset,littleEndian) {
+		var v = this.getUint16(byteOffset,littleEndian);
+		if(v >= 32768) {
+			return v - 65536;
+		} else {
+			return v;
+		}
+	},
+	getUint16: function(byteOffset,littleEndian) {
+		if(littleEndian) {
+			return this.buf.a[this.offset + byteOffset] | this.buf.a[this.offset + byteOffset + 1] << 8;
+		} else {
+			return this.buf.a[this.offset + byteOffset] << 8 | this.buf.a[this.offset + byteOffset + 1];
+		}
+	},
+	getInt32: function(byteOffset,littleEndian) {
+		var p = this.offset + byteOffset;
+		var a = this.buf.a[p++];
+		var b = this.buf.a[p++];
+		var c = this.buf.a[p++];
+		var d = this.buf.a[p++];
+		if(littleEndian) {
+			return a | b << 8 | c << 16 | d << 24;
+		} else {
+			return d | c << 8 | b << 16 | a << 24;
+		}
+	},
+	getUint32: function(byteOffset,littleEndian) {
+		var v = this.getInt32(byteOffset,littleEndian);
+		if(v < 0) {
+			return v + 4294967296.;
+		} else {
+			return v;
+		}
+	},
+	getFloat32: function(byteOffset,littleEndian) {
+		return (haxe_io_FPHelper().default).i32ToFloat(this.getInt32(byteOffset,littleEndian));
+	},
+	getFloat64: function(byteOffset,littleEndian) {
+		var a = this.getInt32(byteOffset,littleEndian);
+		var b = this.getInt32(byteOffset + 4,littleEndian);
+		return (haxe_io_FPHelper().default).i64ToDouble(littleEndian ? a : b,littleEndian ? b : a);
+	},
+	setInt8: function(byteOffset,value) {
+		this.buf.a[byteOffset + this.offset] = value < 0 ? value + 128 & 255 : value & 255;
+	},
+	setUint8: function(byteOffset,value) {
+		this.buf.a[byteOffset + this.offset] = value & 255;
+	},
+	setInt16: function(byteOffset,value,littleEndian) {
+		this.setUint16(byteOffset,value < 0 ? value + 65536 : value,littleEndian);
+	},
+	setUint16: function(byteOffset,value,littleEndian) {
+		var p = byteOffset + this.offset;
+		if(littleEndian) {
+			this.buf.a[p] = value & 255;
+			this.buf.a[p++] = value >> 8 & 255;
+		} else {
+			this.buf.a[p++] = value >> 8 & 255;
+			this.buf.a[p] = value & 255;
+		}
+	},
+	setInt32: function(byteOffset,value,littleEndian) {
+		this.setUint32(byteOffset,value,littleEndian);
+	},
+	setUint32: function(byteOffset,value,littleEndian) {
+		var p = byteOffset + this.offset;
+		if(littleEndian) {
+			this.buf.a[p++] = value & 255;
+			this.buf.a[p++] = value >> 8 & 255;
+			this.buf.a[p++] = value >> 16 & 255;
+			this.buf.a[p++] = value >>> 24;
+		} else {
+			this.buf.a[p++] = value >>> 24;
+			this.buf.a[p++] = value >> 16 & 255;
+			this.buf.a[p++] = value >> 8 & 255;
+			this.buf.a[p++] = value & 255;
+		}
+	},
+	setFloat32: function(byteOffset,value,littleEndian) {
+		this.setUint32(byteOffset,(haxe_io_FPHelper().default).floatToI32(value),littleEndian);
+	},
+	setFloat64: function(byteOffset,value,littleEndian) {
+		var i64 = (haxe_io_FPHelper().default).doubleToI64(value);
+		if(littleEndian) {
+			this.setUint32(byteOffset,i64.low);
+			this.setUint32(byteOffset,i64.high);
+		} else {
+			this.setUint32(byteOffset,i64.high);
+			this.setUint32(byteOffset,i64.low);
+		}
+	}
+};
+DataView.prototype.__class__ = $hxClasses["js.html.compat.DataView"] = DataView;
+
+// Init
+
+var DataView = $global.DataView || DataView;
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = DataView;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/Float32Array.js

@@ -0,0 +1,134 @@
+// Class: js.html.compat.Float32Array
+
+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_html_compat_ArrayBuffer() {return require("./../../../js/html/compat/ArrayBuffer");}
+function Std() {return require("./../../../Std");}
+function haxe_io_FPHelper() {return require("./../../../haxe/io/FPHelper");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Float32Array = function(){}
+
+// Meta
+
+Float32Array.__name__ = ["js","html","compat","Float32Array"];
+Float32Array.prototype = {
+	
+};
+Float32Array.prototype.__class__ = $hxClasses["js.html.compat.Float32Array"] = Float32Array;
+
+// Init
+
+var Float32Array = $global.Float32Array || Float32Array._new;
+
+// Statics
+
+Float32Array._new = function(arg1,offset,length) {
+	var arr;
+	if(typeof(arg1) == "number") {
+		arr = [];
+		var _g1 = 0;
+		var _g = arg1;
+		while(_g1 < _g) {
+			var i = _g1++;
+			arr[i] = 0;
+		}
+		arr.byteLength = arr.length << 2;
+		arr.byteOffset = 0;
+		var _g2 = [];
+		var _g21 = 0;
+		var _g11 = arr.length << 2;
+		while(_g21 < _g11) {
+			var i1 = _g21++;
+			_g2.push(0);
+		}
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(_g2);
+	} else if((Std().default)["is"](arg1,(js_html_compat_ArrayBuffer().default))) {
+		var buffer = arg1;
+		if(offset == null) {
+			offset = 0;
+		}
+		if(length == null) {
+			length = buffer.byteLength - offset >> 2;
+		}
+		arr = [];
+		var _g12 = 0;
+		var _g3 = length;
+		while(_g12 < _g3) {
+			var i2 = _g12++;
+			var val = buffer.a[offset++] | buffer.a[offset++] << 8 | buffer.a[offset++] << 16 | buffer.a[offset++] << 24;
+			arr.push((haxe_io_FPHelper().default).i32ToFloat(val));
+		}
+		arr.byteLength = arr.length << 2;
+		arr.byteOffset = offset;
+		arr.buffer = buffer;
+	} else if((arg1 instanceof Array) && arg1.__enum__ == null) {
+		arr = arg1.slice();
+		var buffer1 = [];
+		var _g4 = 0;
+		while(_g4 < arr.length) {
+			var f = arr[_g4];
+			++_g4;
+			var i3 = (haxe_io_FPHelper().default).floatToI32(f);
+			buffer1.push(i3 & 255);
+			buffer1.push(i3 >> 8 & 255);
+			buffer1.push(i3 >> 16 & 255);
+			buffer1.push(i3 >>> 24);
+		}
+		arr.byteLength = arr.length << 2;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(buffer1);
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO " + (Std().default).string(arg1));
+	}
+	arr.subarray = Float32Array._subarray;
+	arr.set = Float32Array._set;
+	return arr;
+}
+Float32Array._set = function(arg,offset) {
+	if((Std().default)["is"](arg.buffer,(js_html_compat_ArrayBuffer().default))) {
+		var a = arg;
+		if(arg.byteLength + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g1 = 0;
+		var _g = arg.byteLength;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this[i + offset] = a[i];
+		}
+	} else if((arg instanceof Array) && arg.__enum__ == null) {
+		var a1 = arg;
+		if(a1.length + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g11 = 0;
+		var _g2 = a1.length;
+		while(_g11 < _g2) {
+			var i1 = _g11++;
+			this[i1 + offset] = a1[i1];
+		}
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO");
+	}
+}
+Float32Array._subarray = function(start,end) {
+	var a = Float32Array._new(this.slice(start,end));
+	a.byteOffset = start * 4;
+	return a;
+}
+Float32Array.BYTES_PER_ELEMENT = 4
+
+// Export
+
+exports.default = Float32Array;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/Float64Array.js

@@ -0,0 +1,141 @@
+// Class: js.html.compat.Float64Array
+
+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_html_compat_ArrayBuffer() {return require("./../../../js/html/compat/ArrayBuffer");}
+function Std() {return require("./../../../Std");}
+function haxe_io_FPHelper() {return require("./../../../haxe/io/FPHelper");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Float64Array = function(){}
+
+// Meta
+
+Float64Array.__name__ = ["js","html","compat","Float64Array"];
+Float64Array.prototype = {
+	
+};
+Float64Array.prototype.__class__ = $hxClasses["js.html.compat.Float64Array"] = Float64Array;
+
+// Init
+
+var Float64Array = $global.Float64Array || ($global.Float32Array ? "notsupported" : null) || Float64Array._new;
+
+// Statics
+
+Float64Array._new = function(arg1,offset,length) {
+	var arr;
+	if(typeof(arg1) == "number") {
+		arr = [];
+		var _g1 = 0;
+		var _g = arg1;
+		while(_g1 < _g) {
+			var i = _g1++;
+			arr[i] = 0;
+		}
+		arr.byteLength = arr.length << 3;
+		arr.byteOffset = 0;
+		var _g2 = [];
+		var _g21 = 0;
+		var _g11 = arr.length << 3;
+		while(_g21 < _g11) {
+			var i1 = _g21++;
+			_g2.push(0);
+		}
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(_g2);
+	} else if((Std().default)["is"](arg1,(js_html_compat_ArrayBuffer().default))) {
+		var buffer = arg1;
+		if(offset == null) {
+			offset = 0;
+		}
+		if(length == null) {
+			length = buffer.byteLength - offset >> 3;
+		}
+		arr = [];
+		var _g12 = 0;
+		var _g3 = length;
+		while(_g12 < _g3) {
+			var i2 = _g12++;
+			var val1 = buffer.a[offset++] | buffer.a[offset++] << 8 | buffer.a[offset++] << 16 | buffer.a[offset++] << 24;
+			var val2 = buffer.a[offset++] | buffer.a[offset++] << 8 | buffer.a[offset++] << 16 | buffer.a[offset++] << 24;
+			arr.push((haxe_io_FPHelper().default).i64ToDouble(val1,val2));
+		}
+		arr.byteLength = arr.length << 3;
+		arr.byteOffset = offset;
+		arr.buffer = buffer;
+	} else if((arg1 instanceof Array) && arg1.__enum__ == null) {
+		arr = arg1.slice();
+		var buffer1 = [];
+		var _g4 = 0;
+		while(_g4 < arr.length) {
+			var f = arr[_g4];
+			++_g4;
+			var v = (haxe_io_FPHelper().default).doubleToI64(f);
+			var i3 = v.low;
+			buffer1.push(i3 & 255);
+			buffer1.push(i3 >> 8 & 255);
+			buffer1.push(i3 >> 16 & 255);
+			buffer1.push(i3 >>> 24);
+			var i4 = v.high;
+			buffer1.push(i4 & 255);
+			buffer1.push(i4 >> 8 & 255);
+			buffer1.push(i4 >> 16 & 255);
+			buffer1.push(i4 >>> 24);
+		}
+		arr.byteLength = arr.length << 3;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(buffer1);
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO " + (Std().default).string(arg1));
+	}
+	arr.subarray = Float64Array._subarray;
+	arr.set = Float64Array._set;
+	return arr;
+}
+Float64Array._set = function(arg,offset) {
+	if((Std().default)["is"](arg.buffer,(js_html_compat_ArrayBuffer().default))) {
+		var a = arg;
+		if(arg.byteLength + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g1 = 0;
+		var _g = arg.byteLength;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this[i + offset] = a[i];
+		}
+	} else if((arg instanceof Array) && arg.__enum__ == null) {
+		var a1 = arg;
+		if(a1.length + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g11 = 0;
+		var _g2 = a1.length;
+		while(_g11 < _g2) {
+			var i1 = _g11++;
+			this[i1 + offset] = a1[i1];
+		}
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO");
+	}
+}
+Float64Array._subarray = function(start,end) {
+	var a = Float64Array._new(this.slice(start,end));
+	a.byteOffset = start * 8;
+	return a;
+}
+Float64Array.BYTES_PER_ELEMENT = 8
+
+// Export
+
+exports.default = Float64Array;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/Uint8Array.js

@@ -0,0 +1,112 @@
+// Class: js.html.compat.Uint8Array
+
+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_html_compat_ArrayBuffer() {return require("./../../../js/html/compat/ArrayBuffer");}
+function Std() {return require("./../../../Std");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Uint8Array = function(){}
+
+// Meta
+
+Uint8Array.__name__ = ["js","html","compat","Uint8Array"];
+Uint8Array.prototype = {
+	
+};
+Uint8Array.prototype.__class__ = $hxClasses["js.html.compat.Uint8Array"] = Uint8Array;
+
+// Init
+
+var Uint8Array = $global.Uint8Array || Uint8Array._new;
+
+// Statics
+
+Uint8Array._new = function(arg1,offset,length) {
+	var arr;
+	if(typeof(arg1) == "number") {
+		arr = [];
+		var _g1 = 0;
+		var _g = arg1;
+		while(_g1 < _g) {
+			var i = _g1++;
+			arr[i] = 0;
+		}
+		arr.byteLength = arr.length;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(arr);
+	} else if((Std().default)["is"](arg1,(js_html_compat_ArrayBuffer().default))) {
+		var buffer = arg1;
+		if(offset == null) {
+			offset = 0;
+		}
+		if(length == null) {
+			length = buffer.byteLength - offset;
+		}
+		if(offset == 0) {
+			arr = buffer.a;
+		} else {
+			arr = buffer.a.slice(offset,offset + length);
+		}
+		arr.byteLength = arr.length;
+		arr.byteOffset = offset;
+		arr.buffer = buffer;
+	} else if((arg1 instanceof Array) && arg1.__enum__ == null) {
+		arr = arg1.slice();
+		arr.byteLength = arr.length;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(arr);
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO " + (Std().default).string(arg1));
+	}
+	arr.subarray = Uint8Array._subarray;
+	arr.set = Uint8Array._set;
+	return arr;
+}
+Uint8Array._set = function(arg,offset) {
+	if((Std().default)["is"](arg.buffer,(js_html_compat_ArrayBuffer().default))) {
+		var a = arg;
+		if(arg.byteLength + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g1 = 0;
+		var _g = arg.byteLength;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this[i + offset] = a[i];
+		}
+	} else if((arg instanceof Array) && arg.__enum__ == null) {
+		var a1 = arg;
+		if(a1.length + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g11 = 0;
+		var _g2 = a1.length;
+		while(_g11 < _g2) {
+			var i1 = _g11++;
+			this[i1 + offset] = a1[i1];
+		}
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO");
+	}
+}
+Uint8Array._subarray = function(start,end) {
+	var a = Uint8Array._new(this.slice(start,end));
+	a.byteOffset = start;
+	return a;
+}
+Uint8Array.BYTES_PER_ELEMENT = 1
+
+// Export
+
+exports.default = Uint8Array;