vim-webgl-component
Version:
A demonstration app built on top of the vim-webgl-viewer
1,810 lines • 1.87 MB
JavaScript
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
const style = "";
/**
* @license
* Copyright 2010-2022 Three.js Authors
* SPDX-License-Identifier: MIT
*/
const REVISION = "143";
const MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
const TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };
const CullFaceNone = 0;
const CullFaceBack = 1;
const CullFaceFront = 2;
const CullFaceFrontBack = 3;
const BasicShadowMap = 0;
const PCFShadowMap = 1;
const PCFSoftShadowMap = 2;
const VSMShadowMap = 3;
const FrontSide = 0;
const BackSide = 1;
const DoubleSide = 2;
const FlatShading = 1;
const SmoothShading = 2;
const NoBlending = 0;
const NormalBlending = 1;
const AdditiveBlending = 2;
const SubtractiveBlending = 3;
const MultiplyBlending = 4;
const CustomBlending = 5;
const AddEquation = 100;
const SubtractEquation = 101;
const ReverseSubtractEquation = 102;
const MinEquation = 103;
const MaxEquation = 104;
const ZeroFactor = 200;
const OneFactor = 201;
const SrcColorFactor = 202;
const OneMinusSrcColorFactor = 203;
const SrcAlphaFactor = 204;
const OneMinusSrcAlphaFactor = 205;
const DstAlphaFactor = 206;
const OneMinusDstAlphaFactor = 207;
const DstColorFactor = 208;
const OneMinusDstColorFactor = 209;
const SrcAlphaSaturateFactor = 210;
const NeverDepth = 0;
const AlwaysDepth = 1;
const LessDepth = 2;
const LessEqualDepth = 3;
const EqualDepth = 4;
const GreaterEqualDepth = 5;
const GreaterDepth = 6;
const NotEqualDepth = 7;
const MultiplyOperation = 0;
const MixOperation = 1;
const AddOperation = 2;
const NoToneMapping = 0;
const LinearToneMapping = 1;
const ReinhardToneMapping = 2;
const CineonToneMapping = 3;
const ACESFilmicToneMapping = 4;
const CustomToneMapping = 5;
const UVMapping = 300;
const CubeReflectionMapping = 301;
const CubeRefractionMapping = 302;
const EquirectangularReflectionMapping = 303;
const EquirectangularRefractionMapping = 304;
const CubeUVReflectionMapping = 306;
const RepeatWrapping = 1e3;
const ClampToEdgeWrapping = 1001;
const MirroredRepeatWrapping = 1002;
const NearestFilter = 1003;
const NearestMipmapNearestFilter = 1004;
const NearestMipMapNearestFilter = 1004;
const NearestMipmapLinearFilter = 1005;
const NearestMipMapLinearFilter = 1005;
const LinearFilter = 1006;
const LinearMipmapNearestFilter = 1007;
const LinearMipMapNearestFilter = 1007;
const LinearMipmapLinearFilter = 1008;
const LinearMipMapLinearFilter = 1008;
const UnsignedByteType = 1009;
const ByteType = 1010;
const ShortType = 1011;
const UnsignedShortType = 1012;
const IntType = 1013;
const UnsignedIntType = 1014;
const FloatType = 1015;
const HalfFloatType = 1016;
const UnsignedShort4444Type = 1017;
const UnsignedShort5551Type = 1018;
const UnsignedInt248Type = 1020;
const AlphaFormat = 1021;
const RGBFormat = 1022;
const RGBAFormat = 1023;
const LuminanceFormat = 1024;
const LuminanceAlphaFormat = 1025;
const DepthFormat = 1026;
const DepthStencilFormat = 1027;
const RedFormat = 1028;
const RedIntegerFormat = 1029;
const RGFormat = 1030;
const RGIntegerFormat = 1031;
const RGBAIntegerFormat = 1033;
const RGB_S3TC_DXT1_Format = 33776;
const RGBA_S3TC_DXT1_Format = 33777;
const RGBA_S3TC_DXT3_Format = 33778;
const RGBA_S3TC_DXT5_Format = 33779;
const RGB_PVRTC_4BPPV1_Format = 35840;
const RGB_PVRTC_2BPPV1_Format = 35841;
const RGBA_PVRTC_4BPPV1_Format = 35842;
const RGBA_PVRTC_2BPPV1_Format = 35843;
const RGB_ETC1_Format = 36196;
const RGB_ETC2_Format = 37492;
const RGBA_ETC2_EAC_Format = 37496;
const RGBA_ASTC_4x4_Format = 37808;
const RGBA_ASTC_5x4_Format = 37809;
const RGBA_ASTC_5x5_Format = 37810;
const RGBA_ASTC_6x5_Format = 37811;
const RGBA_ASTC_6x6_Format = 37812;
const RGBA_ASTC_8x5_Format = 37813;
const RGBA_ASTC_8x6_Format = 37814;
const RGBA_ASTC_8x8_Format = 37815;
const RGBA_ASTC_10x5_Format = 37816;
const RGBA_ASTC_10x6_Format = 37817;
const RGBA_ASTC_10x8_Format = 37818;
const RGBA_ASTC_10x10_Format = 37819;
const RGBA_ASTC_12x10_Format = 37820;
const RGBA_ASTC_12x12_Format = 37821;
const RGBA_BPTC_Format = 36492;
const LoopOnce = 2200;
const LoopRepeat = 2201;
const LoopPingPong = 2202;
const InterpolateDiscrete = 2300;
const InterpolateLinear = 2301;
const InterpolateSmooth = 2302;
const ZeroCurvatureEnding = 2400;
const ZeroSlopeEnding = 2401;
const WrapAroundEnding = 2402;
const NormalAnimationBlendMode = 2500;
const AdditiveAnimationBlendMode = 2501;
const TrianglesDrawMode = 0;
const TriangleStripDrawMode = 1;
const TriangleFanDrawMode = 2;
const LinearEncoding = 3e3;
const sRGBEncoding = 3001;
const BasicDepthPacking = 3200;
const RGBADepthPacking = 3201;
const TangentSpaceNormalMap = 0;
const ObjectSpaceNormalMap = 1;
const NoColorSpace = "";
const SRGBColorSpace = "srgb";
const LinearSRGBColorSpace = "srgb-linear";
const ZeroStencilOp = 0;
const KeepStencilOp = 7680;
const ReplaceStencilOp = 7681;
const IncrementStencilOp = 7682;
const DecrementStencilOp = 7683;
const IncrementWrapStencilOp = 34055;
const DecrementWrapStencilOp = 34056;
const InvertStencilOp = 5386;
const NeverStencilFunc = 512;
const LessStencilFunc = 513;
const EqualStencilFunc = 514;
const LessEqualStencilFunc = 515;
const GreaterStencilFunc = 516;
const NotEqualStencilFunc = 517;
const GreaterEqualStencilFunc = 518;
const AlwaysStencilFunc = 519;
const StaticDrawUsage = 35044;
const DynamicDrawUsage = 35048;
const StreamDrawUsage = 35040;
const StaticReadUsage = 35045;
const DynamicReadUsage = 35049;
const StreamReadUsage = 35041;
const StaticCopyUsage = 35046;
const DynamicCopyUsage = 35050;
const StreamCopyUsage = 35042;
const GLSL1 = "100";
const GLSL3 = "300 es";
const _SRGBAFormat = 1035;
class EventDispatcher {
addEventListener(type, listener) {
if (this._listeners === void 0)
this._listeners = {};
const listeners = this._listeners;
if (listeners[type] === void 0) {
listeners[type] = [];
}
if (listeners[type].indexOf(listener) === -1) {
listeners[type].push(listener);
}
}
hasEventListener(type, listener) {
if (this._listeners === void 0)
return false;
const listeners = this._listeners;
return listeners[type] !== void 0 && listeners[type].indexOf(listener) !== -1;
}
removeEventListener(type, listener) {
if (this._listeners === void 0)
return;
const listeners = this._listeners;
const listenerArray = listeners[type];
if (listenerArray !== void 0) {
const index = listenerArray.indexOf(listener);
if (index !== -1) {
listenerArray.splice(index, 1);
}
}
}
dispatchEvent(event) {
if (this._listeners === void 0)
return;
const listeners = this._listeners;
const listenerArray = listeners[event.type];
if (listenerArray !== void 0) {
event.target = this;
const array = listenerArray.slice(0);
for (let i = 0, l = array.length; i < l; i++) {
array[i].call(this, event);
}
event.target = null;
}
}
}
const _lut = ["00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0a", "0b", "0c", "0d", "0e", "0f", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1a", "1b", "1c", "1d", "1e", "1f", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2a", "2b", "2c", "2d", "2e", "2f", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3a", "3b", "3c", "3d", "3e", "3f", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4a", "4b", "4c", "4d", "4e", "4f", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5a", "5b", "5c", "5d", "5e", "5f", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6a", "6b", "6c", "6d", "6e", "6f", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7a", "7b", "7c", "7d", "7e", "7f", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8a", "8b", "8c", "8d", "8e", "8f", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "aa", "ab", "ac", "ad", "ae", "af", "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "ba", "bb", "bc", "bd", "be", "bf", "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "da", "db", "dc", "dd", "de", "df", "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef", "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "fa", "fb", "fc", "fd", "fe", "ff"];
let _seed = 1234567;
const DEG2RAD = Math.PI / 180;
const RAD2DEG = 180 / Math.PI;
function generateUUID() {
const d0 = Math.random() * 4294967295 | 0;
const d1 = Math.random() * 4294967295 | 0;
const d2 = Math.random() * 4294967295 | 0;
const d3 = Math.random() * 4294967295 | 0;
const uuid = _lut[d0 & 255] + _lut[d0 >> 8 & 255] + _lut[d0 >> 16 & 255] + _lut[d0 >> 24 & 255] + "-" + _lut[d1 & 255] + _lut[d1 >> 8 & 255] + "-" + _lut[d1 >> 16 & 15 | 64] + _lut[d1 >> 24 & 255] + "-" + _lut[d2 & 63 | 128] + _lut[d2 >> 8 & 255] + "-" + _lut[d2 >> 16 & 255] + _lut[d2 >> 24 & 255] + _lut[d3 & 255] + _lut[d3 >> 8 & 255] + _lut[d3 >> 16 & 255] + _lut[d3 >> 24 & 255];
return uuid.toLowerCase();
}
function clamp$1(value, min, max) {
return Math.max(min, Math.min(max, value));
}
function euclideanModulo(n, m) {
return (n % m + m) % m;
}
function mapLinear(x, a1, a2, b1, b2) {
return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
}
function inverseLerp(x, y, value) {
if (x !== y) {
return (value - x) / (y - x);
} else {
return 0;
}
}
function lerp(x, y, t) {
return (1 - t) * x + t * y;
}
function damp(x, y, lambda, dt) {
return lerp(x, y, 1 - Math.exp(-lambda * dt));
}
function pingpong(x, length = 1) {
return length - Math.abs(euclideanModulo(x, length * 2) - length);
}
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);
}
function randInt(low, high) {
return low + Math.floor(Math.random() * (high - low + 1));
}
function randFloat(low, high) {
return low + Math.random() * (high - low);
}
function randFloatSpread(range) {
return range * (0.5 - Math.random());
}
function seededRandom(s) {
if (s !== void 0)
_seed = s;
let t = _seed += 1831565813;
t = Math.imul(t ^ t >>> 15, t | 1);
t ^= t + Math.imul(t ^ t >>> 7, t | 61);
return ((t ^ t >>> 14) >>> 0) / 4294967296;
}
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) {
const cos = Math.cos;
const sin = Math.sin;
const c2 = cos(b / 2);
const s2 = sin(b / 2);
const c13 = cos((a + c) / 2);
const s13 = sin((a + c) / 2);
const c1_3 = cos((a - c) / 2);
const s1_3 = sin((a - c) / 2);
const c3_1 = cos((c - a) / 2);
const 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);
}
}
function denormalize$1(value, array) {
switch (array.constructor) {
case Float32Array:
return value;
case Uint16Array:
return value / 65535;
case Uint8Array:
return value / 255;
case Int16Array:
return Math.max(value / 32767, -1);
case Int8Array:
return Math.max(value / 127, -1);
default:
throw new Error("Invalid component type.");
}
}
function normalize(value, array) {
switch (array.constructor) {
case Float32Array:
return value;
case Uint16Array:
return Math.round(value * 65535);
case Uint8Array:
return Math.round(value * 255);
case Int16Array:
return Math.round(value * 32767);
case Int8Array:
return Math.round(value * 127);
default:
throw new Error("Invalid component type.");
}
}
var MathUtils = /* @__PURE__ */ Object.freeze({
__proto__: null,
DEG2RAD,
RAD2DEG,
generateUUID,
clamp: clamp$1,
euclideanModulo,
mapLinear,
inverseLerp,
lerp,
damp,
pingpong,
smoothstep,
smootherstep,
randInt,
randFloat,
randFloatSpread,
seededRandom,
degToRad,
radToDeg,
isPowerOfTwo,
ceilPowerOfTwo,
floorPowerOfTwo,
setQuaternionFromProperEuler,
normalize,
denormalize: denormalize$1
});
class Vector2 {
constructor(x = 0, y = 0) {
Vector2.prototype.isVector2 = true;
this.x = x;
this.y = y;
}
get width() {
return this.x;
}
set width(value) {
this.x = value;
}
get height() {
return this.y;
}
set height(value) {
this.y = value;
}
set(x, y) {
this.x = x;
this.y = y;
return this;
}
setScalar(scalar) {
this.x = scalar;
this.y = scalar;
return this;
}
setX(x) {
this.x = x;
return this;
}
setY(y) {
this.y = y;
return this;
}
setComponent(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;
}
getComponent(index) {
switch (index) {
case 0:
return this.x;
case 1:
return this.y;
default:
throw new Error("index is out of range: " + index);
}
}
clone() {
return new this.constructor(this.x, this.y);
}
copy(v) {
this.x = v.x;
this.y = v.y;
return this;
}
add(v) {
this.x += v.x;
this.y += v.y;
return this;
}
addScalar(s) {
this.x += s;
this.y += s;
return this;
}
addVectors(a, b) {
this.x = a.x + b.x;
this.y = a.y + b.y;
return this;
}
addScaledVector(v, s) {
this.x += v.x * s;
this.y += v.y * s;
return this;
}
sub(v) {
this.x -= v.x;
this.y -= v.y;
return this;
}
subScalar(s) {
this.x -= s;
this.y -= s;
return this;
}
subVectors(a, b) {
this.x = a.x - b.x;
this.y = a.y - b.y;
return this;
}
multiply(v) {
this.x *= v.x;
this.y *= v.y;
return this;
}
multiplyScalar(scalar) {
this.x *= scalar;
this.y *= scalar;
return this;
}
divide(v) {
this.x /= v.x;
this.y /= v.y;
return this;
}
divideScalar(scalar) {
return this.multiplyScalar(1 / scalar);
}
applyMatrix3(m) {
const x = this.x, y = this.y;
const 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;
}
min(v) {
this.x = Math.min(this.x, v.x);
this.y = Math.min(this.y, v.y);
return this;
}
max(v) {
this.x = Math.max(this.x, v.x);
this.y = Math.max(this.y, v.y);
return this;
}
clamp(min, max) {
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;
}
clampScalar(minVal, maxVal) {
this.x = Math.max(minVal, Math.min(maxVal, this.x));
this.y = Math.max(minVal, Math.min(maxVal, this.y));
return this;
}
clampLength(min, max) {
const length = this.length();
return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
}
floor() {
this.x = Math.floor(this.x);
this.y = Math.floor(this.y);
return this;
}
ceil() {
this.x = Math.ceil(this.x);
this.y = Math.ceil(this.y);
return this;
}
round() {
this.x = Math.round(this.x);
this.y = Math.round(this.y);
return this;
}
roundToZero() {
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;
}
negate() {
this.x = -this.x;
this.y = -this.y;
return this;
}
dot(v) {
return this.x * v.x + this.y * v.y;
}
cross(v) {
return this.x * v.y - this.y * v.x;
}
lengthSq() {
return this.x * this.x + this.y * this.y;
}
length() {
return Math.sqrt(this.x * this.x + this.y * this.y);
}
manhattanLength() {
return Math.abs(this.x) + Math.abs(this.y);
}
normalize() {
return this.divideScalar(this.length() || 1);
}
angle() {
const angle = Math.atan2(-this.y, -this.x) + Math.PI;
return angle;
}
distanceTo(v) {
return Math.sqrt(this.distanceToSquared(v));
}
distanceToSquared(v) {
const dx = this.x - v.x, dy = this.y - v.y;
return dx * dx + dy * dy;
}
manhattanDistanceTo(v) {
return Math.abs(this.x - v.x) + Math.abs(this.y - v.y);
}
setLength(length) {
return this.normalize().multiplyScalar(length);
}
lerp(v, alpha) {
this.x += (v.x - this.x) * alpha;
this.y += (v.y - this.y) * alpha;
return this;
}
lerpVectors(v1, v2, alpha) {
this.x = v1.x + (v2.x - v1.x) * alpha;
this.y = v1.y + (v2.y - v1.y) * alpha;
return this;
}
equals(v) {
return v.x === this.x && v.y === this.y;
}
fromArray(array, offset = 0) {
this.x = array[offset];
this.y = array[offset + 1];
return this;
}
toArray(array = [], offset = 0) {
array[offset] = this.x;
array[offset + 1] = this.y;
return array;
}
fromBufferAttribute(attribute, index) {
this.x = attribute.getX(index);
this.y = attribute.getY(index);
return this;
}
rotateAround(center, angle) {
const c = Math.cos(angle), s = Math.sin(angle);
const x = this.x - center.x;
const y = this.y - center.y;
this.x = x * c - y * s + center.x;
this.y = x * s + y * c + center.y;
return this;
}
random() {
this.x = Math.random();
this.y = Math.random();
return this;
}
*[Symbol.iterator]() {
yield this.x;
yield this.y;
}
}
class Matrix3 {
constructor() {
Matrix3.prototype.isMatrix3 = true;
this.elements = [
1,
0,
0,
0,
1,
0,
0,
0,
1
];
}
set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
const 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;
}
identity() {
this.set(
1,
0,
0,
0,
1,
0,
0,
0,
1
);
return this;
}
copy(m) {
const te = this.elements;
const 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;
}
extractBasis(xAxis, yAxis, zAxis) {
xAxis.setFromMatrix3Column(this, 0);
yAxis.setFromMatrix3Column(this, 1);
zAxis.setFromMatrix3Column(this, 2);
return this;
}
setFromMatrix4(m) {
const 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;
}
multiply(m) {
return this.multiplyMatrices(this, m);
}
premultiply(m) {
return this.multiplyMatrices(m, this);
}
multiplyMatrices(a, b) {
const ae = a.elements;
const be = b.elements;
const te = this.elements;
const a11 = ae[0], a12 = ae[3], a13 = ae[6];
const a21 = ae[1], a22 = ae[4], a23 = ae[7];
const a31 = ae[2], a32 = ae[5], a33 = ae[8];
const b11 = be[0], b12 = be[3], b13 = be[6];
const b21 = be[1], b22 = be[4], b23 = be[7];
const 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;
}
multiplyScalar(s) {
const 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;
}
determinant() {
const te = this.elements;
const 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;
}
invert() {
const 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);
const 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;
}
transpose() {
let tmp2;
const m = this.elements;
tmp2 = m[1];
m[1] = m[3];
m[3] = tmp2;
tmp2 = m[2];
m[2] = m[6];
m[6] = tmp2;
tmp2 = m[5];
m[5] = m[7];
m[7] = tmp2;
return this;
}
getNormalMatrix(matrix4) {
return this.setFromMatrix4(matrix4).invert().transpose();
}
transposeIntoArray(r) {
const 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;
}
setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
const c = Math.cos(rotation);
const 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;
}
scale(sx, sy) {
const te = this.elements;
te[0] *= sx;
te[3] *= sx;
te[6] *= sx;
te[1] *= sy;
te[4] *= sy;
te[7] *= sy;
return this;
}
rotate(theta) {
const c = Math.cos(theta);
const s = Math.sin(theta);
const te = this.elements;
const a11 = te[0], a12 = te[3], a13 = te[6];
const 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;
}
translate(tx, ty) {
const 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;
}
equals(matrix) {
const te = this.elements;
const me = matrix.elements;
for (let i = 0; i < 9; i++) {
if (te[i] !== me[i])
return false;
}
return true;
}
fromArray(array, offset = 0) {
for (let i = 0; i < 9; i++) {
this.elements[i] = array[i + offset];
}
return this;
}
toArray(array = [], offset = 0) {
const 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;
}
clone() {
return new this.constructor().fromArray(this.elements);
}
}
function arrayNeedsUint32(array) {
for (let i = array.length - 1; i >= 0; --i) {
if (array[i] > 65535)
return true;
}
return false;
}
const TYPED_ARRAYS = {
Int8Array,
Uint8Array,
Uint8ClampedArray,
Int16Array,
Uint16Array,
Int32Array,
Uint32Array,
Float32Array,
Float64Array
};
function getTypedArray(type, buffer) {
return new TYPED_ARRAYS[type](buffer);
}
function createElementNS(name) {
return document.createElementNS("http://www.w3.org/1999/xhtml", name);
}
function SRGBToLinear(c) {
return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
}
function LinearToSRGB(c) {
return c < 31308e-7 ? c * 12.92 : 1.055 * Math.pow(c, 0.41666) - 0.055;
}
const FN = {
[SRGBColorSpace]: { [LinearSRGBColorSpace]: SRGBToLinear },
[LinearSRGBColorSpace]: { [SRGBColorSpace]: LinearToSRGB }
};
const ColorManagement = {
legacyMode: true,
get workingColorSpace() {
return LinearSRGBColorSpace;
},
set workingColorSpace(colorSpace) {
console.warn("THREE.ColorManagement: .workingColorSpace is readonly.");
},
convert: function(color, sourceColorSpace, targetColorSpace) {
if (this.legacyMode || sourceColorSpace === targetColorSpace || !sourceColorSpace || !targetColorSpace) {
return color;
}
if (FN[sourceColorSpace] && FN[sourceColorSpace][targetColorSpace] !== void 0) {
const fn = FN[sourceColorSpace][targetColorSpace];
color.r = fn(color.r);
color.g = fn(color.g);
color.b = fn(color.b);
return color;
}
throw new Error("Unsupported color space conversion.");
},
fromWorkingColorSpace: function(color, targetColorSpace) {
return this.convert(color, this.workingColorSpace, targetColorSpace);
},
toWorkingColorSpace: function(color, sourceColorSpace) {
return this.convert(color, sourceColorSpace, this.workingColorSpace);
}
};
const _colorKeywords = {
"aliceblue": 15792383,
"antiquewhite": 16444375,
"aqua": 65535,
"aquamarine": 8388564,
"azure": 15794175,
"beige": 16119260,
"bisque": 16770244,
"black": 0,
"blanchedalmond": 16772045,
"blue": 255,
"blueviolet": 9055202,
"brown": 10824234,
"burlywood": 14596231,
"cadetblue": 6266528,
"chartreuse": 8388352,
"chocolate": 13789470,
"coral": 16744272,
"cornflowerblue": 6591981,
"cornsilk": 16775388,
"crimson": 14423100,
"cyan": 65535,
"darkblue": 139,
"darkcyan": 35723,
"darkgoldenrod": 12092939,
"darkgray": 11119017,
"darkgreen": 25600,
"darkgrey": 11119017,
"darkkhaki": 12433259,
"darkmagenta": 9109643,
"darkolivegreen": 5597999,
"darkorange": 16747520,
"darkorchid": 10040012,
"darkred": 9109504,
"darksalmon": 15308410,
"darkseagreen": 9419919,
"darkslateblue": 4734347,
"darkslategray": 3100495,
"darkslategrey": 3100495,
"darkturquoise": 52945,
"darkviolet": 9699539,
"deeppink": 16716947,
"deepskyblue": 49151,
"dimgray": 6908265,
"dimgrey": 6908265,
"dodgerblue": 2003199,
"firebrick": 11674146,
"floralwhite": 16775920,
"forestgreen": 2263842,
"fuchsia": 16711935,
"gainsboro": 14474460,
"ghostwhite": 16316671,
"gold": 16766720,
"goldenrod": 14329120,
"gray": 8421504,
"green": 32768,
"greenyellow": 11403055,
"grey": 8421504,
"honeydew": 15794160,
"hotpink": 16738740,
"indianred": 13458524,
"indigo": 4915330,
"ivory": 16777200,
"khaki": 15787660,
"lavender": 15132410,
"lavenderblush": 16773365,
"lawngreen": 8190976,
"lemonchiffon": 16775885,
"lightblue": 11393254,
"lightcoral": 15761536,
"lightcyan": 14745599,
"lightgoldenrodyellow": 16448210,
"lightgray": 13882323,
"lightgreen": 9498256,
"lightgrey": 13882323,
"lightpink": 16758465,
"lightsalmon": 16752762,
"lightseagreen": 2142890,
"lightskyblue": 8900346,
"lightslategray": 7833753,
"lightslategrey": 7833753,
"lightsteelblue": 11584734,
"lightyellow": 16777184,
"lime": 65280,
"limegreen": 3329330,
"linen": 16445670,
"magenta": 16711935,
"maroon": 8388608,
"mediumaquamarine": 6737322,
"mediumblue": 205,
"mediumorchid": 12211667,
"mediumpurple": 9662683,
"mediumseagreen": 3978097,
"mediumslateblue": 8087790,
"mediumspringgreen": 64154,
"mediumturquoise": 4772300,
"mediumvioletred": 13047173,
"midnightblue": 1644912,
"mintcream": 16121850,
"mistyrose": 16770273,
"moccasin": 16770229,
"navajowhite": 16768685,
"navy": 128,
"oldlace": 16643558,
"olive": 8421376,
"olivedrab": 7048739,
"orange": 16753920,
"orangered": 16729344,
"orchid": 14315734,
"palegoldenrod": 15657130,
"palegreen": 10025880,
"paleturquoise": 11529966,
"palevioletred": 14381203,
"papayawhip": 16773077,
"peachpuff": 16767673,
"peru": 13468991,
"pink": 16761035,
"plum": 14524637,
"powderblue": 11591910,
"purple": 8388736,
"rebeccapurple": 6697881,
"red": 16711680,
"rosybrown": 12357519,
"royalblue": 4286945,
"saddlebrown": 9127187,
"salmon": 16416882,
"sandybrown": 16032864,
"seagreen": 3050327,
"seashell": 16774638,
"sienna": 10506797,
"silver": 12632256,
"skyblue": 8900331,
"slateblue": 6970061,
"slategray": 7372944,
"slategrey": 7372944,
"snow": 16775930,
"springgreen": 65407,
"steelblue": 4620980,
"tan": 13808780,
"teal": 32896,
"thistle": 14204888,
"tomato": 16737095,
"turquoise": 4251856,
"violet": 15631086,
"wheat": 16113331,
"white": 16777215,
"whitesmoke": 16119285,
"yellow": 16776960,
"yellowgreen": 10145074
};
const _rgb = { r: 0, g: 0, b: 0 };
const _hslA = { h: 0, s: 0, l: 0 };
const _hslB = { h: 0, s: 0, l: 0 };
function hue2rgb(p, q, t) {
if (t < 0)
t += 1;
if (t > 1)
t -= 1;
if (t < 1 / 6)
return p + (q - p) * 6 * t;
if (t < 1 / 2)
return q;
if (t < 2 / 3)
return p + (q - p) * 6 * (2 / 3 - t);
return p;
}
function toComponents(source, target) {
target.r = source.r;
target.g = source.g;
target.b = source.b;
return target;
}
class Color {
constructor(r, g, b) {
this.isColor = true;
this.r = 1;
this.g = 1;
this.b = 1;
if (g === void 0 && b === void 0) {
return this.set(r);
}
return this.setRGB(r, g, b);
}
set(value) {
if (value && value.isColor) {
this.copy(value);
} else if (typeof value === "number") {
this.setHex(value);
} else if (typeof value === "string") {
this.setStyle(value);
}
return this;
}
setScalar(scalar) {
this.r = scalar;
this.g = scalar;
this.b = scalar;
return this;
}
setHex(hex, colorSpace = SRGBColorSpace) {
hex = Math.floor(hex);
this.r = (hex >> 16 & 255) / 255;
this.g = (hex >> 8 & 255) / 255;
this.b = (hex & 255) / 255;
ColorManagement.toWorkingColorSpace(this, colorSpace);
return this;
}
setRGB(r, g, b, colorSpace = LinearSRGBColorSpace) {
this.r = r;
this.g = g;
this.b = b;
ColorManagement.toWorkingColorSpace(this, colorSpace);
return this;
}
setHSL(h, s, l, colorSpace = LinearSRGBColorSpace) {
h = euclideanModulo(h, 1);
s = clamp$1(s, 0, 1);
l = clamp$1(l, 0, 1);
if (s === 0) {
this.r = this.g = this.b = l;
} else {
const p = l <= 0.5 ? l * (1 + s) : l + s - l * s;
const q = 2 * l - p;
this.r = hue2rgb(q, p, h + 1 / 3);
this.g = hue2rgb(q, p, h);
this.b = hue2rgb(q, p, h - 1 / 3);
}
ColorManagement.toWorkingColorSpace(this, colorSpace);
return this;
}
setStyle(style2, colorSpace = SRGBColorSpace) {
function handleAlpha(string) {
if (string === void 0)
return;
if (parseFloat(string) < 1) {
console.warn("THREE.Color: Alpha component of " + style2 + " will be ignored.");
}
}
let m;
if (m = /^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(style2)) {
let color;
const name = m[1];
const components = m[2];
switch (name) {
case "rgb":
case "rgba":
if (color = /^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) {
this.r = Math.min(255, parseInt(color[1], 10)) / 255;
this.g = Math.min(255, parseInt(color[2], 10)) / 255;
this.b = Math.min(255, parseInt(color[3], 10)) / 255;
ColorManagement.toWorkingColorSpace(this, colorSpace);
handleAlpha(color[4]);
return this;
}
if (color = /^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) {
this.r = Math.min(100, parseInt(color[1], 10)) / 100;
this.g = Math.min(100, parseInt(color[2], 10)) / 100;
this.b = Math.min(100, parseInt(color[3], 10)) / 100;
ColorManagement.toWorkingColorSpace(this, colorSpace);
handleAlpha(color[4]);
return this;
}
break;
case "hsl":
case "hsla":
if (color = /^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) {
const h = parseFloat(color[1]) / 360;
const s = parseInt(color[2], 10) / 100;
const l = parseInt(color[3], 10) / 100;
handleAlpha(color[4]);
return this.setHSL(h, s, l, colorSpace);
}
break;
}
} else if (m = /^\#([A-Fa-f\d]+)$/.exec(style2)) {
const hex = m[1];
const size = hex.length;
if (size === 3) {
this.r = parseInt(hex.charAt(0) + hex.charAt(0), 16) / 255;
this.g = parseInt(hex.charAt(1) + hex.charAt(1), 16) / 255;
this.b = parseInt(hex.charAt(2) + hex.charAt(2), 16) / 255;
ColorManagement.toWorkingColorSpace(this, colorSpace);
return this;
} else if (size === 6) {
this.r = parseInt(hex.charAt(0) + hex.charAt(1), 16) / 255;
this.g = parseInt(hex.charAt(2) + hex.charAt(3), 16) / 255;
this.b = parseInt(hex.charAt(4) + hex.charAt(5), 16) / 255;
ColorManagement.toWorkingColorSpace(this, colorSpace);
return this;
}
}
if (style2 && style2.length > 0) {
return this.setColorName(style2, colorSpace);
}
return this;
}
setColorName(style2, colorSpace = SRGBColorSpace) {
const hex = _colorKeywords[style2.toLowerCase()];
if (hex !== void 0) {
this.setHex(hex, colorSpace);
} else {
console.warn("THREE.Color: Unknown color " + style2);
}
return this;
}
clone() {
return new this.constructor(this.r, this.g, this.b);
}
copy(color) {
this.r = color.r;
this.g = color.g;
this.b = color.b;
return this;
}
copySRGBToLinear(color) {
this.r = SRGBToLinear(color.r);
this.g = SRGBToLinear(color.g);
this.b = SRGBToLinear(color.b);
return this;
}
copyLinearToSRGB(color) {
this.r = LinearToSRGB(color.r);
this.g = LinearToSRGB(color.g);
this.b = LinearToSRGB(color.b);
return this;
}
convertSRGBToLinear() {
this.copySRGBToLinear(this);
return this;
}
convertLinearToSRGB() {
this.copyLinearToSRGB(this);
return this;
}
getHex(colorSpace = SRGBColorSpace) {
ColorManagement.fromWorkingColorSpace(toComponents(this, _rgb), colorSpace);
return clamp$1(_rgb.r * 255, 0, 255) << 16 ^ clamp$1(_rgb.g * 255, 0, 255) << 8 ^ clamp$1(_rgb.b * 255, 0, 255) << 0;
}
getHexString(colorSpace = SRGBColorSpace) {
return ("000000" + this.getHex(colorSpace).toString(16)).slice(-6);
}
getHSL(target, colorSpace = LinearSRGBColorSpace) {
ColorManagement.fromWorkingColorSpace(toComponents(this, _rgb), colorSpace);
const r = _rgb.r, g = _rgb.g, b = _rgb.b;
const max = Math.max(r, g, b);
const min = Math.min(r, g, b);
let hue, saturation;
const lightness = (min + max) / 2;
if (min === max) {
hue = 0;
saturation = 0;
} else {
const delta = max - min;
saturation = lightness <= 0.5 ? delta / (max + min) : delta / (2 - max - min);
switch (max) {
case r:
hue = (g - b) / delta + (g < b ? 6 : 0);
break;
case g:
hue = (b - r) / delta + 2;
break;
case b:
hue = (r - g) / delta + 4;
break;
}
hue /= 6;
}
target.h = hue;
target.s = saturation;
target.l = lightness;
return target;
}
getRGB(target, colorSpace = LinearSRGBColorSpace) {
ColorManagement.fromWorkingColorSpace(toComponents(this, _rgb), colorSpace);
target.r = _rgb.r;
target.g = _rgb.g;
target.b = _rgb.b;
return target;
}
getStyle(colorSpace = SRGBColorSpace) {
ColorManagement.fromWorkingColorSpace(toComponents(this, _rgb), colorSpace);
if (colorSpace !== SRGBColorSpace) {
return `color(${colorSpace} ${_rgb.r} ${_rgb.g} ${_rgb.b})`;
}
return `rgb(${_rgb.r * 255 | 0},${_rgb.g * 255 | 0},${_rgb.b * 255 | 0})`;
}
offsetHSL(h, s, l) {
this.getHSL(_hslA);
_hslA.h += h;
_hslA.s += s;
_hslA.l += l;
this.setHSL(_hslA.h, _hslA.s, _hslA.l);
return this;
}
add(color) {
this.r += color.r;
this.g += color.g;
this.b += color.b;
return this;
}
addColors(color1, color2) {
this.r = color1.r + color2.r;
this.g = color1.g + color2.g;
this.b = color1.b + color2.b;
return this;
}
addScalar(s) {
this.r += s;
this.g += s;
this.b += s;
return this;
}
sub(color) {
this.r = Math.max(0, this.r - color.r);
this.g = Math.max(0, this.g - color.g);
this.b = Math.max(0, this.b - color.b);
return this;
}
multiply(color) {
this.r *= color.r;
this.g *= color.g;
this.b *= color.b;
return this;
}
multiplyScalar(s) {
this.r *= s;
this.g *= s;
this.b *= s;
return this;
}
lerp(color, alpha) {
this.r += (color.r - this.r) * alpha;
this.g += (color.g - this.g) * alpha;
this.b += (color.b - this.b) * alpha;
return this;
}
lerpColors(color1, color2, alpha) {
this.r = color1.r + (color2.r - color1.r) * alpha;
this.g = color1.g + (color2.g - color1.g) * alpha;
this.b = color1.b + (color2.b - color1.b) * alpha;
return this;
}
lerpHSL(color, alpha) {
this.getHSL(_hslA);
color.getHSL(_hslB);
const h = lerp(_hslA.h, _hslB.h, alpha);
const s = lerp(_hslA.s, _hslB.s, alpha);
const l = lerp(_hslA.l, _hslB.l, alpha);
this.setHSL(h, s, l);
return this;
}
equals(c) {
return c.r === this.r && c.g === this.g && c.b === this.b;
}
fromArray(array, offset = 0) {
this.r = array[offset];
this.g = array[offset + 1];
this.b = array[offset + 2];
return this;
}
toArray(array = [], offset = 0) {
array[offset] = this.r;
array[offset + 1] = this.g;
array[offset + 2] = this.b;
return array;
}
fromBufferAttribute(attribute, index) {
this.r = attribute.getX(index);
this.g = attribute.getY(index);
this.b = attribute.getZ(index);
if (attribute.normalized === true) {
this.r /= 255;
this.g /= 255;
this.b /= 255;
}
return this;
}
toJSON() {
return this.getHex();
}
*[Symbol.iterator]() {
yield this.r;
yield this.g;
yield this.b;
}
}
Color.NAMES = _colorKeywords;
let _canvas;
class ImageUtils {
static getDataURL(image) {
if (/^data:/i.test(image.src)) {
return image.src;
}
if (typeof HTMLCanvasElement == "undefined") {
return image.src;
}
let canvas;
if (image instanceof HTMLCanvasElement) {
canvas = image;
} else {
if (_canvas === void 0)
_canvas = createElementNS("canvas");
_canvas.width = image.width;
_canvas.height = image.height;
const 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");
}
}
static sRGBToLinear(image) {
if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
const canvas = createElementNS("canvas");
canvas.width = image.width;
canvas.height = image.height;
const context = canvas.getContext("2d");
context.drawImage(image, 0, 0, image.width, image.height);
const imageData = context.getImageData(0, 0, image.width, image.height);
const data = imageData.data;
for (let i = 0; i < data.length; i++) {
data[i] = SRGBToLinear(data[i] / 255) * 255;
}
context.putImageData(imageData, 0, 0);
return canvas;
} else if (image.data) {
const data = image.data.slice(0);
for (let i = 0; i < data.length; i++) {
if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
data[i] = Math.floor(SRGBToLinear(data[i] / 255) * 255);
} else {
data[i] = SRGBToLinear(data[i]);
}
}
return {
data,
width: image.width,
height: image.height
};
} else {
console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.");
return image;
}
}
}
class Source {
constructor(data = null) {
this.isSource = true;
this.uuid = generateUUID();
this.data = data;
this.version = 0;
}
set needsUpdate(value) {
if (value === true)
this.version++;
}
toJSON(meta) {
const isRootObject = meta === void 0 || typeof meta === "string";
if (!isRootObject && meta.images[this.uuid] !== void 0) {
return meta.images[this.uuid];
}
const output = {
uuid: this.uuid,
url: ""
};
const data = this.data;
if (data !== null) {
let url;
if (Array.isArray(data)) {
url = [];
for (let i = 0, l = data.length; i < l; i++) {
if (data[i].isDataTexture) {
url.push(serializeImage(data[i].image));
} else {
url.push(serializeImage(data[i]));
}
}
} else {
url = serializeImage(data);
}
output.url = url;
}
if (!isRootObject) {
meta.images[this.uuid] = output;
}
return output;
}
}
function serializeImage(image) {
if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
return ImageUtils.getDataURL(image);
} else {
if (image.data) {
return {
data: Array.from(image.data),
width: image.width,
height: image.height,
type: image.data.constructor.name
};
} else {
console.warn("THREE.Texture: Unable to serialize Texture.");
return {};
}
}
}
let textureId = 0;
class Texture extends EventDispatcher {
constructor(image = Texture.DEFAULT_IMAGE, mapping = Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = 1, encoding = LinearEncoding) {
super();
this.isTexture = true;
Object.defineProperty(this, "id", { value: textureId++ });
this.uuid = generateUUID();
this.name = "";
this.source = new Source(image);
this.mipmaps = [];
this.mapping = mapping;
this.wrapS = wrapS;
this.wrapT = wrapT;
this.magFilter = magFilter;
this.minFilter = minFilter;
this.anisotropy = anisotropy;
this.format = format;
this.internalFormat = null;
this.type = type;
this.offset = new Vector2(0, 0);
this.repeat = new Vector2(1, 1);
this.center = new Vector2(0, 0);
this.rotation = 0;
this.matrixAutoUpdate = true;
this.matrix = new Matrix3();
this.generateMipmaps = true;
this.premultiplyAlpha = false;
this.flipY = true;
this.unpackAlignment = 4;
this.encoding = encoding;
this.userData = {};
this.version = 0;
this.onUpdate = null;
this.isRenderTargetTexture = false;
this.needsPMREMUpdate = false;
}
get image() {
return this.source.data;
}
set image(value) {
this.source.data = value;
}
updateMatrix() {
this.matrix.setUvTransform(this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y);
}
clone() {
return new this.constructor().copy(this);
}
copy(source) {
this.name = source.name;
this.source = source.source;
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;
this.userData = JSON.parse(JSON.stringify(source.userData));
this.needsUpdate = true;
return this;
}
toJSON(meta) {
const isRootObject = meta === void 0 || typeof meta === "string";
if (!isRootObject && meta.textures[this.uuid] !== void 0) {
return meta.textures[this.uuid];
}
const output = {
metadata: {
version: 4.5,
type: "Texture",
generator: "Texture.toJSON"
},
uuid: this.uuid,
name: this.name,
image: this.source.toJSON(meta).uuid,
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 (JSON.stringify(this.userData) !== "{}")
output.userData = this.userData;
if (!isRootObject) {
meta.textures[this.uuid] = output;
}
return output;
}
dispose() {
this.dispatchEvent({ type: "dispose" });
}
transformUv(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;
}
set needsUpdate(value) {
if (value === true) {
this.version++;
this.source.needsUpdate = true;
}
}
}
Texture.DEFAULT_IMAGE = null;
Texture.DEFAULT_MAPPING = UVMapping;
class Vector4 {
constructor(x = 0, y = 0, z = 0, w = 1) {
Vector4.prototype.isVector4 = true;
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
get width() {
return this.z;
}
set width(value) {
this.z = value;
}
get height() {
return this.w;
}
set height(value) {
this.w = value;
}
set(x, y, z, w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
return this;
}
setScalar(scalar) {
this.x = scalar;
this.y = scalar;
this.z = scalar;
this.w = scalar;
return this;
}
setX(x) {
this.x = x;
return this;
}
setY(y) {
this.y = y;
return this;
}
setZ(z) {
this.z = z;
return this;
}
setW(w) {
this.w = w;
return this;
}
setComponent(index, va