starling-framework/lib/_gen/starling/rendering/IndexData.js

A fast, productive library for 2D cross-platform development.

// Class: starling.rendering.IndexData

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 $hxEnums = require("./../../hxEnums_stub").default;
var $import = require("./../../import_stub").default;
function Std() {return require("./../../Std");}
function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
function openfl_errors_EOFError() {return $import(require("openfl/errors/EOFError"));}
function openfl__$Vector_Vector_$Impl_$() {return require("./../../openfl/_Vector/Vector_Impl_");}
function starling_utils_StringUtil() {return require("./../../starling/utils/StringUtil");}
function openfl_utils_ByteArray() {return $import(require("openfl/utils/ByteArray"));}
function starling_core_Starling() {return require("./../../starling/core/Starling");}
function starling_errors_MissingContextError() {return require("./../../starling/errors/MissingContextError");}

// Constructor

var IndexData = function(initialCapacity) {
	if(initialCapacity == null) {
		initialCapacity = 48;
	}
	this._numIndices = 0;
	this._initialCapacity = initialCapacity;
	this._useQuadLayout = true;
}

// Meta

IndexData.__name__ = "starling.rendering.IndexData";
IndexData.__isInterface__ = false;
IndexData.prototype = {
	clear: function() {
		if(this._rawData != null) {
			this._rawData.clear();
		}
		this._numIndices = 0;
		this._useQuadLayout = true;
	},
	clone: function() {
		var clone = new IndexData(this._numIndices);
		if(!this._useQuadLayout) {
			clone.switchToGenericData();
			clone._rawData.writeBytes(this._rawData);
		}
		clone._numIndices = this._numIndices;
		return clone;
	},
	copyTo: function(target,targetIndexID,offset,indexID,numIndices) {
		if(numIndices == null) {
			numIndices = -1;
		}
		if(indexID == null) {
			indexID = 0;
		}
		if(offset == null) {
			offset = 0;
		}
		if(targetIndexID == null) {
			targetIndexID = 0;
		}
		if(numIndices < 0 || indexID + numIndices > this._numIndices) {
			numIndices = this._numIndices - indexID;
		}
		var sourceData;
		var targetData;
		var newNumIndices = targetIndexID + numIndices;
		if(target._numIndices < newNumIndices) {
			target._numIndices = newNumIndices;
			if(IndexData.sQuadDataNumIndices < newNumIndices) {
				this.ensureQuadDataCapacity(newNumIndices);
			}
		}
		if(this._useQuadLayout) {
			if(target._useQuadLayout) {
				var keepsQuadLayout = true;
				var distance = targetIndexID - indexID;
				var distanceInQuads = (Std().default).int(distance / 6);
				var offsetInQuads = (Std().default).int(offset / 4);
				if(distanceInQuads == offsetInQuads && (offset & 3) == 0 && distanceInQuads * 6 == distance) {
					keepsQuadLayout = true;
				} else if(numIndices > 2) {
					keepsQuadLayout = false;
				} else {
					var _g = 0;
					var _g1 = numIndices;
					while(_g < _g1) {
						var i = _g++;
						keepsQuadLayout = keepsQuadLayout && IndexData.getBasicQuadIndexAt(indexID + i) + offset == IndexData.getBasicQuadIndexAt(targetIndexID + i);
					}
				}
				if(keepsQuadLayout) {
					return;
				} else {
					target.switchToGenericData();
				}
			}
			sourceData = IndexData.sQuadData;
			targetData = target._rawData;
			if((offset & 3) == 0) {
				indexID += (Std().default).int(6 * offset / 4);
				offset = 0;
				this.ensureQuadDataCapacity(indexID + numIndices);
			}
		} else {
			if(target._useQuadLayout) {
				target.switchToGenericData();
			}
			sourceData = this._rawData;
			targetData = target._rawData;
		}
		targetData.position = targetIndexID * 2;
		if(offset == 0) {
			targetData.writeBytes(sourceData,indexID * 2,numIndices * 2);
		} else {
			sourceData.position = indexID * 2;
			while(numIndices > 1) {
				var indexAB = sourceData.readUnsignedInt();
				var indexA = ((indexAB & -65536) >>> 16) + offset;
				var indexB = (indexAB & 65535) + offset;
				targetData.writeUnsignedInt(indexA << 16 | indexB);
				numIndices -= 2;
			}
			if(numIndices != 0) {
				targetData.writeShort(sourceData.readUnsignedShort() + offset);
			}
		}
	},
	setIndex: function(indexID,index) {
		if(this._numIndices < indexID + 1) {
			this.set_numIndices(indexID + 1);
		}
		if(this._useQuadLayout) {
			if(IndexData.getBasicQuadIndexAt(indexID) == index) {
				return;
			} else {
				this.switchToGenericData();
			}
		}
		this._rawData.position = indexID * 2;
		this._rawData.writeShort(index);
	},
	getIndex: function(indexID) {
		if(this._useQuadLayout) {
			if(indexID < this._numIndices) {
				return IndexData.getBasicQuadIndexAt(indexID);
			} else {
				throw new (js__$Boot_HaxeError().default)(new (openfl_errors_EOFError().default)());
			}
		} else {
			this._rawData.position = indexID * 2;
			return this._rawData.readUnsignedShort();
		}
	},
	offsetIndices: function(offset,indexID,numIndices) {
		if(numIndices == null) {
			numIndices = -1;
		}
		if(indexID == null) {
			indexID = 0;
		}
		if(numIndices < 0 || indexID + numIndices > this._numIndices) {
			numIndices = this._numIndices - indexID;
		}
		var endIndex = indexID + numIndices;
		var _g = indexID;
		var _g1 = endIndex;
		while(_g < _g1) {
			var i = _g++;
			this.setIndex(i,this.getIndex(i) + offset);
		}
	},
	addTriangle: function(a,b,c) {
		if(this._useQuadLayout) {
			if(a == IndexData.getBasicQuadIndexAt(this._numIndices)) {
				var oddTriangleID = (this._numIndices & 1) != 0;
				var evenTriangleID = !oddTriangleID;
				if(evenTriangleID && b == a + 1 && c == b + 1 || oddTriangleID && c == a + 1 && b == c + 1) {
					this._numIndices += 3;
					this.ensureQuadDataCapacity(this._numIndices);
					return;
				}
			}
			this.switchToGenericData();
		}
		this._rawData.position = this._numIndices * 2;
		this._rawData.writeShort(a);
		this._rawData.writeShort(b);
		this._rawData.writeShort(c);
		this._numIndices += 3;
	},
	addQuad: function(a,b,c,d) {
		if(this._useQuadLayout) {
			if(a == IndexData.getBasicQuadIndexAt(this._numIndices) && b == a + 1 && c == b + 1 && d == c + 1) {
				this._numIndices += 6;
				this.ensureQuadDataCapacity(this._numIndices);
				return;
			} else {
				this.switchToGenericData();
			}
		}
		this._rawData.position = this._numIndices * 2;
		this._rawData.writeShort(a);
		this._rawData.writeShort(b);
		this._rawData.writeShort(c);
		this._rawData.writeShort(b);
		this._rawData.writeShort(d);
		this._rawData.writeShort(c);
		this._numIndices += 6;
	},
	toVector: function(out) {
		if(out == null) {
			out = (openfl__$Vector_Vector_$Impl_$().default)._new(this._numIndices);
		} else {
			out.length = this._numIndices;
		}
		var rawData = this._useQuadLayout ? IndexData.sQuadData : this._rawData;
		rawData.position = 0;
		var _g = 0;
		var _g1 = this._numIndices;
		while(_g < _g1) {
			var i = _g++;
			(openfl__$Vector_Vector_$Impl_$().default).set(out,i,rawData.readUnsignedShort());
		}
		return out;
	},
	toString: function() {
		var string = this._numIndices;
		var this1 = this.toVector(IndexData.sVector);
		var string1 = (starling_utils_StringUtil().default).format("[IndexData numIndices={0} indices=\"{1}\"]",[string,(Array.prototype.join.call)(this1,",")]);
		IndexData.sVector.length = 0;
		return string1;
	},
	switchToGenericData: function() {
		if(this._useQuadLayout) {
			this._useQuadLayout = false;
			if(this._rawData == null) {
				this._rawData = new (openfl_utils_ByteArray().default)();
				this._rawData.set_endian("littleEndian");
				this._rawData.length = this._initialCapacity * 2;
				this._rawData.length = this._numIndices * 2;
			}
			if(this._numIndices != 0) {
				this._rawData.writeBytes(IndexData.sQuadData,0,this._numIndices * 2);
			}
		}
	},
	ensureQuadDataCapacity: function(numIndices) {
		if(IndexData.sQuadDataNumIndices >= numIndices) {
			return;
		}
		var i;
		var oldNumQuads = (Std().default).int(IndexData.sQuadDataNumIndices / 6);
		var newNumQuads = Math.ceil(numIndices / 6);
		IndexData.sQuadData.set_endian("littleEndian");
		IndexData.sQuadData.position = IndexData.sQuadData.length;
		IndexData.sQuadDataNumIndices = newNumQuads * 6;
		var _g = oldNumQuads;
		var _g1 = newNumQuads;
		while(_g < _g1) {
			var i1 = _g++;
			IndexData.sQuadData.writeShort(4 * i1);
			IndexData.sQuadData.writeShort(4 * i1 + 1);
			IndexData.sQuadData.writeShort(4 * i1 + 2);
			IndexData.sQuadData.writeShort(4 * i1 + 1);
			IndexData.sQuadData.writeShort(4 * i1 + 3);
			IndexData.sQuadData.writeShort(4 * i1 + 2);
		}
	},
	createIndexBuffer: function(upload,bufferUsage) {
		if(bufferUsage == null) {
			bufferUsage = "staticDraw";
		}
		if(upload == null) {
			upload = false;
		}
		var context = (starling_core_Starling().default).get_current().get_context();
		if(context == null) {
			throw new (js__$Boot_HaxeError().default)(new (starling_errors_MissingContextError().default)());
		}
		if(this._numIndices == 0) {
			return null;
		}
		var buffer = context.createIndexBuffer(this._numIndices,bufferUsage);
		if(upload) {
			this.uploadToIndexBuffer(buffer);
		}
		return buffer;
	},
	uploadToIndexBuffer: function(buffer,indexID,numIndices) {
		if(numIndices == null) {
			numIndices = -1;
		}
		if(indexID == null) {
			indexID = 0;
		}
		if(numIndices < 0 || indexID + numIndices > this._numIndices) {
			numIndices = this._numIndices - indexID;
		}
		if(numIndices > 0) {
			buffer.uploadFromByteArray(this.get_rawData(),0,indexID,numIndices);
		}
	},
	trim: function() {
		if(this._useQuadLayout) {
			return;
		}
		IndexData.sTrimData.length = this._rawData.length;
		IndexData.sTrimData.position = 0;
		IndexData.sTrimData.writeBytes(this._rawData);
		this._rawData.clear();
		this._rawData.length = IndexData.sTrimData.length;
		this._rawData.writeBytes(IndexData.sTrimData);
		IndexData.sTrimData.clear();
	},
	get_numIndices: function() {
		return this._numIndices;
	},
	set_numIndices: function(value) {
		if(value != this._numIndices) {
			if(this._useQuadLayout) {
				this.ensureQuadDataCapacity(value);
			} else {
				this._rawData.length = value * 2;
			}
			if(value == 0) {
				this._useQuadLayout = true;
			}
			this._numIndices = value;
		}
		return value;
	},
	get_numTriangles: function() {
		return (Std().default).int(this._numIndices / 3);
	},
	set_numTriangles: function(value) {
		return this.set_numIndices(value * 3);
	},
	get_numQuads: function() {
		return (Std().default).int(this._numIndices / 6);
	},
	set_numQuads: function(value) {
		return this.set_numIndices(value * 6);
	},
	get_indexSizeInBytes: function() {
		return 2;
	},
	get_useQuadLayout: function() {
		return this._useQuadLayout;
	},
	set_useQuadLayout: function(value) {
		if(value != this._useQuadLayout) {
			if(value) {
				this.ensureQuadDataCapacity(this._numIndices);
				this._rawData.length = 0;
				this._useQuadLayout = true;
			} else {
				this.switchToGenericData();
			}
		}
		return value;
	},
	get_rawData: function() {
		if(this._useQuadLayout) {
			return IndexData.sQuadData;
		} else {
			return this._rawData;
		}
	}
};
IndexData.prototype.__class__ = IndexData.prototype.constructor = $hxClasses["starling.rendering.IndexData"] = IndexData;

