osh-js
Version:
OSH javascript Toolkit
1,450 lines (1,449 loc) • 1.38 MB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var _a;
/**
* @license
* Copyright 2010-2021 Three.js Authors
* SPDX-License-Identifier: MIT
*/
var REVISION = '128';
var MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
var TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };
var CullFaceNone = 0;
var CullFaceBack = 1;
var CullFaceFront = 2;
var CullFaceFrontBack = 3;
var BasicShadowMap = 0;
var PCFShadowMap = 1;
var PCFSoftShadowMap = 2;
var VSMShadowMap = 3;
var FrontSide = 0;
var BackSide = 1;
var DoubleSide = 2;
var FlatShading = 1;
var SmoothShading = 2;
var NoBlending = 0;
var NormalBlending = 1;
var AdditiveBlending = 2;
var SubtractiveBlending = 3;
var MultiplyBlending = 4;
var CustomBlending = 5;
var AddEquation = 100;
var SubtractEquation = 101;
var ReverseSubtractEquation = 102;
var MinEquation = 103;
var MaxEquation = 104;
var ZeroFactor = 200;
var OneFactor = 201;
var SrcColorFactor = 202;
var OneMinusSrcColorFactor = 203;
var SrcAlphaFactor = 204;
var OneMinusSrcAlphaFactor = 205;
var DstAlphaFactor = 206;
var OneMinusDstAlphaFactor = 207;
var DstColorFactor = 208;
var OneMinusDstColorFactor = 209;
var SrcAlphaSaturateFactor = 210;
var NeverDepth = 0;
var AlwaysDepth = 1;
var LessDepth = 2;
var LessEqualDepth = 3;
var EqualDepth = 4;
var GreaterEqualDepth = 5;
var GreaterDepth = 6;
var NotEqualDepth = 7;
var MultiplyOperation = 0;
var MixOperation = 1;
var AddOperation = 2;
var NoToneMapping = 0;
var LinearToneMapping = 1;
var ReinhardToneMapping = 2;
var CineonToneMapping = 3;
var ACESFilmicToneMapping = 4;
var CustomToneMapping = 5;
var UVMapping = 300;
var CubeReflectionMapping = 301;
var CubeRefractionMapping = 302;
var EquirectangularReflectionMapping = 303;
var EquirectangularRefractionMapping = 304;
var CubeUVReflectionMapping = 306;
var CubeUVRefractionMapping = 307;
var RepeatWrapping = 1000;
var ClampToEdgeWrapping = 1001;
var MirroredRepeatWrapping = 1002;
var NearestFilter = 1003;
var NearestMipmapNearestFilter = 1004;
var NearestMipMapNearestFilter = 1004;
var NearestMipmapLinearFilter = 1005;
var NearestMipMapLinearFilter = 1005;
var LinearFilter = 1006;
var LinearMipmapNearestFilter = 1007;
var LinearMipMapNearestFilter = 1007;
var LinearMipmapLinearFilter = 1008;
var LinearMipMapLinearFilter = 1008;
var UnsignedByteType = 1009;
var ByteType = 1010;
var ShortType = 1011;
var UnsignedShortType = 1012;
var IntType = 1013;
var UnsignedIntType = 1014;
var FloatType = 1015;
var HalfFloatType = 1016;
var UnsignedShort4444Type = 1017;
var UnsignedShort5551Type = 1018;
var UnsignedShort565Type = 1019;
var UnsignedInt248Type = 1020;
var AlphaFormat = 1021;
var RGBFormat = 1022;
var RGBAFormat = 1023;
var LuminanceFormat = 1024;
var LuminanceAlphaFormat = 1025;
var RGBEFormat = RGBAFormat;
var DepthFormat = 1026;
var DepthStencilFormat = 1027;
var RedFormat = 1028;
var RedIntegerFormat = 1029;
var RGFormat = 1030;
var RGIntegerFormat = 1031;
var RGBIntegerFormat = 1032;
var RGBAIntegerFormat = 1033;
var RGB_S3TC_DXT1_Format = 33776;
var RGBA_S3TC_DXT1_Format = 33777;
var RGBA_S3TC_DXT3_Format = 33778;
var RGBA_S3TC_DXT5_Format = 33779;
var RGB_PVRTC_4BPPV1_Format = 35840;
var RGB_PVRTC_2BPPV1_Format = 35841;
var RGBA_PVRTC_4BPPV1_Format = 35842;
var RGBA_PVRTC_2BPPV1_Format = 35843;
var RGB_ETC1_Format = 36196;
var RGB_ETC2_Format = 37492;
var RGBA_ETC2_EAC_Format = 37496;
var RGBA_ASTC_4x4_Format = 37808;
var RGBA_ASTC_5x4_Format = 37809;
var RGBA_ASTC_5x5_Format = 37810;
var RGBA_ASTC_6x5_Format = 37811;
var RGBA_ASTC_6x6_Format = 37812;
var RGBA_ASTC_8x5_Format = 37813;
var RGBA_ASTC_8x6_Format = 37814;
var RGBA_ASTC_8x8_Format = 37815;
var RGBA_ASTC_10x5_Format = 37816;
var RGBA_ASTC_10x6_Format = 37817;
var RGBA_ASTC_10x8_Format = 37818;
var RGBA_ASTC_10x10_Format = 37819;
var RGBA_ASTC_12x10_Format = 37820;
var RGBA_ASTC_12x12_Format = 37821;
var RGBA_BPTC_Format = 36492;
var SRGB8_ALPHA8_ASTC_4x4_Format = 37840;
var SRGB8_ALPHA8_ASTC_5x4_Format = 37841;
var SRGB8_ALPHA8_ASTC_5x5_Format = 37842;
var SRGB8_ALPHA8_ASTC_6x5_Format = 37843;
var SRGB8_ALPHA8_ASTC_6x6_Format = 37844;
var SRGB8_ALPHA8_ASTC_8x5_Format = 37845;
var SRGB8_ALPHA8_ASTC_8x6_Format = 37846;
var SRGB8_ALPHA8_ASTC_8x8_Format = 37847;
var SRGB8_ALPHA8_ASTC_10x5_Format = 37848;
var SRGB8_ALPHA8_ASTC_10x6_Format = 37849;
var SRGB8_ALPHA8_ASTC_10x8_Format = 37850;
var SRGB8_ALPHA8_ASTC_10x10_Format = 37851;
var SRGB8_ALPHA8_ASTC_12x10_Format = 37852;
var SRGB8_ALPHA8_ASTC_12x12_Format = 37853;
var LoopOnce = 2200;
var LoopRepeat = 2201;
var LoopPingPong = 2202;
var InterpolateDiscrete = 2300;
var InterpolateLinear = 2301;
var InterpolateSmooth = 2302;
var ZeroCurvatureEnding = 2400;
var ZeroSlopeEnding = 2401;
var WrapAroundEnding = 2402;
var NormalAnimationBlendMode = 2500;
var AdditiveAnimationBlendMode = 2501;
var TrianglesDrawMode = 0;
var TriangleStripDrawMode = 1;
var TriangleFanDrawMode = 2;
var LinearEncoding = 3000;
var sRGBEncoding = 3001;
var GammaEncoding = 3007;
var RGBEEncoding = 3002;
var LogLuvEncoding = 3003;
var RGBM7Encoding = 3004;
var RGBM16Encoding = 3005;
var RGBDEncoding = 3006;
var BasicDepthPacking = 3200;
var RGBADepthPacking = 3201;
var TangentSpaceNormalMap = 0;
var ObjectSpaceNormalMap = 1;
var ZeroStencilOp = 0;
var KeepStencilOp = 7680;
var ReplaceStencilOp = 7681;
var IncrementStencilOp = 7682;
var DecrementStencilOp = 7683;
var IncrementWrapStencilOp = 34055;
var DecrementWrapStencilOp = 34056;
var InvertStencilOp = 5386;
var NeverStencilFunc = 512;
var LessStencilFunc = 513;
var EqualStencilFunc = 514;
var LessEqualStencilFunc = 515;
var GreaterStencilFunc = 516;
var NotEqualStencilFunc = 517;
var GreaterEqualStencilFunc = 518;
var AlwaysStencilFunc = 519;
var StaticDrawUsage = 35044;
var DynamicDrawUsage = 35048;
var StreamDrawUsage = 35040;
var StaticReadUsage = 35045;
var DynamicReadUsage = 35049;
var StreamReadUsage = 35041;
var StaticCopyUsage = 35046;
var DynamicCopyUsage = 35050;
var StreamCopyUsage = 35042;
var GLSL1 = '100';
var GLSL3 = '300 es';
/**
* https://github.com/mrdoob/eventdispatcher.js/
*/
var EventDispatcher = /** @class */ (function () {
function EventDispatcher() {
}
EventDispatcher.prototype.addEventListener = function (type, listener) {
if (this._listeners === undefined)
this._listeners = {};
var listeners = this._listeners;
if (listeners[type] === undefined) {
listeners[type] = [];
}
if (listeners[type].indexOf(listener) === -1) {
listeners[type].push(listener);
}
};
EventDispatcher.prototype.hasEventListener = function (type, listener) {
if (this._listeners === undefined)
return false;
var listeners = this._listeners;
return listeners[type] !== undefined && listeners[type].indexOf(listener) !== -1;
};
EventDispatcher.prototype.removeEventListener = function (type, listener) {
if (this._listeners === undefined)
return;
var listeners = this._listeners;
var listenerArray = listeners[type];
if (listenerArray !== undefined) {
var index = listenerArray.indexOf(listener);
if (index !== -1) {
listenerArray.splice(index, 1);
}
}
};
EventDispatcher.prototype.dispatchEvent = function (event) {
if (this._listeners === undefined)
return;
var listeners = this._listeners;
var listenerArray = listeners[event.type];
if (listenerArray !== undefined) {
event.target = this;
// Make a copy, in case listeners are removed while iterating.
var array = listenerArray.slice(0);
for (var i = 0, l = array.length; i < l; i++) {
array[i].call(this, event);
}
event.target = null;
}
};
return EventDispatcher;
}());
var _lut = [];
for (var i = 0; i < 256; i++) {
_lut[i] = (i < 16 ? '0' : '') + (i).toString(16);
}
var _seed = 1234567;
var DEG2RAD = Math.PI / 180;
var RAD2DEG = 180 / Math.PI;
// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
function generateUUID() {
var d0 = Math.random() * 0xffffffff | 0;
var d1 = Math.random() * 0xffffffff | 0;
var d2 = Math.random() * 0xffffffff | 0;
var d3 = Math.random() * 0xffffffff | 0;
var uuid = _lut[d0 & 0xff] + _lut[d0 >> 8 & 0xff] + _lut[d0 >> 16 & 0xff] + _lut[d0 >> 24 & 0xff] + '-' +
_lut[d1 & 0xff] + _lut[d1 >> 8 & 0xff] + '-' + _lut[d1 >> 16 & 0x0f | 0x40] + _lut[d1 >> 24 & 0xff] + '-' +
_lut[d2 & 0x3f | 0x80] + _lut[d2 >> 8 & 0xff] + '-' + _lut[d2 >> 16 & 0xff] + _lut[d2 >> 24 & 0xff] +
_lut[d3 & 0xff] + _lut[d3 >> 8 & 0xff] + _lut[d3 >> 16 & 0xff] + _lut[d3 >> 24 & 0xff];
// .toUpperCase() here flattens concatenated strings to save heap memory space.
return uuid.toUpperCase();
}
function clamp(value, min, max) {
return Math.max(min, Math.min(max, value));
}
// compute euclidian modulo of m % n
// https://en.wikipedia.org/wiki/Modulo_operation
function euclideanModulo(n, m) {
return ((n % m) + m) % m;
}
// Linear mapping from range <a1, a2> to range <b1, b2>
function mapLinear(x, a1, a2, b1, b2) {
return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
}
// https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
function inverseLerp(x, y, value) {
if (x !== y) {
return (value - x) / (y - x);
}
else {
return 0;
}
}
// https://en.wikipedia.org/wiki/Linear_interpolation
function lerp(x, y, t) {
return (1 - t) * x + t * y;
}
// http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
function damp(x, y, lambda, dt) {
return lerp(x, y, 1 - Math.exp(-lambda * dt));
}
// https://www.desmos.com/calculator/vcsjnyz7x4
function pingpong(x, length) {
if (length === void 0) { length = 1; }
return length - Math.abs(euclideanModulo(x, length * 2) - length);
}
// http://en.wikipedia.org/wiki/Smoothstep
function smoothstep(x, min, max) {
if (x <= min)
return 0;
if (x >= max)
return 1;
x = (x - min) / (max - min);
return x * x * (3 - 2 * x);
}
function smootherstep(x, min, max) {
if (x <= min)
return 0;
if (x >= max)
return 1;
x = (x - min) / (max - min);
return x * x * x * (x * (x * 6 - 15) + 10);
}
// Random integer from <low, high> interval
function randInt(low, high) {
return low + Math.floor(Math.random() * (high - low + 1));
}
// Random float from <low, high> interval
function randFloat(low, high) {
return low + Math.random() * (high - low);
}
// Random float from <-range/2, range/2> interval
function randFloatSpread(range) {
return range * (0.5 - Math.random());
}
// Deterministic pseudo-random float in the interval [ 0, 1 ]
function seededRandom(s) {
if (s !== undefined)
_seed = s % 2147483647;
// Park-Miller algorithm
_seed = _seed * 16807 % 2147483647;
return (_seed - 1) / 2147483646;
}
function degToRad(degrees) {
return degrees * DEG2RAD;
}
function radToDeg(radians) {
return radians * RAD2DEG;
}
function isPowerOfTwo(value) {
return (value & (value - 1)) === 0 && value !== 0;
}
function ceilPowerOfTwo(value) {
return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2));
}
function floorPowerOfTwo(value) {
return Math.pow(2, Math.floor(Math.log(value) / Math.LN2));
}
function setQuaternionFromProperEuler(q, a, b, c, order) {
// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
// rotations are applied to the axes in the order specified by 'order'
// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
// angles are in radians
var cos = Math.cos;
var sin = Math.sin;
var c2 = cos(b / 2);
var s2 = sin(b / 2);
var c13 = cos((a + c) / 2);
var s13 = sin((a + c) / 2);
var c1_3 = cos((a - c) / 2);
var s1_3 = sin((a - c) / 2);
var c3_1 = cos((c - a) / 2);
var s3_1 = sin((c - a) / 2);
switch (order) {
case 'XYX':
q.set(c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13);
break;
case 'YZY':
q.set(s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13);
break;
case 'ZXZ':
q.set(s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13);
break;
case 'XZX':
q.set(c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13);
break;
case 'YXY':
q.set(s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13);
break;
case 'ZYZ':
q.set(s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13);
break;
default:
console.warn('THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order);
}
}
var MathUtils = /*#__PURE__*/ Object.freeze({
__proto__: null,
DEG2RAD: DEG2RAD,
RAD2DEG: RAD2DEG,
generateUUID: generateUUID,
clamp: clamp,
euclideanModulo: euclideanModulo,
mapLinear: mapLinear,
inverseLerp: inverseLerp,
lerp: lerp,
damp: damp,
pingpong: pingpong,
smoothstep: smoothstep,
smootherstep: smootherstep,
randInt: randInt,
randFloat: randFloat,
randFloatSpread: randFloatSpread,
seededRandom: seededRandom,
degToRad: degToRad,
radToDeg: radToDeg,
isPowerOfTwo: isPowerOfTwo,
ceilPowerOfTwo: ceilPowerOfTwo,
floorPowerOfTwo: floorPowerOfTwo,
setQuaternionFromProperEuler: setQuaternionFromProperEuler
});
var Vector2 = /** @class */ (function () {
function Vector2(x, y) {
if (x === void 0) { x = 0; }
if (y === void 0) { y = 0; }
this.x = x;
this.y = y;
}
Object.defineProperty(Vector2.prototype, "width", {
get: function () {
return this.x;
},
set: function (value) {
this.x = value;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Vector2.prototype, "height", {
get: function () {
return this.y;
},
set: function (value) {
this.y = value;
},
enumerable: false,
configurable: true
});
Vector2.prototype.set = function (x, y) {
this.x = x;
this.y = y;
return this;
};
Vector2.prototype.setScalar = function (scalar) {
this.x = scalar;
this.y = scalar;
return this;
};
Vector2.prototype.setX = function (x) {
this.x = x;
return this;
};
Vector2.prototype.setY = function (y) {
this.y = y;
return this;
};
Vector2.prototype.setComponent = function (index, value) {
switch (index) {
case 0:
this.x = value;
break;
case 1:
this.y = value;
break;
default: throw new Error('index is out of range: ' + index);
}
return this;
};
Vector2.prototype.getComponent = function (index) {
switch (index) {
case 0: return this.x;
case 1: return this.y;
default: throw new Error('index is out of range: ' + index);
}
};
Vector2.prototype.clone = function () {
return new this.constructor(this.x, this.y);
};
Vector2.prototype.copy = function (v) {
this.x = v.x;
this.y = v.y;
return this;
};
Vector2.prototype.add = function (v, w) {
if (w !== undefined) {
console.warn('THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
return this.addVectors(v, w);
}
this.x += v.x;
this.y += v.y;
return this;
};
Vector2.prototype.addScalar = function (s) {
this.x += s;
this.y += s;
return this;
};
Vector2.prototype.addVectors = function (a, b) {
this.x = a.x + b.x;
this.y = a.y + b.y;
return this;
};
Vector2.prototype.addScaledVector = function (v, s) {
this.x += v.x * s;
this.y += v.y * s;
return this;
};
Vector2.prototype.sub = function (v, w) {
if (w !== undefined) {
console.warn('THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
return this.subVectors(v, w);
}
this.x -= v.x;
this.y -= v.y;
return this;
};
Vector2.prototype.subScalar = function (s) {
this.x -= s;
this.y -= s;
return this;
};
Vector2.prototype.subVectors = function (a, b) {
this.x = a.x - b.x;
this.y = a.y - b.y;
return this;
};
Vector2.prototype.multiply = function (v) {
this.x *= v.x;
this.y *= v.y;
return this;
};
Vector2.prototype.multiplyScalar = function (scalar) {
this.x *= scalar;
this.y *= scalar;
return this;
};
Vector2.prototype.divide = function (v) {
this.x /= v.x;
this.y /= v.y;
return this;
};
Vector2.prototype.divideScalar = function (scalar) {
return this.multiplyScalar(1 / scalar);
};
Vector2.prototype.applyMatrix3 = function (m) {
var x = this.x, y = this.y;
var e = m.elements;
this.x = e[0] * x + e[3] * y + e[6];
this.y = e[1] * x + e[4] * y + e[7];
return this;
};
Vector2.prototype.min = function (v) {
this.x = Math.min(this.x, v.x);
this.y = Math.min(this.y, v.y);
return this;
};
Vector2.prototype.max = function (v) {
this.x = Math.max(this.x, v.x);
this.y = Math.max(this.y, v.y);
return this;
};
Vector2.prototype.clamp = function (min, max) {
// assumes min < max, componentwise
this.x = Math.max(min.x, Math.min(max.x, this.x));
this.y = Math.max(min.y, Math.min(max.y, this.y));
return this;
};
Vector2.prototype.clampScalar = function (minVal, maxVal) {
this.x = Math.max(minVal, Math.min(maxVal, this.x));
this.y = Math.max(minVal, Math.min(maxVal, this.y));
return this;
};
Vector2.prototype.clampLength = function (min, max) {
var length = this.length();
return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
};
Vector2.prototype.floor = function () {
this.x = Math.floor(this.x);
this.y = Math.floor(this.y);
return this;
};
Vector2.prototype.ceil = function () {
this.x = Math.ceil(this.x);
this.y = Math.ceil(this.y);
return this;
};
Vector2.prototype.round = function () {
this.x = Math.round(this.x);
this.y = Math.round(this.y);
return this;
};
Vector2.prototype.roundToZero = function () {
this.x = (this.x < 0) ? Math.ceil(this.x) : Math.floor(this.x);
this.y = (this.y < 0) ? Math.ceil(this.y) : Math.floor(this.y);
return this;
};
Vector2.prototype.negate = function () {
this.x = -this.x;
this.y = -this.y;
return this;
};
Vector2.prototype.dot = function (v) {
return this.x * v.x + this.y * v.y;
};
Vector2.prototype.cross = function (v) {
return this.x * v.y - this.y * v.x;
};
Vector2.prototype.lengthSq = function () {
return this.x * this.x + this.y * this.y;
};
Vector2.prototype.length = function () {
return Math.sqrt(this.x * this.x + this.y * this.y);
};
Vector2.prototype.manhattanLength = function () {
return Math.abs(this.x) + Math.abs(this.y);
};
Vector2.prototype.normalize = function () {
return this.divideScalar(this.length() || 1);
};
Vector2.prototype.angle = function () {
// computes the angle in radians with respect to the positive x-axis
var angle = Math.atan2(-this.y, -this.x) + Math.PI;
return angle;
};
Vector2.prototype.distanceTo = function (v) {
return Math.sqrt(this.distanceToSquared(v));
};
Vector2.prototype.distanceToSquared = function (v) {
var dx = this.x - v.x, dy = this.y - v.y;
return dx * dx + dy * dy;
};
Vector2.prototype.manhattanDistanceTo = function (v) {
return Math.abs(this.x - v.x) + Math.abs(this.y - v.y);
};
Vector2.prototype.setLength = function (length) {
return this.normalize().multiplyScalar(length);
};
Vector2.prototype.lerp = function (v, alpha) {
this.x += (v.x - this.x) * alpha;
this.y += (v.y - this.y) * alpha;
return this;
};
Vector2.prototype.lerpVectors = function (v1, v2, alpha) {
this.x = v1.x + (v2.x - v1.x) * alpha;
this.y = v1.y + (v2.y - v1.y) * alpha;
return this;
};
Vector2.prototype.equals = function (v) {
return ((v.x === this.x) && (v.y === this.y));
};
Vector2.prototype.fromArray = function (array, offset) {
if (offset === void 0) { offset = 0; }
this.x = array[offset];
this.y = array[offset + 1];
return this;
};
Vector2.prototype.toArray = function (array, offset) {
if (array === void 0) { array = []; }
if (offset === void 0) { offset = 0; }
array[offset] = this.x;
array[offset + 1] = this.y;
return array;
};
Vector2.prototype.fromBufferAttribute = function (attribute, index, offset) {
if (offset !== undefined) {
console.warn('THREE.Vector2: offset has been removed from .fromBufferAttribute().');
}
this.x = attribute.getX(index);
this.y = attribute.getY(index);
return this;
};
Vector2.prototype.rotateAround = function (center, angle) {
var c = Math.cos(angle), s = Math.sin(angle);
var x = this.x - center.x;
var y = this.y - center.y;
this.x = x * c - y * s + center.x;
this.y = x * s + y * c + center.y;
return this;
};
Vector2.prototype.random = function () {
this.x = Math.random();
this.y = Math.random();
return this;
};
return Vector2;
}());
Vector2.prototype.isVector2 = true;
var Matrix3 = /** @class */ (function () {
function Matrix3() {
this.elements = [
1, 0, 0,
0, 1, 0,
0, 0, 1
];
if (arguments.length > 0) {
console.error('THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.');
}
}
Matrix3.prototype.set = function (n11, n12, n13, n21, n22, n23, n31, n32, n33) {
var te = this.elements;
te[0] = n11;
te[1] = n21;
te[2] = n31;
te[3] = n12;
te[4] = n22;
te[5] = n32;
te[6] = n13;
te[7] = n23;
te[8] = n33;
return this;
};
Matrix3.prototype.identity = function () {
this.set(1, 0, 0, 0, 1, 0, 0, 0, 1);
return this;
};
Matrix3.prototype.copy = function (m) {
var te = this.elements;
var me = m.elements;
te[0] = me[0];
te[1] = me[1];
te[2] = me[2];
te[3] = me[3];
te[4] = me[4];
te[5] = me[5];
te[6] = me[6];
te[7] = me[7];
te[8] = me[8];
return this;
};
Matrix3.prototype.extractBasis = function (xAxis, yAxis, zAxis) {
xAxis.setFromMatrix3Column(this, 0);
yAxis.setFromMatrix3Column(this, 1);
zAxis.setFromMatrix3Column(this, 2);
return this;
};
Matrix3.prototype.setFromMatrix4 = function (m) {
var me = m.elements;
this.set(me[0], me[4], me[8], me[1], me[5], me[9], me[2], me[6], me[10]);
return this;
};
Matrix3.prototype.multiply = function (m) {
return this.multiplyMatrices(this, m);
};
Matrix3.prototype.premultiply = function (m) {
return this.multiplyMatrices(m, this);
};
Matrix3.prototype.multiplyMatrices = function (a, b) {
var ae = a.elements;
var be = b.elements;
var te = this.elements;
var a11 = ae[0], a12 = ae[3], a13 = ae[6];
var a21 = ae[1], a22 = ae[4], a23 = ae[7];
var a31 = ae[2], a32 = ae[5], a33 = ae[8];
var b11 = be[0], b12 = be[3], b13 = be[6];
var b21 = be[1], b22 = be[4], b23 = be[7];
var b31 = be[2], b32 = be[5], b33 = be[8];
te[0] = a11 * b11 + a12 * b21 + a13 * b31;
te[3] = a11 * b12 + a12 * b22 + a13 * b32;
te[6] = a11 * b13 + a12 * b23 + a13 * b33;
te[1] = a21 * b11 + a22 * b21 + a23 * b31;
te[4] = a21 * b12 + a22 * b22 + a23 * b32;
te[7] = a21 * b13 + a22 * b23 + a23 * b33;
te[2] = a31 * b11 + a32 * b21 + a33 * b31;
te[5] = a31 * b12 + a32 * b22 + a33 * b32;
te[8] = a31 * b13 + a32 * b23 + a33 * b33;
return this;
};
Matrix3.prototype.multiplyScalar = function (s) {
var te = this.elements;
te[0] *= s;
te[3] *= s;
te[6] *= s;
te[1] *= s;
te[4] *= s;
te[7] *= s;
te[2] *= s;
te[5] *= s;
te[8] *= s;
return this;
};
Matrix3.prototype.determinant = function () {
var te = this.elements;
var a = te[0], b = te[1], c = te[2], d = te[3], e = te[4], f = te[5], g = te[6], h = te[7], i = te[8];
return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
};
Matrix3.prototype.invert = function () {
var te = this.elements, n11 = te[0], n21 = te[1], n31 = te[2], n12 = te[3], n22 = te[4], n32 = te[5], n13 = te[6], n23 = te[7], n33 = te[8], t11 = n33 * n22 - n32 * n23, t12 = n32 * n13 - n33 * n12, t13 = n23 * n12 - n22 * n13, det = n11 * t11 + n21 * t12 + n31 * t13;
if (det === 0)
return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
var detInv = 1 / det;
te[0] = t11 * detInv;
te[1] = (n31 * n23 - n33 * n21) * detInv;
te[2] = (n32 * n21 - n31 * n22) * detInv;
te[3] = t12 * detInv;
te[4] = (n33 * n11 - n31 * n13) * detInv;
te[5] = (n31 * n12 - n32 * n11) * detInv;
te[6] = t13 * detInv;
te[7] = (n21 * n13 - n23 * n11) * detInv;
te[8] = (n22 * n11 - n21 * n12) * detInv;
return this;
};
Matrix3.prototype.transpose = function () {
var tmp;
var m = this.elements;
tmp = m[1];
m[1] = m[3];
m[3] = tmp;
tmp = m[2];
m[2] = m[6];
m[6] = tmp;
tmp = m[5];
m[5] = m[7];
m[7] = tmp;
return this;
};
Matrix3.prototype.getNormalMatrix = function (matrix4) {
return this.setFromMatrix4(matrix4).invert().transpose();
};
Matrix3.prototype.transposeIntoArray = function (r) {
var m = this.elements;
r[0] = m[0];
r[1] = m[3];
r[2] = m[6];
r[3] = m[1];
r[4] = m[4];
r[5] = m[7];
r[6] = m[2];
r[7] = m[5];
r[8] = m[8];
return this;
};
Matrix3.prototype.setUvTransform = function (tx, ty, sx, sy, rotation, cx, cy) {
var c = Math.cos(rotation);
var s = Math.sin(rotation);
this.set(sx * c, sx * s, -sx * (c * cx + s * cy) + cx + tx, -sy * s, sy * c, -sy * (-s * cx + c * cy) + cy + ty, 0, 0, 1);
return this;
};
Matrix3.prototype.scale = function (sx, sy) {
var te = this.elements;
te[0] *= sx;
te[3] *= sx;
te[6] *= sx;
te[1] *= sy;
te[4] *= sy;
te[7] *= sy;
return this;
};
Matrix3.prototype.rotate = function (theta) {
var c = Math.cos(theta);
var s = Math.sin(theta);
var te = this.elements;
var a11 = te[0], a12 = te[3], a13 = te[6];
var a21 = te[1], a22 = te[4], a23 = te[7];
te[0] = c * a11 + s * a21;
te[3] = c * a12 + s * a22;
te[6] = c * a13 + s * a23;
te[1] = -s * a11 + c * a21;
te[4] = -s * a12 + c * a22;
te[7] = -s * a13 + c * a23;
return this;
};
Matrix3.prototype.translate = function (tx, ty) {
var te = this.elements;
te[0] += tx * te[2];
te[3] += tx * te[5];
te[6] += tx * te[8];
te[1] += ty * te[2];
te[4] += ty * te[5];
te[7] += ty * te[8];
return this;
};
Matrix3.prototype.equals = function (matrix) {
var te = this.elements;
var me = matrix.elements;
for (var i = 0; i < 9; i++) {
if (te[i] !== me[i])
return false;
}
return true;
};
Matrix3.prototype.fromArray = function (array, offset) {
if (offset === void 0) { offset = 0; }
for (var i = 0; i < 9; i++) {
this.elements[i] = array[i + offset];
}
return this;
};
Matrix3.prototype.toArray = function (array, offset) {
if (array === void 0) { array = []; }
if (offset === void 0) { offset = 0; }
var te = this.elements;
array[offset] = te[0];
array[offset + 1] = te[1];
array[offset + 2] = te[2];
array[offset + 3] = te[3];
array[offset + 4] = te[4];
array[offset + 5] = te[5];
array[offset + 6] = te[6];
array[offset + 7] = te[7];
array[offset + 8] = te[8];
return array;
};
Matrix3.prototype.clone = function () {
return new this.constructor().fromArray(this.elements);
};
return Matrix3;
}());
Matrix3.prototype.isMatrix3 = true;
var _canvas;
var ImageUtils = /** @class */ (function () {
function ImageUtils() {
}
ImageUtils.getDataURL = function (image) {
if (/^data:/i.test(image.src)) {
return image.src;
}
if (typeof HTMLCanvasElement == 'undefined') {
return image.src;
}
var canvas;
if (image instanceof HTMLCanvasElement) {
canvas = image;
}
else {
if (_canvas === undefined)
_canvas = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas');
_canvas.width = image.width;
_canvas.height = image.height;
var context = _canvas.getContext('2d');
if (image instanceof ImageData) {
context.putImageData(image, 0, 0);
}
else {
context.drawImage(image, 0, 0, image.width, image.height);
}
canvas = _canvas;
}
if (canvas.width > 2048 || canvas.height > 2048) {
console.warn('THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image);
return canvas.toDataURL('image/jpeg', 0.6);
}
else {
return canvas.toDataURL('image/png');
}
};
return ImageUtils;
}());
var textureId = 0;
var Texture = /** @class */ (function (_super) {
__extends(Texture, _super);
function Texture(image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding) {
if (image === void 0) { image = Texture.DEFAULT_IMAGE; }
if (mapping === void 0) { mapping = Texture.DEFAULT_MAPPING; }
if (wrapS === void 0) { wrapS = ClampToEdgeWrapping; }
if (wrapT === void 0) { wrapT = ClampToEdgeWrapping; }
if (magFilter === void 0) { magFilter = LinearFilter; }
if (minFilter === void 0) { minFilter = LinearMipmapLinearFilter; }
if (format === void 0) { format = RGBAFormat; }
if (type === void 0) { type = UnsignedByteType; }
if (anisotropy === void 0) { anisotropy = 1; }
if (encoding === void 0) { encoding = LinearEncoding; }
var _this_1 = _super.call(this) || this;
Object.defineProperty(_this_1, 'id', { value: textureId++ });
_this_1.uuid = generateUUID();
_this_1.name = '';
_this_1.image = image;
_this_1.mipmaps = [];
_this_1.mapping = mapping;
_this_1.wrapS = wrapS;
_this_1.wrapT = wrapT;
_this_1.magFilter = magFilter;
_this_1.minFilter = minFilter;
_this_1.anisotropy = anisotropy;
_this_1.format = format;
_this_1.internalFormat = null;
_this_1.type = type;
_this_1.offset = new Vector2(0, 0);
_this_1.repeat = new Vector2(1, 1);
_this_1.center = new Vector2(0, 0);
_this_1.rotation = 0;
_this_1.matrixAutoUpdate = true;
_this_1.matrix = new Matrix3();
_this_1.generateMipmaps = true;
_this_1.premultiplyAlpha = false;
_this_1.flipY = true;
_this_1.unpackAlignment = 4; // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
// Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
//
// Also changing the encoding after already used by a Material will not automatically make the Material
// update. You need to explicitly call Material.needsUpdate to trigger it to recompile.
_this_1.encoding = encoding;
_this_1.version = 0;
_this_1.onUpdate = null;
return _this_1;
}
Texture.prototype.updateMatrix = function () {
this.matrix.setUvTransform(this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y);
};
Texture.prototype.clone = function () {
return new this.constructor().copy(this);
};
Texture.prototype.copy = function (source) {
this.name = source.name;
this.image = source.image;
this.mipmaps = source.mipmaps.slice(0);
this.mapping = source.mapping;
this.wrapS = source.wrapS;
this.wrapT = source.wrapT;
this.magFilter = source.magFilter;
this.minFilter = source.minFilter;
this.anisotropy = source.anisotropy;
this.format = source.format;
this.internalFormat = source.internalFormat;
this.type = source.type;
this.offset.copy(source.offset);
this.repeat.copy(source.repeat);
this.center.copy(source.center);
this.rotation = source.rotation;
this.matrixAutoUpdate = source.matrixAutoUpdate;
this.matrix.copy(source.matrix);
this.generateMipmaps = source.generateMipmaps;
this.premultiplyAlpha = source.premultiplyAlpha;
this.flipY = source.flipY;
this.unpackAlignment = source.unpackAlignment;
this.encoding = source.encoding;
return this;
};
Texture.prototype.toJSON = function (meta) {
var isRootObject = (meta === undefined || typeof meta === 'string');
if (!isRootObject && meta.textures[this.uuid] !== undefined) {
return meta.textures[this.uuid];
}
var output = {
metadata: {
version: 4.5,
type: 'Texture',
generator: 'Texture.toJSON'
},
uuid: this.uuid,
name: this.name,
mapping: this.mapping,
repeat: [this.repeat.x, this.repeat.y],
offset: [this.offset.x, this.offset.y],
center: [this.center.x, this.center.y],
rotation: this.rotation,
wrap: [this.wrapS, this.wrapT],
format: this.format,
type: this.type,
encoding: this.encoding,
minFilter: this.minFilter,
magFilter: this.magFilter,
anisotropy: this.anisotropy,
flipY: this.flipY,
premultiplyAlpha: this.premultiplyAlpha,
unpackAlignment: this.unpackAlignment
};
if (this.image !== undefined) {
// TODO: Move to THREE.Image
var image = this.image;
if (image.uuid === undefined) {
image.uuid = generateUUID(); // UGH
}
if (!isRootObject && meta.images[image.uuid] === undefined) {
var url = void 0;
if (Array.isArray(image)) {
// process array of images e.g. CubeTexture
url = [];
for (var i = 0, l = image.length; i < l; i++) {
// check cube texture with data textures
if (image[i].isDataTexture) {
url.push(serializeImage(image[i].image));
}
else {
url.push(serializeImage(image[i]));
}
}
}
else {
// process single image
url = serializeImage(image);
}
meta.images[image.uuid] = {
uuid: image.uuid,
url: url
};
}
output.image = image.uuid;
}
if (!isRootObject) {
meta.textures[this.uuid] = output;
}
return output;
};
Texture.prototype.dispose = function () {
this.dispatchEvent({ type: 'dispose' });
};
Texture.prototype.transformUv = function (uv) {
if (this.mapping !== UVMapping)
return uv;
uv.applyMatrix3(this.matrix);
if (uv.x < 0 || uv.x > 1) {
switch (this.wrapS) {
case RepeatWrapping:
uv.x = uv.x - Math.floor(uv.x);
break;
case ClampToEdgeWrapping:
uv.x = uv.x < 0 ? 0 : 1;
break;
case MirroredRepeatWrapping:
if (Math.abs(Math.floor(uv.x) % 2) === 1) {
uv.x = Math.ceil(uv.x) - uv.x;
}
else {
uv.x = uv.x - Math.floor(uv.x);
}
break;
}
}
if (uv.y < 0 || uv.y > 1) {
switch (this.wrapT) {
case RepeatWrapping:
uv.y = uv.y - Math.floor(uv.y);
break;
case ClampToEdgeWrapping:
uv.y = uv.y < 0 ? 0 : 1;
break;
case MirroredRepeatWrapping:
if (Math.abs(Math.floor(uv.y) % 2) === 1) {
uv.y = Math.ceil(uv.y) - uv.y;
}
else {
uv.y = uv.y - Math.floor(uv.y);
}
break;
}
}
if (this.flipY) {
uv.y = 1 - uv.y;
}
return uv;
};
Object.defineProperty(Texture.prototype, "needsUpdate", {
set: function (value) {
if (value === true)
this.version++;
},
enumerable: false,
configurable: true
});
return Texture;
}(EventDispatcher));
Texture.DEFAULT_IMAGE = undefined;
Texture.DEFAULT_MAPPING = UVMapping;
Texture.prototype.isTexture = true;
function serializeImage(image) {
if ((typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement) ||
(typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement) ||
(typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap)) {
// default images
return ImageUtils.getDataURL(image);
}
else {
if (image.data) {
// images of DataTexture
return {
data: Array.prototype.slice.call(image.data),
width: image.width,
height: image.height,
type: image.data.constructor.name
};
}
else {
console.warn('THREE.Texture: Unable to serialize Texture.');
return {};
}
}
}
var Vector4 = /** @class */ (function () {
function Vector4(x, y, z, w) {
if (x === void 0) { x = 0; }
if (y === void 0) { y = 0; }
if (z === void 0) { z = 0; }
if (w === void 0) { w = 1; }
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
Object.defineProperty(Vector4.prototype, "width", {
get: function () {
return this.z;
},
set: function (value) {
this.z = value;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Vector4.prototype, "height", {
get: function () {
return this.w;
},
set: function (value) {
this.w = value;
},
enumerable: false,
configurable: true
});
Vector4.prototype.set = function (x, y, z, w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
return this;
};
Vector4.prototype.setScalar = function (scalar) {
this.x = scalar;
this.y = scalar;
this.z = scalar;
this.w = scalar;
return this;
};
Vector4.prototype.setX = function (x) {
this.x = x;
return this;
};
Vector4.prototype.setY = function (y) {
this.y = y;
return this;
};
Vector4.prototype.setZ = function (z) {
this.z = z;
return this;
};
Vector4.prototype.setW = function (w) {
this.w = w;
return this;
};
Vector4.prototype.setComponent = function (index, value) {
switch (index) {
case 0:
this.x = value;
break;
case 1:
this.y = value;
break;
case 2:
this.z = value;
break;
case 3:
this.w = value;
break;
default: throw new Error('index is out of range: ' + index);
}
return this;
};
Vector4.prototype.getComponent = function (index) {
switch (index) {
case 0: return this.x;
case 1: return this.y;
case 2: return this.z;
case 3: return this.w;
default: throw new Error('index is out of range: ' + index);
}
};
Vector4.prototype.clone = function () {
return new this.constructor(this.x, this.y, this.z, this.w);
};
Vector4.prototype.copy = function (v) {
this.x = v.x;
this.y = v.y;
this.z = v.z;
this.w = (v.w !== undefined) ? v.w : 1;
return this;
};
Vector4.prototype.add = function (v, w) {
if (w !== undefined) {
console.warn('THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
return this.addVectors(v, w);
}
this.x += v.x;
this.y += v.y;
this.z += v.z;
this.w += v.w;
return this;
};
Vector4.prototype.addScalar = function (s) {
this.x += s;
this.y += s;
this.z += s;
this.w += s;
return this;
};
Vector4.prototype.addVectors = function (a, b) {
this.x = a.x + b.x;
this.y = a.y + b.y;
this.z = a.z + b.z;
this.w = a.w + b.w;
return this;
};
Vector4.prototype.addScaledVector = function (v, s) {
this.x += v.x * s;
this.y += v.y * s;
this.z += v.z * s;
this.w += v.w * s;
return this;
};
Vector4.prototype.sub = function (v, w) {
if (w !== undefined) {
console.warn('THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
return this.subVectors(v, w);
}
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
this.w -= v.w;
return this;
};
Vector4.prototype.subScalar = function (s) {
this.x -= s;
this.y -= s;
this.z -= s;
this.w -= s;
return this;
};
Vector4.prototype.subVectors = function (a, b) {
this.x = a.x - b.x;
this.y = a.y - b.y;
this.z = a.z - b.z;
this.w = a.w - b.w;
return this;
};
Vector4.prototype.multiply = function (v) {
this.x *= v.x;
this.y *= v.y;
this.z *= v.z;
this.w *= v.w;
return this;
};
Vector4.prototype.multiplyScalar = function (scalar) {
this.x *= scalar;
this.y *= scalar;
this.z *= scalar;
this.w *= scalar;
return this;
};
Vector4.prototype.applyMatrix4 = function (m) {
var x = this.x, y = this.y, z = this.z, w = this.w;
var e = m.elements;
this.x = e[0] * x + e[4] * y + e[8] * z + e[12] * w;
this.y = e[1] * x + e[5] * y + e[9] * z + e[13] * w;
this.z = e[2] * x + e[6] * y + e[10] * z + e[14] * w;
this.w = e[3] * x + e[7] * y + e[11] * z + e[15] * w;
return this;
};
Vector4.prototype.divideScalar = function (scalar) {
return this.multiplyScalar(1 / scalar);
};
Vector4.prototype.setAxisAngleFromQuaternion = function (q) {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
// q is assumed to be normalized
this.w = 2 * Math.acos(q.w);
var s = Math.sqrt(1 - q.w * q.w);
if (s < 0.0001) {
this.x = 1;
this.y = 0;
this.z = 0;
}
else {
this.x = q.x / s;
this.y = q.y / s;
this.z = q.z / s;
}
return this;
};
Vector4.prototype.setAxisAngleFromRotationMatrix = function (m) {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
var angle, x, y, z; // variables for result
var epsilon = 0.01, // margin to allow for rounding errors
epsilon2 = 0.1, // margin to distinguish between 0 and 180 degrees
te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10];
if ((Math.abs(m12 - m21) < epsilon) &&
(Math.abs(m13 - m31) < epsilon) &&
(Math.abs(m23 - m32) < epsilon)) {
// singularity found
// first check for identity matrix which must have +1 for all terms
// in leading diagonal and zero in other terms