// Init

Object.defineProperties(IndexData.prototype,{ numIndices : { get : function () { return this.get_numIndices (); }, set : function (v) { return this.set_numIndices (v); }}, numTriangles : { get : function () { return this.get_numTriangles (); }, set : function (v) { return this.set_numTriangles (v); }}, numQuads : { get : function () { return this.get_numQuads (); }, set : function (v) { return this.set_numQuads (v); }}, indexSizeInBytes : { get : function () { return this.get_indexSizeInBytes (); }}, useQuadLayout : { get : function () { return this.get_useQuadLayout (); }, set : function (v) { return this.set_useQuadLayout (v); }}, rawData : { get : function () { return this.get_rawData (); }}});

// Statics

IndexData.getBasicQuadIndexAt = function(indexID) {
	var quadID = (Std().default).int(indexID / 6);
	var posInQuad = (Std().default).int(indexID - quadID * 6);
	var offset;
	if(posInQuad == 0) {
		offset = 0;
	} else if(posInQuad == 1 || posInQuad == 3) {
		offset = 1;
	} else if(posInQuad == 2 || posInQuad == 5) {
		offset = 2;
	} else {
		offset = 3;
	}
	return quadID * 4 + offset;
}
IndexData.INDEX_SIZE = 2
IndexData.sQuadData = new (openfl_utils_ByteArray().default)()
IndexData.sQuadDataNumIndices = 0
IndexData.sVector = (openfl__$Vector_Vector_$Impl_$().default)._new()
IndexData.sTrimData = new (openfl_utils_ByteArray().default)()

// Export

exports.default = IndexData;