@fonsecabarreto/genesis-gl-react 0.1.1 → 0.1.31

package/dist/chunk-QXHXGH2T.js

@@ -0,0 +1,4733 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/hooks/useGenesisGL.ts
+import { useRef, useEffect, useState } from "react";
+
+// ../GenesisGL/src/Core/shaders/index.ts
+var vsSource = (
+  /* glsl */
+  `
+#define MAX_JOINTS 128
+
+attribute vec3 aPosition;
+attribute vec3 aNormal;
+attribute vec2 aTexCoord;
+
+// \u2500\u2500 Skinning attributes (vec4: up to 4 joint influences per vertex) \u2500\u2500
+attribute vec4 aJointIndices;
+attribute vec4 aJointWeights;
+
+uniform mat4 uModel;
+uniform mat4 uView;
+uniform mat4 uProjection;
+
+// \u2500\u2500 Skinning uniforms \u2500\u2500
+uniform bool uUseSkinning;
+uniform mat4 uJointMatrices[MAX_JOINTS];
+
+varying vec3 vNormal;
+varying vec3 vPosition;
+varying vec2 vTexCoord;
+
+void main() {
+    vTexCoord = aTexCoord;
+
+    vec4 pos = vec4(aPosition, 1.0);
+    vec3 norm = aNormal;
+
+    if (uUseSkinning) {
+        mat4 skinMat =
+            aJointWeights.x * uJointMatrices[int(aJointIndices.x)] +
+            aJointWeights.y * uJointMatrices[int(aJointIndices.y)] +
+            aJointWeights.z * uJointMatrices[int(aJointIndices.z)] +
+            aJointWeights.w * uJointMatrices[int(aJointIndices.w)];
+        pos  = skinMat * pos;
+        norm = mat3(skinMat) * norm;
+    }
+
+    vNormal = mat3(uModel) * norm;
+
+    vec4 worldPosition = uModel * pos;
+    vPosition = worldPosition.xyz;
+    gl_Position = uProjection * uView * worldPosition;
+}
+`
+);
+var fsSource = (
+  /* glsl */
+  `
+precision mediump float;
+
+#define MAX_LIGHTS 5
+
+varying vec3 vNormal;
+varying vec3 vPosition;
+varying vec2 vTexCoord;
+
+uniform vec3 uLightDirection[MAX_LIGHTS];
+uniform vec3 uLightColor[MAX_LIGHTS];
+uniform float uLightIntensity[MAX_LIGHTS];
+uniform int uLightType[MAX_LIGHTS];  // 0=directional, 1=point, 2=ambient
+uniform int uLightCount;
+uniform vec3 uLightPosition[MAX_LIGHTS];
+uniform float uLightConstant[MAX_LIGHTS];
+uniform float uLightLinear[MAX_LIGHTS];
+uniform float uLightQuadratic[MAX_LIGHTS];
+
+uniform vec4 uColor;
+uniform bool uUnlit;
+uniform bool uUseTexture;
+uniform sampler2D uTexture;
+
+uniform vec3 uViewPosition;
+uniform float uShininess;
+uniform vec3 uSpecularColor;
+
+void main() {
+    vec4 baseColor = uColor;
+    if (uUseTexture) {
+        baseColor *= texture2D(uTexture, vTexCoord);
+    }
+
+    if (uUnlit) {
+        gl_FragColor = baseColor;
+        return;
+    }
+
+    vec3 norm = normalize(vNormal);
+    vec3 totalDiffuse = vec3(0.0);
+    vec3 totalAmbient = vec3(0.0);
+    vec3 totalSpecular = vec3(0.0);
+
+    vec3 viewDir = normalize(uViewPosition - vPosition);
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+        if (i >= uLightCount) break;
+
+        if (uLightType[i] == 2) {
+            totalAmbient += uLightColor[i] * uLightIntensity[i];
+        } else {
+            vec3 lightDir;
+            float attenuation = 1.0;
+
+            if (uLightType[i] == 0) {
+                // Directional light
+                lightDir = normalize(-uLightDirection[i]);
+            } else {
+                // Point light
+                vec3 lightVec = uLightPosition[i] - vPosition;
+                float distance = length(lightVec);
+                lightDir = normalize(lightVec);
+                attenuation = 1.0 / (
+                    uLightConstant[i] +
+                    uLightLinear[i] * distance +
+                    uLightQuadratic[i] * distance * distance
+                );
+            }
+
+            // Diffuse
+            float diff = max(dot(norm, lightDir), 0.0);
+            totalDiffuse += diff * uLightColor[i] * uLightIntensity[i] * attenuation;
+
+            // Specular (Blinn-Phong) \u2014 softer, more natural highlights
+            vec3 halfDir = normalize(lightDir + viewDir);
+            float spec = pow(max(dot(norm, halfDir), 0.0), uShininess);
+            totalSpecular += spec * uSpecularColor * uLightIntensity[i] * attenuation;
+        }
+    }
+
+    vec3 lightingResult =
+        totalAmbient * baseColor.rgb +
+        totalDiffuse * baseColor.rgb +
+        totalSpecular;
+
+    gl_FragColor = vec4(lightingResult, baseColor.a);
+}
+`
+);
+
+// ../GenesisGL/src/Core/classes/WebGLCore.ts
+var WebGLCore = class {
+  gl;
+  program;
+  canvas;
+  isWebGL2;
+  /**
+   * Initialise the WebGL rendering core.
+   *
+   * @param canvasOrId - An `HTMLCanvasElement` or the DOM `id` of one.
+   *                     Defaults to `'glcanvas'`.
+   */
+  constructor(canvasOrId = "glcanvas") {
+    const canvas = typeof canvasOrId === "string" ? document.getElementById(canvasOrId) : canvasOrId;
+    if (!canvas) throw new Error("Canvas not found");
+    this.canvas = canvas;
+    canvas.width = window.innerWidth;
+    canvas.height = window.innerHeight;
+    this.gl = canvas.getContext("webgl2") ?? canvas.getContext("webgl");
+    if (!this.gl) throw new Error("WebGL not supported in this browser!");
+    this.isWebGL2 = this.gl instanceof WebGL2RenderingContext;
+    this.gl.viewport(0, 0, canvas.width, canvas.height);
+    const program = this.createProgram(this.gl);
+    if (!program) throw new Error("Failed to create program");
+    this.program = program;
+  }
+  getProgram() {
+    return this.program;
+  }
+  getRenderingContext() {
+    return this.gl;
+  }
+  createProgram(gl) {
+    const vertexShader = this.compileShader(gl, gl.VERTEX_SHADER, vsSource);
+    const fragmentShader = this.compileShader(gl, gl.FRAGMENT_SHADER, fsSource);
+    if (!vertexShader || !fragmentShader)
+      throw new Error("Failed to create shaders");
+    const program = gl.createProgram();
+    if (!program) return null;
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      console.error(gl.getProgramInfoLog(program));
+      throw new Error(gl.getProgramInfoLog(program) || "Program link error");
+    }
+    return program;
+  }
+  compileShader(gl, type, source) {
+    const shader = gl.createShader(type);
+    if (!shader) return null;
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+      console.error(gl.getShaderInfoLog(shader));
+      gl.deleteShader(shader);
+      throw new Error(gl.getShaderInfoLog(shader) || "Shader compile error");
+    }
+    return shader;
+  }
+  resize(width, height) {
+    this.canvas.width = width;
+    this.canvas.height = height;
+    this.gl.viewport(0, 0, width, height);
+  }
+  dispose() {
+    const { gl, program } = this;
+    if (program) gl.deleteProgram(program);
+  }
+};
+
+// ../../node_modules/gl-matrix/esm/common.js
+var EPSILON = 1e-6;
+var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+var RANDOM = Math.random;
+var ANGLE_ORDER = "zyx";
+function round(a) {
+  if (a >= 0) return Math.round(a);
+  return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+}
+var degree = Math.PI / 180;
+var radian = 180 / Math.PI;
+
+// ../../node_modules/gl-matrix/esm/mat3.js
+function create() {
+  var out = new ARRAY_TYPE(9);
+  if (ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[5] = 0;
+    out[6] = 0;
+    out[7] = 0;
+  }
+  out[0] = 1;
+  out[4] = 1;
+  out[8] = 1;
+  return out;
+}
+
+// ../../node_modules/gl-matrix/esm/mat4.js
+var mat4_exports = {};
+__export(mat4_exports, {
+  add: () => add,
+  adjoint: () => adjoint,
+  clone: () => clone,
+  copy: () => copy,
+  create: () => create2,
+  decompose: () => decompose,
+  determinant: () => determinant,
+  equals: () => equals,
+  exactEquals: () => exactEquals,
+  frob: () => frob,
+  fromQuat: () => fromQuat,
+  fromQuat2: () => fromQuat2,
+  fromRotation: () => fromRotation,
+  fromRotationTranslation: () => fromRotationTranslation,
+  fromRotationTranslationScale: () => fromRotationTranslationScale,
+  fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin,
+  fromScaling: () => fromScaling,
+  fromTranslation: () => fromTranslation,
+  fromValues: () => fromValues,
+  fromXRotation: () => fromXRotation,
+  fromYRotation: () => fromYRotation,
+  fromZRotation: () => fromZRotation,
+  frustum: () => frustum,
+  getRotation: () => getRotation,
+  getScaling: () => getScaling,
+  getTranslation: () => getTranslation,
+  identity: () => identity,
+  invert: () => invert,
+  lookAt: () => lookAt,
+  mul: () => mul,
+  multiply: () => multiply,
+  multiplyScalar: () => multiplyScalar,
+  multiplyScalarAndAdd: () => multiplyScalarAndAdd,
+  ortho: () => ortho,
+  orthoNO: () => orthoNO,
+  orthoZO: () => orthoZO,
+  perspective: () => perspective,
+  perspectiveFromFieldOfView: () => perspectiveFromFieldOfView,
+  perspectiveNO: () => perspectiveNO,
+  perspectiveZO: () => perspectiveZO,
+  rotate: () => rotate,
+  rotateX: () => rotateX,
+  rotateY: () => rotateY,
+  rotateZ: () => rotateZ,
+  scale: () => scale,
+  set: () => set,
+  str: () => str,
+  sub: () => sub,
+  subtract: () => subtract,
+  targetTo: () => targetTo,
+  translate: () => translate,
+  transpose: () => transpose
+});
+function create2() {
+  var out = new ARRAY_TYPE(16);
+  if (ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+  }
+  out[0] = 1;
+  out[5] = 1;
+  out[10] = 1;
+  out[15] = 1;
+  return out;
+}
+function clone(a) {
+  var out = new ARRAY_TYPE(16);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  out[9] = a[9];
+  out[10] = a[10];
+  out[11] = a[11];
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+function copy(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  out[9] = a[9];
+  out[10] = a[10];
+  out[11] = a[11];
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
+  var out = new ARRAY_TYPE(16);
+  out[0] = m00;
+  out[1] = m01;
+  out[2] = m02;
+  out[3] = m03;
+  out[4] = m10;
+  out[5] = m11;
+  out[6] = m12;
+  out[7] = m13;
+  out[8] = m20;
+  out[9] = m21;
+  out[10] = m22;
+  out[11] = m23;
+  out[12] = m30;
+  out[13] = m31;
+  out[14] = m32;
+  out[15] = m33;
+  return out;
+}
+function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
+  out[0] = m00;
+  out[1] = m01;
+  out[2] = m02;
+  out[3] = m03;
+  out[4] = m10;
+  out[5] = m11;
+  out[6] = m12;
+  out[7] = m13;
+  out[8] = m20;
+  out[9] = m21;
+  out[10] = m22;
+  out[11] = m23;
+  out[12] = m30;
+  out[13] = m31;
+  out[14] = m32;
+  out[15] = m33;
+  return out;
+}
+function identity(out) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function transpose(out, a) {
+  if (out === a) {
+    var a01 = a[1], a02 = a[2], a03 = a[3];
+    var a12 = a[6], a13 = a[7];
+    var a23 = a[11];
+    out[1] = a[4];
+    out[2] = a[8];
+    out[3] = a[12];
+    out[4] = a01;
+    out[6] = a[9];
+    out[7] = a[13];
+    out[8] = a02;
+    out[9] = a12;
+    out[11] = a[14];
+    out[12] = a03;
+    out[13] = a13;
+    out[14] = a23;
+  } else {
+    out[0] = a[0];
+    out[1] = a[4];
+    out[2] = a[8];
+    out[3] = a[12];
+    out[4] = a[1];
+    out[5] = a[5];
+    out[6] = a[9];
+    out[7] = a[13];
+    out[8] = a[2];
+    out[9] = a[6];
+    out[10] = a[10];
+    out[11] = a[14];
+    out[12] = a[3];
+    out[13] = a[7];
+    out[14] = a[11];
+    out[15] = a[15];
+  }
+  return out;
+}
+function invert(out, a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b00 = a00 * a11 - a01 * a10;
+  var b01 = a00 * a12 - a02 * a10;
+  var b02 = a00 * a13 - a03 * a10;
+  var b03 = a01 * a12 - a02 * a11;
+  var b04 = a01 * a13 - a03 * a11;
+  var b05 = a02 * a13 - a03 * a12;
+  var b06 = a20 * a31 - a21 * a30;
+  var b07 = a20 * a32 - a22 * a30;
+  var b08 = a20 * a33 - a23 * a30;
+  var b09 = a21 * a32 - a22 * a31;
+  var b10 = a21 * a33 - a23 * a31;
+  var b11 = a22 * a33 - a23 * a32;
+  var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) {
+    return null;
+  }
+  det = 1 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+function adjoint(out, a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b00 = a00 * a11 - a01 * a10;
+  var b01 = a00 * a12 - a02 * a10;
+  var b02 = a00 * a13 - a03 * a10;
+  var b03 = a01 * a12 - a02 * a11;
+  var b04 = a01 * a13 - a03 * a11;
+  var b05 = a02 * a13 - a03 * a12;
+  var b06 = a20 * a31 - a21 * a30;
+  var b07 = a20 * a32 - a22 * a30;
+  var b08 = a20 * a33 - a23 * a30;
+  var b09 = a21 * a32 - a22 * a31;
+  var b10 = a21 * a33 - a23 * a31;
+  var b11 = a22 * a33 - a23 * a32;
+  out[0] = a11 * b11 - a12 * b10 + a13 * b09;
+  out[1] = a02 * b10 - a01 * b11 - a03 * b09;
+  out[2] = a31 * b05 - a32 * b04 + a33 * b03;
+  out[3] = a22 * b04 - a21 * b05 - a23 * b03;
+  out[4] = a12 * b08 - a10 * b11 - a13 * b07;
+  out[5] = a00 * b11 - a02 * b08 + a03 * b07;
+  out[6] = a32 * b02 - a30 * b05 - a33 * b01;
+  out[7] = a20 * b05 - a22 * b02 + a23 * b01;
+  out[8] = a10 * b10 - a11 * b08 + a13 * b06;
+  out[9] = a01 * b08 - a00 * b10 - a03 * b06;
+  out[10] = a30 * b04 - a31 * b02 + a33 * b00;
+  out[11] = a21 * b02 - a20 * b04 - a23 * b00;
+  out[12] = a11 * b07 - a10 * b09 - a12 * b06;
+  out[13] = a00 * b09 - a01 * b07 + a02 * b06;
+  out[14] = a31 * b01 - a30 * b03 - a32 * b00;
+  out[15] = a20 * b03 - a21 * b01 + a22 * b00;
+  return out;
+}
+function determinant(a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b0 = a00 * a11 - a01 * a10;
+  var b1 = a00 * a12 - a02 * a10;
+  var b2 = a01 * a12 - a02 * a11;
+  var b3 = a20 * a31 - a21 * a30;
+  var b4 = a20 * a32 - a22 * a30;
+  var b5 = a21 * a32 - a22 * a31;
+  var b6 = a00 * b5 - a01 * b4 + a02 * b3;
+  var b7 = a10 * b5 - a11 * b4 + a12 * b3;
+  var b8 = a20 * b2 - a21 * b1 + a22 * b0;
+  var b9 = a30 * b2 - a31 * b1 + a32 * b0;
+  return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9;
+}
+function multiply(out, a, b) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[4];
+  b1 = b[5];
+  b2 = b[6];
+  b3 = b[7];
+  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[8];
+  b1 = b[9];
+  b2 = b[10];
+  b3 = b[11];
+  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[12];
+  b1 = b[13];
+  b2 = b[14];
+  b3 = b[15];
+  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  return out;
+}
+function translate(out, a, v) {
+  var x = v[0], y = v[1], z = v[2];
+  var a00, a01, a02, a03;
+  var a10, a11, a12, a13;
+  var a20, a21, a22, a23;
+  if (a === out) {
+    out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+    out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+    out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+    out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+  } else {
+    a00 = a[0];
+    a01 = a[1];
+    a02 = a[2];
+    a03 = a[3];
+    a10 = a[4];
+    a11 = a[5];
+    a12 = a[6];
+    a13 = a[7];
+    a20 = a[8];
+    a21 = a[9];
+    a22 = a[10];
+    a23 = a[11];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a03;
+    out[4] = a10;
+    out[5] = a11;
+    out[6] = a12;
+    out[7] = a13;
+    out[8] = a20;
+    out[9] = a21;
+    out[10] = a22;
+    out[11] = a23;
+    out[12] = a00 * x + a10 * y + a20 * z + a[12];
+    out[13] = a01 * x + a11 * y + a21 * z + a[13];
+    out[14] = a02 * x + a12 * y + a22 * z + a[14];
+    out[15] = a03 * x + a13 * y + a23 * z + a[15];
+  }
+  return out;
+}
+function scale(out, a, v) {
+  var x = v[0], y = v[1], z = v[2];
+  out[0] = a[0] * x;
+  out[1] = a[1] * x;
+  out[2] = a[2] * x;
+  out[3] = a[3] * x;
+  out[4] = a[4] * y;
+  out[5] = a[5] * y;
+  out[6] = a[6] * y;
+  out[7] = a[7] * y;
+  out[8] = a[8] * z;
+  out[9] = a[9] * z;
+  out[10] = a[10] * z;
+  out[11] = a[11] * z;
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+function rotate(out, a, rad, axis) {
+  var x = axis[0], y = axis[1], z = axis[2];
+  var len4 = Math.sqrt(x * x + y * y + z * z);
+  var s, c, t;
+  var a00, a01, a02, a03;
+  var a10, a11, a12, a13;
+  var a20, a21, a22, a23;
+  var b00, b01, b02;
+  var b10, b11, b12;
+  var b20, b21, b22;
+  if (len4 < EPSILON) {
+    return null;
+  }
+  len4 = 1 / len4;
+  x *= len4;
+  y *= len4;
+  z *= len4;
+  s = Math.sin(rad);
+  c = Math.cos(rad);
+  t = 1 - c;
+  a00 = a[0];
+  a01 = a[1];
+  a02 = a[2];
+  a03 = a[3];
+  a10 = a[4];
+  a11 = a[5];
+  a12 = a[6];
+  a13 = a[7];
+  a20 = a[8];
+  a21 = a[9];
+  a22 = a[10];
+  a23 = a[11];
+  b00 = x * x * t + c;
+  b01 = y * x * t + z * s;
+  b02 = z * x * t - y * s;
+  b10 = x * y * t - z * s;
+  b11 = y * y * t + c;
+  b12 = z * y * t + x * s;
+  b20 = x * z * t + y * s;
+  b21 = y * z * t - x * s;
+  b22 = z * z * t + c;
+  out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+  out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+  out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+  out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+  out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+  out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+  out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+  out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+  out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+  out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+  out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+  out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+  if (a !== out) {
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  return out;
+}
+function rotateX(out, a, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  var a10 = a[4];
+  var a11 = a[5];
+  var a12 = a[6];
+  var a13 = a[7];
+  var a20 = a[8];
+  var a21 = a[9];
+  var a22 = a[10];
+  var a23 = a[11];
+  if (a !== out) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[4] = a10 * c + a20 * s;
+  out[5] = a11 * c + a21 * s;
+  out[6] = a12 * c + a22 * s;
+  out[7] = a13 * c + a23 * s;
+  out[8] = a20 * c - a10 * s;
+  out[9] = a21 * c - a11 * s;
+  out[10] = a22 * c - a12 * s;
+  out[11] = a23 * c - a13 * s;
+  return out;
+}
+function rotateY(out, a, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  var a00 = a[0];
+  var a01 = a[1];
+  var a02 = a[2];
+  var a03 = a[3];
+  var a20 = a[8];
+  var a21 = a[9];
+  var a22 = a[10];
+  var a23 = a[11];
+  if (a !== out) {
+    out[4] = a[4];
+    out[5] = a[5];
+    out[6] = a[6];
+    out[7] = a[7];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[0] = a00 * c - a20 * s;
+  out[1] = a01 * c - a21 * s;
+  out[2] = a02 * c - a22 * s;
+  out[3] = a03 * c - a23 * s;
+  out[8] = a00 * s + a20 * c;
+  out[9] = a01 * s + a21 * c;
+  out[10] = a02 * s + a22 * c;
+  out[11] = a03 * s + a23 * c;
+  return out;
+}
+function rotateZ(out, a, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  var a00 = a[0];
+  var a01 = a[1];
+  var a02 = a[2];
+  var a03 = a[3];
+  var a10 = a[4];
+  var a11 = a[5];
+  var a12 = a[6];
+  var a13 = a[7];
+  if (a !== out) {
+    out[8] = a[8];
+    out[9] = a[9];
+    out[10] = a[10];
+    out[11] = a[11];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[0] = a00 * c + a10 * s;
+  out[1] = a01 * c + a11 * s;
+  out[2] = a02 * c + a12 * s;
+  out[3] = a03 * c + a13 * s;
+  out[4] = a10 * c - a00 * s;
+  out[5] = a11 * c - a01 * s;
+  out[6] = a12 * c - a02 * s;
+  out[7] = a13 * c - a03 * s;
+  return out;
+}
+function fromTranslation(out, v) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+function fromScaling(out, v) {
+  out[0] = v[0];
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = v[1];
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = v[2];
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromRotation(out, rad, axis) {
+  var x = axis[0], y = axis[1], z = axis[2];
+  var len4 = Math.sqrt(x * x + y * y + z * z);
+  var s, c, t;
+  if (len4 < EPSILON) {
+    return null;
+  }
+  len4 = 1 / len4;
+  x *= len4;
+  y *= len4;
+  z *= len4;
+  s = Math.sin(rad);
+  c = Math.cos(rad);
+  t = 1 - c;
+  out[0] = x * x * t + c;
+  out[1] = y * x * t + z * s;
+  out[2] = z * x * t - y * s;
+  out[3] = 0;
+  out[4] = x * y * t - z * s;
+  out[5] = y * y * t + c;
+  out[6] = z * y * t + x * s;
+  out[7] = 0;
+  out[8] = x * z * t + y * s;
+  out[9] = y * z * t - x * s;
+  out[10] = z * z * t + c;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromXRotation(out, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = c;
+  out[6] = s;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = -s;
+  out[10] = c;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromYRotation(out, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  out[0] = c;
+  out[1] = 0;
+  out[2] = -s;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = s;
+  out[9] = 0;
+  out[10] = c;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromZRotation(out, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  out[0] = c;
+  out[1] = s;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = -s;
+  out[5] = c;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromRotationTranslation(out, q, v) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var xy = x * y2;
+  var xz = x * z2;
+  var yy = y * y2;
+  var yz = y * z2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  out[0] = 1 - (yy + zz);
+  out[1] = xy + wz;
+  out[2] = xz - wy;
+  out[3] = 0;
+  out[4] = xy - wz;
+  out[5] = 1 - (xx + zz);
+  out[6] = yz + wx;
+  out[7] = 0;
+  out[8] = xz + wy;
+  out[9] = yz - wx;
+  out[10] = 1 - (xx + yy);
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+function fromQuat2(out, a) {
+  var translation = new ARRAY_TYPE(3);
+  var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3], ax = a[4], ay = a[5], az = a[6], aw = a[7];
+  var magnitude = bx * bx + by * by + bz * bz + bw * bw;
+  if (magnitude > 0) {
+    translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;
+    translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;
+    translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;
+  } else {
+    translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;
+    translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;
+    translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;
+  }
+  fromRotationTranslation(out, a, translation);
+  return out;
+}
+function getTranslation(out, mat) {
+  out[0] = mat[12];
+  out[1] = mat[13];
+  out[2] = mat[14];
+  return out;
+}
+function getScaling(out, mat) {
+  var m11 = mat[0];
+  var m12 = mat[1];
+  var m13 = mat[2];
+  var m21 = mat[4];
+  var m22 = mat[5];
+  var m23 = mat[6];
+  var m31 = mat[8];
+  var m32 = mat[9];
+  var m33 = mat[10];
+  out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+  out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+  out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+  return out;
+}
+function getRotation(out, mat) {
+  var scaling = new ARRAY_TYPE(3);
+  getScaling(scaling, mat);
+  var is1 = 1 / scaling[0];
+  var is2 = 1 / scaling[1];
+  var is3 = 1 / scaling[2];
+  var sm11 = mat[0] * is1;
+  var sm12 = mat[1] * is2;
+  var sm13 = mat[2] * is3;
+  var sm21 = mat[4] * is1;
+  var sm22 = mat[5] * is2;
+  var sm23 = mat[6] * is3;
+  var sm31 = mat[8] * is1;
+  var sm32 = mat[9] * is2;
+  var sm33 = mat[10] * is3;
+  var trace = sm11 + sm22 + sm33;
+  var S = 0;
+  if (trace > 0) {
+    S = Math.sqrt(trace + 1) * 2;
+    out[3] = 0.25 * S;
+    out[0] = (sm23 - sm32) / S;
+    out[1] = (sm31 - sm13) / S;
+    out[2] = (sm12 - sm21) / S;
+  } else if (sm11 > sm22 && sm11 > sm33) {
+    S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+    out[3] = (sm23 - sm32) / S;
+    out[0] = 0.25 * S;
+    out[1] = (sm12 + sm21) / S;
+    out[2] = (sm31 + sm13) / S;
+  } else if (sm22 > sm33) {
+    S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+    out[3] = (sm31 - sm13) / S;
+    out[0] = (sm12 + sm21) / S;
+    out[1] = 0.25 * S;
+    out[2] = (sm23 + sm32) / S;
+  } else {
+    S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+    out[3] = (sm12 - sm21) / S;
+    out[0] = (sm31 + sm13) / S;
+    out[1] = (sm23 + sm32) / S;
+    out[2] = 0.25 * S;
+  }
+  return out;
+}
+function decompose(out_r, out_t, out_s, mat) {
+  out_t[0] = mat[12];
+  out_t[1] = mat[13];
+  out_t[2] = mat[14];
+  var m11 = mat[0];
+  var m12 = mat[1];
+  var m13 = mat[2];
+  var m21 = mat[4];
+  var m22 = mat[5];
+  var m23 = mat[6];
+  var m31 = mat[8];
+  var m32 = mat[9];
+  var m33 = mat[10];
+  out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+  out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+  out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+  var is1 = 1 / out_s[0];
+  var is2 = 1 / out_s[1];
+  var is3 = 1 / out_s[2];
+  var sm11 = m11 * is1;
+  var sm12 = m12 * is2;
+  var sm13 = m13 * is3;
+  var sm21 = m21 * is1;
+  var sm22 = m22 * is2;
+  var sm23 = m23 * is3;
+  var sm31 = m31 * is1;
+  var sm32 = m32 * is2;
+  var sm33 = m33 * is3;
+  var trace = sm11 + sm22 + sm33;
+  var S = 0;
+  if (trace > 0) {
+    S = Math.sqrt(trace + 1) * 2;
+    out_r[3] = 0.25 * S;
+    out_r[0] = (sm23 - sm32) / S;
+    out_r[1] = (sm31 - sm13) / S;
+    out_r[2] = (sm12 - sm21) / S;
+  } else if (sm11 > sm22 && sm11 > sm33) {
+    S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+    out_r[3] = (sm23 - sm32) / S;
+    out_r[0] = 0.25 * S;
+    out_r[1] = (sm12 + sm21) / S;
+    out_r[2] = (sm31 + sm13) / S;
+  } else if (sm22 > sm33) {
+    S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+    out_r[3] = (sm31 - sm13) / S;
+    out_r[0] = (sm12 + sm21) / S;
+    out_r[1] = 0.25 * S;
+    out_r[2] = (sm23 + sm32) / S;
+  } else {
+    S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+    out_r[3] = (sm12 - sm21) / S;
+    out_r[0] = (sm31 + sm13) / S;
+    out_r[1] = (sm23 + sm32) / S;
+    out_r[2] = 0.25 * S;
+  }
+  return out_r;
+}
+function fromRotationTranslationScale(out, q, v, s) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var xy = x * y2;
+  var xz = x * z2;
+  var yy = y * y2;
+  var yz = y * z2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  var sx = s[0];
+  var sy = s[1];
+  var sz = s[2];
+  out[0] = (1 - (yy + zz)) * sx;
+  out[1] = (xy + wz) * sx;
+  out[2] = (xz - wy) * sx;
+  out[3] = 0;
+  out[4] = (xy - wz) * sy;
+  out[5] = (1 - (xx + zz)) * sy;
+  out[6] = (yz + wx) * sy;
+  out[7] = 0;
+  out[8] = (xz + wy) * sz;
+  out[9] = (yz - wx) * sz;
+  out[10] = (1 - (xx + yy)) * sz;
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+function fromRotationTranslationScaleOrigin(out, q, v, s, o) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var xy = x * y2;
+  var xz = x * z2;
+  var yy = y * y2;
+  var yz = y * z2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  var sx = s[0];
+  var sy = s[1];
+  var sz = s[2];
+  var ox = o[0];
+  var oy = o[1];
+  var oz = o[2];
+  var out0 = (1 - (yy + zz)) * sx;
+  var out1 = (xy + wz) * sx;
+  var out2 = (xz - wy) * sx;
+  var out4 = (xy - wz) * sy;
+  var out5 = (1 - (xx + zz)) * sy;
+  var out6 = (yz + wx) * sy;
+  var out8 = (xz + wy) * sz;
+  var out9 = (yz - wx) * sz;
+  var out10 = (1 - (xx + yy)) * sz;
+  out[0] = out0;
+  out[1] = out1;
+  out[2] = out2;
+  out[3] = 0;
+  out[4] = out4;
+  out[5] = out5;
+  out[6] = out6;
+  out[7] = 0;
+  out[8] = out8;
+  out[9] = out9;
+  out[10] = out10;
+  out[11] = 0;
+  out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);
+  out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);
+  out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);
+  out[15] = 1;
+  return out;
+}
+function fromQuat(out, q) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var yx = y * x2;
+  var yy = y * y2;
+  var zx = z * x2;
+  var zy = z * y2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  out[0] = 1 - yy - zz;
+  out[1] = yx + wz;
+  out[2] = zx - wy;
+  out[3] = 0;
+  out[4] = yx - wz;
+  out[5] = 1 - xx - zz;
+  out[6] = zy + wx;
+  out[7] = 0;
+  out[8] = zx + wy;
+  out[9] = zy - wx;
+  out[10] = 1 - xx - yy;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function frustum(out, left, right, bottom, top, near, far) {
+  var rl = 1 / (right - left);
+  var tb = 1 / (top - bottom);
+  var nf = 1 / (near - far);
+  out[0] = near * 2 * rl;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = near * 2 * tb;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = (right + left) * rl;
+  out[9] = (top + bottom) * tb;
+  out[10] = (far + near) * nf;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = far * near * 2 * nf;
+  out[15] = 0;
+  return out;
+}
+function perspectiveNO(out, fovy, aspect, near, far) {
+  var f = 1 / Math.tan(fovy / 2);
+  out[0] = f / aspect;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = f;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[15] = 0;
+  if (far != null && far !== Infinity) {
+    var nf = 1 / (near - far);
+    out[10] = (far + near) * nf;
+    out[14] = 2 * far * near * nf;
+  } else {
+    out[10] = -1;
+    out[14] = -2 * near;
+  }
+  return out;
+}
+var perspective = perspectiveNO;
+function perspectiveZO(out, fovy, aspect, near, far) {
+  var f = 1 / Math.tan(fovy / 2);
+  out[0] = f / aspect;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = f;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[15] = 0;
+  if (far != null && far !== Infinity) {
+    var nf = 1 / (near - far);
+    out[10] = far * nf;
+    out[14] = far * near * nf;
+  } else {
+    out[10] = -1;
+    out[14] = -near;
+  }
+  return out;
+}
+function perspectiveFromFieldOfView(out, fov, near, far) {
+  var upTan = Math.tan(fov.upDegrees * Math.PI / 180);
+  var downTan = Math.tan(fov.downDegrees * Math.PI / 180);
+  var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180);
+  var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180);
+  var xScale = 2 / (leftTan + rightTan);
+  var yScale = 2 / (upTan + downTan);
+  out[0] = xScale;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = yScale;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = -((leftTan - rightTan) * xScale * 0.5);
+  out[9] = (upTan - downTan) * yScale * 0.5;
+  out[10] = far / (near - far);
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = far * near / (near - far);
+  out[15] = 0;
+  return out;
+}
+function orthoNO(out, left, right, bottom, top, near, far) {
+  var lr = 1 / (left - right);
+  var bt = 1 / (bottom - top);
+  var nf = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 2 * nf;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = (far + near) * nf;
+  out[15] = 1;
+  return out;
+}
+var ortho = orthoNO;
+function orthoZO(out, left, right, bottom, top, near, far) {
+  var lr = 1 / (left - right);
+  var bt = 1 / (bottom - top);
+  var nf = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = nf;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = near * nf;
+  out[15] = 1;
+  return out;
+}
+function lookAt(out, eye, center, up) {
+  var x0, x1, x2, y0, y1, y2, z0, z1, z2, len4;
+  var eyex = eye[0];
+  var eyey = eye[1];
+  var eyez = eye[2];
+  var upx = up[0];
+  var upy = up[1];
+  var upz = up[2];
+  var centerx = center[0];
+  var centery = center[1];
+  var centerz = center[2];
+  if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {
+    return identity(out);
+  }
+  z0 = eyex - centerx;
+  z1 = eyey - centery;
+  z2 = eyez - centerz;
+  len4 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+  z0 *= len4;
+  z1 *= len4;
+  z2 *= len4;
+  x0 = upy * z2 - upz * z1;
+  x1 = upz * z0 - upx * z2;
+  x2 = upx * z1 - upy * z0;
+  len4 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+  if (!len4) {
+    x0 = 0;
+    x1 = 0;
+    x2 = 0;
+  } else {
+    len4 = 1 / len4;
+    x0 *= len4;
+    x1 *= len4;
+    x2 *= len4;
+  }
+  y0 = z1 * x2 - z2 * x1;
+  y1 = z2 * x0 - z0 * x2;
+  y2 = z0 * x1 - z1 * x0;
+  len4 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+  if (!len4) {
+    y0 = 0;
+    y1 = 0;
+    y2 = 0;
+  } else {
+    len4 = 1 / len4;
+    y0 *= len4;
+    y1 *= len4;
+    y2 *= len4;
+  }
+  out[0] = x0;
+  out[1] = y0;
+  out[2] = z0;
+  out[3] = 0;
+  out[4] = x1;
+  out[5] = y1;
+  out[6] = z1;
+  out[7] = 0;
+  out[8] = x2;
+  out[9] = y2;
+  out[10] = z2;
+  out[11] = 0;
+  out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+  out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+  out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+  out[15] = 1;
+  return out;
+}
+function targetTo(out, eye, target, up) {
+  var eyex = eye[0], eyey = eye[1], eyez = eye[2], upx = up[0], upy = up[1], upz = up[2];
+  var z0 = eyex - target[0], z1 = eyey - target[1], z2 = eyez - target[2];
+  var len4 = z0 * z0 + z1 * z1 + z2 * z2;
+  if (len4 > 0) {
+    len4 = 1 / Math.sqrt(len4);
+    z0 *= len4;
+    z1 *= len4;
+    z2 *= len4;
+  }
+  var x0 = upy * z2 - upz * z1, x1 = upz * z0 - upx * z2, x2 = upx * z1 - upy * z0;
+  len4 = x0 * x0 + x1 * x1 + x2 * x2;
+  if (len4 > 0) {
+    len4 = 1 / Math.sqrt(len4);
+    x0 *= len4;
+    x1 *= len4;
+    x2 *= len4;
+  }
+  out[0] = x0;
+  out[1] = x1;
+  out[2] = x2;
+  out[3] = 0;
+  out[4] = z1 * x2 - z2 * x1;
+  out[5] = z2 * x0 - z0 * x2;
+  out[6] = z0 * x1 - z1 * x0;
+  out[7] = 0;
+  out[8] = z0;
+  out[9] = z1;
+  out[10] = z2;
+  out[11] = 0;
+  out[12] = eyex;
+  out[13] = eyey;
+  out[14] = eyez;
+  out[15] = 1;
+  return out;
+}
+function str(a) {
+  return "mat4(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ", " + a[4] + ", " + a[5] + ", " + a[6] + ", " + a[7] + ", " + a[8] + ", " + a[9] + ", " + a[10] + ", " + a[11] + ", " + a[12] + ", " + a[13] + ", " + a[14] + ", " + a[15] + ")";
+}
+function frob(a) {
+  return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]);
+}
+function add(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  out[3] = a[3] + b[3];
+  out[4] = a[4] + b[4];
+  out[5] = a[5] + b[5];
+  out[6] = a[6] + b[6];
+  out[7] = a[7] + b[7];
+  out[8] = a[8] + b[8];
+  out[9] = a[9] + b[9];
+  out[10] = a[10] + b[10];
+  out[11] = a[11] + b[11];
+  out[12] = a[12] + b[12];
+  out[13] = a[13] + b[13];
+  out[14] = a[14] + b[14];
+  out[15] = a[15] + b[15];
+  return out;
+}
+function subtract(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  out[3] = a[3] - b[3];
+  out[4] = a[4] - b[4];
+  out[5] = a[5] - b[5];
+  out[6] = a[6] - b[6];
+  out[7] = a[7] - b[7];
+  out[8] = a[8] - b[8];
+  out[9] = a[9] - b[9];
+  out[10] = a[10] - b[10];
+  out[11] = a[11] - b[11];
+  out[12] = a[12] - b[12];
+  out[13] = a[13] - b[13];
+  out[14] = a[14] - b[14];
+  out[15] = a[15] - b[15];
+  return out;
+}
+function multiplyScalar(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  out[3] = a[3] * b;
+  out[4] = a[4] * b;
+  out[5] = a[5] * b;
+  out[6] = a[6] * b;
+  out[7] = a[7] * b;
+  out[8] = a[8] * b;
+  out[9] = a[9] * b;
+  out[10] = a[10] * b;
+  out[11] = a[11] * b;
+  out[12] = a[12] * b;
+  out[13] = a[13] * b;
+  out[14] = a[14] * b;
+  out[15] = a[15] * b;
+  return out;
+}
+function multiplyScalarAndAdd(out, a, b, scale5) {
+  out[0] = a[0] + b[0] * scale5;
+  out[1] = a[1] + b[1] * scale5;
+  out[2] = a[2] + b[2] * scale5;
+  out[3] = a[3] + b[3] * scale5;
+  out[4] = a[4] + b[4] * scale5;
+  out[5] = a[5] + b[5] * scale5;
+  out[6] = a[6] + b[6] * scale5;
+  out[7] = a[7] + b[7] * scale5;
+  out[8] = a[8] + b[8] * scale5;
+  out[9] = a[9] + b[9] * scale5;
+  out[10] = a[10] + b[10] * scale5;
+  out[11] = a[11] + b[11] * scale5;
+  out[12] = a[12] + b[12] * scale5;
+  out[13] = a[13] + b[13] * scale5;
+  out[14] = a[14] + b[14] * scale5;
+  out[15] = a[15] + b[15] * scale5;
+  return out;
+}
+function exactEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];
+}
+function equals(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+  var a4 = a[4], a5 = a[5], a6 = a[6], a7 = a[7];
+  var a8 = a[8], a9 = a[9], a10 = a[10], a11 = a[11];
+  var a12 = a[12], a13 = a[13], a14 = a[14], a15 = a[15];
+  var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  var b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7];
+  var b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11];
+  var b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON * Math.max(1, Math.abs(a15), Math.abs(b15));
+}
+var mul = multiply;
+var sub = subtract;
+
+// ../../node_modules/gl-matrix/esm/quat.js
+var quat_exports = {};
+__export(quat_exports, {
+  add: () => add4,
+  calculateW: () => calculateW,
+  clone: () => clone4,
+  conjugate: () => conjugate,
+  copy: () => copy4,
+  create: () => create5,
+  dot: () => dot3,
+  equals: () => equals4,
+  exactEquals: () => exactEquals4,
+  exp: () => exp,
+  fromEuler: () => fromEuler,
+  fromMat3: () => fromMat3,
+  fromValues: () => fromValues4,
+  getAngle: () => getAngle,
+  getAxisAngle: () => getAxisAngle,
+  identity: () => identity2,
+  invert: () => invert2,
+  len: () => len3,
+  length: () => length3,
+  lerp: () => lerp3,
+  ln: () => ln,
+  mul: () => mul4,
+  multiply: () => multiply4,
+  normalize: () => normalize3,
+  pow: () => pow,
+  random: () => random3,
+  rotateX: () => rotateX3,
+  rotateY: () => rotateY3,
+  rotateZ: () => rotateZ3,
+  rotationTo: () => rotationTo,
+  scale: () => scale4,
+  set: () => set4,
+  setAxes: () => setAxes,
+  setAxisAngle: () => setAxisAngle,
+  slerp: () => slerp2,
+  sqlerp: () => sqlerp,
+  sqrLen: () => sqrLen3,
+  squaredLength: () => squaredLength3,
+  str: () => str4
+});
+
+// ../../node_modules/gl-matrix/esm/vec3.js
+var vec3_exports = {};
+__export(vec3_exports, {
+  add: () => add2,
+  angle: () => angle,
+  bezier: () => bezier,
+  ceil: () => ceil,
+  clone: () => clone2,
+  copy: () => copy2,
+  create: () => create3,
+  cross: () => cross,
+  dist: () => dist,
+  distance: () => distance,
+  div: () => div,
+  divide: () => divide,
+  dot: () => dot,
+  equals: () => equals2,
+  exactEquals: () => exactEquals2,
+  floor: () => floor,
+  forEach: () => forEach,
+  fromValues: () => fromValues2,
+  hermite: () => hermite,
+  inverse: () => inverse,
+  len: () => len,
+  length: () => length,
+  lerp: () => lerp,
+  max: () => max,
+  min: () => min,
+  mul: () => mul2,
+  multiply: () => multiply2,
+  negate: () => negate,
+  normalize: () => normalize,
+  random: () => random,
+  rotateX: () => rotateX2,
+  rotateY: () => rotateY2,
+  rotateZ: () => rotateZ2,
+  round: () => round2,
+  scale: () => scale2,
+  scaleAndAdd: () => scaleAndAdd,
+  set: () => set2,
+  slerp: () => slerp,
+  sqrDist: () => sqrDist,
+  sqrLen: () => sqrLen,
+  squaredDistance: () => squaredDistance,
+  squaredLength: () => squaredLength,
+  str: () => str2,
+  sub: () => sub2,
+  subtract: () => subtract2,
+  transformMat3: () => transformMat3,
+  transformMat4: () => transformMat4,
+  transformQuat: () => transformQuat,
+  zero: () => zero
+});
+function create3() {
+  var out = new ARRAY_TYPE(3);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+function clone2(a) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function length(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function fromValues2(x, y, z) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function copy2(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function set2(out, x, y, z) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function add2(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  return out;
+}
+function subtract2(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  return out;
+}
+function multiply2(out, a, b) {
+  out[0] = a[0] * b[0];
+  out[1] = a[1] * b[1];
+  out[2] = a[2] * b[2];
+  return out;
+}
+function divide(out, a, b) {
+  out[0] = a[0] / b[0];
+  out[1] = a[1] / b[1];
+  out[2] = a[2] / b[2];
+  return out;
+}
+function ceil(out, a) {
+  out[0] = Math.ceil(a[0]);
+  out[1] = Math.ceil(a[1]);
+  out[2] = Math.ceil(a[2]);
+  return out;
+}
+function floor(out, a) {
+  out[0] = Math.floor(a[0]);
+  out[1] = Math.floor(a[1]);
+  out[2] = Math.floor(a[2]);
+  return out;
+}
+function min(out, a, b) {
+  out[0] = Math.min(a[0], b[0]);
+  out[1] = Math.min(a[1], b[1]);
+  out[2] = Math.min(a[2], b[2]);
+  return out;
+}
+function max(out, a, b) {
+  out[0] = Math.max(a[0], b[0]);
+  out[1] = Math.max(a[1], b[1]);
+  out[2] = Math.max(a[2], b[2]);
+  return out;
+}
+function round2(out, a) {
+  out[0] = round(a[0]);
+  out[1] = round(a[1]);
+  out[2] = round(a[2]);
+  return out;
+}
+function scale2(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  return out;
+}
+function scaleAndAdd(out, a, b, scale5) {
+  out[0] = a[0] + b[0] * scale5;
+  out[1] = a[1] + b[1] * scale5;
+  out[2] = a[2] + b[2] * scale5;
+  return out;
+}
+function distance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function squaredDistance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return x * x + y * y + z * z;
+}
+function squaredLength(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return x * x + y * y + z * z;
+}
+function negate(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  return out;
+}
+function inverse(out, a) {
+  out[0] = 1 / a[0];
+  out[1] = 1 / a[1];
+  out[2] = 1 / a[2];
+  return out;
+}
+function normalize(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var len4 = x * x + y * y + z * z;
+  if (len4 > 0) {
+    len4 = 1 / Math.sqrt(len4);
+  }
+  out[0] = a[0] * len4;
+  out[1] = a[1] * len4;
+  out[2] = a[2] * len4;
+  return out;
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(out, a, b) {
+  var ax = a[0], ay = a[1], az = a[2];
+  var bx = b[0], by = b[1], bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function lerp(out, a, b, t) {
+  var ax = a[0];
+  var ay = a[1];
+  var az = a[2];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  out[2] = az + t * (b[2] - az);
+  return out;
+}
+function slerp(out, a, b, t) {
+  var angle2 = Math.acos(Math.min(Math.max(dot(a, b), -1), 1));
+  var sinTotal = Math.sin(angle2);
+  var ratioA = Math.sin((1 - t) * angle2) / sinTotal;
+  var ratioB = Math.sin(t * angle2) / sinTotal;
+  out[0] = ratioA * a[0] + ratioB * b[0];
+  out[1] = ratioA * a[1] + ratioB * b[1];
+  out[2] = ratioA * a[2] + ratioB * b[2];
+  return out;
+}
+function hermite(out, a, b, c, d, t) {
+  var factorTimes2 = t * t;
+  var factor1 = factorTimes2 * (2 * t - 3) + 1;
+  var factor2 = factorTimes2 * (t - 2) + t;
+  var factor3 = factorTimes2 * (t - 1);
+  var factor4 = factorTimes2 * (3 - 2 * t);
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function bezier(out, a, b, c, d, t) {
+  var inverseFactor = 1 - t;
+  var inverseFactorTimesTwo = inverseFactor * inverseFactor;
+  var factorTimes2 = t * t;
+  var factor1 = inverseFactorTimesTwo * inverseFactor;
+  var factor2 = 3 * t * inverseFactorTimesTwo;
+  var factor3 = 3 * factorTimes2 * inverseFactor;
+  var factor4 = factorTimes2 * t;
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function random(out, scale5) {
+  scale5 = scale5 === void 0 ? 1 : scale5;
+  var r = RANDOM() * 2 * Math.PI;
+  var z = RANDOM() * 2 - 1;
+  var zScale = Math.sqrt(1 - z * z) * scale5;
+  out[0] = Math.cos(r) * zScale;
+  out[1] = Math.sin(r) * zScale;
+  out[2] = z * scale5;
+  return out;
+}
+function transformMat4(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  w = w || 1;
+  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+  return out;
+}
+function transformMat3(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  out[0] = x * m[0] + y * m[3] + z * m[6];
+  out[1] = x * m[1] + y * m[4] + z * m[7];
+  out[2] = x * m[2] + y * m[5] + z * m[8];
+  return out;
+}
+function transformQuat(out, a, q) {
+  var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+  var vx = a[0], vy = a[1], vz = a[2];
+  var tx = qy * vz - qz * vy;
+  var ty = qz * vx - qx * vz;
+  var tz = qx * vy - qy * vx;
+  tx = tx + tx;
+  ty = ty + ty;
+  tz = tz + tz;
+  out[0] = vx + qw * tx + qy * tz - qz * ty;
+  out[1] = vy + qw * ty + qz * tx - qx * tz;
+  out[2] = vz + qw * tz + qx * ty - qy * tx;
+  return out;
+}
+function rotateX2(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0];
+  r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+  r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateY2(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+  r[1] = p[1];
+  r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateZ2(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+  r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+  r[2] = p[2];
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function angle(a, b) {
+  var ax = a[0], ay = a[1], az = a[2], bx = b[0], by = b[1], bz = b[2], mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)), cosine = mag && dot(a, b) / mag;
+  return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+function zero(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  return out;
+}
+function str2(a) {
+  return "vec3(" + a[0] + ", " + a[1] + ", " + a[2] + ")";
+}
+function exactEquals2(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+function equals2(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2];
+  var b0 = b[0], b1 = b[1], b2 = b[2];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
+}
+var sub2 = subtract2;
+var mul2 = multiply2;
+var div = divide;
+var dist = distance;
+var sqrDist = squaredDistance;
+var len = length;
+var sqrLen = squaredLength;
+var forEach = (function() {
+  var vec = create3();
+  return function(a, stride, offset, count, fn, arg) {
+    var i, l;
+    if (!stride) {
+      stride = 3;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      vec[2] = a[i + 2];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+      a[i + 2] = vec[2];
+    }
+    return a;
+  };
+})();
+
+// ../../node_modules/gl-matrix/esm/vec4.js
+var vec4_exports = {};
+__export(vec4_exports, {
+  add: () => add3,
+  ceil: () => ceil2,
+  clone: () => clone3,
+  copy: () => copy3,
+  create: () => create4,
+  cross: () => cross2,
+  dist: () => dist2,
+  distance: () => distance2,
+  div: () => div2,
+  divide: () => divide2,
+  dot: () => dot2,
+  equals: () => equals3,
+  exactEquals: () => exactEquals3,
+  floor: () => floor2,
+  forEach: () => forEach2,
+  fromValues: () => fromValues3,
+  inverse: () => inverse2,
+  len: () => len2,
+  length: () => length2,
+  lerp: () => lerp2,
+  max: () => max2,
+  min: () => min2,
+  mul: () => mul3,
+  multiply: () => multiply3,
+  negate: () => negate2,
+  normalize: () => normalize2,
+  random: () => random2,
+  round: () => round3,
+  scale: () => scale3,
+  scaleAndAdd: () => scaleAndAdd2,
+  set: () => set3,
+  sqrDist: () => sqrDist2,
+  sqrLen: () => sqrLen2,
+  squaredDistance: () => squaredDistance2,
+  squaredLength: () => squaredLength2,
+  str: () => str3,
+  sub: () => sub3,
+  subtract: () => subtract3,
+  transformMat4: () => transformMat42,
+  transformQuat: () => transformQuat2,
+  zero: () => zero2
+});
+function create4() {
+  var out = new ARRAY_TYPE(4);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+  }
+  return out;
+}
+function clone3(a) {
+  var out = new ARRAY_TYPE(4);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  return out;
+}
+function fromValues3(x, y, z, w) {
+  var out = new ARRAY_TYPE(4);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+}
+function copy3(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  return out;
+}
+function set3(out, x, y, z, w) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+}
+function add3(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  out[3] = a[3] + b[3];
+  return out;
+}
+function subtract3(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  out[3] = a[3] - b[3];
+  return out;
+}
+function multiply3(out, a, b) {
+  out[0] = a[0] * b[0];
+  out[1] = a[1] * b[1];
+  out[2] = a[2] * b[2];
+  out[3] = a[3] * b[3];
+  return out;
+}
+function divide2(out, a, b) {
+  out[0] = a[0] / b[0];
+  out[1] = a[1] / b[1];
+  out[2] = a[2] / b[2];
+  out[3] = a[3] / b[3];
+  return out;
+}
+function ceil2(out, a) {
+  out[0] = Math.ceil(a[0]);
+  out[1] = Math.ceil(a[1]);
+  out[2] = Math.ceil(a[2]);
+  out[3] = Math.ceil(a[3]);
+  return out;
+}
+function floor2(out, a) {
+  out[0] = Math.floor(a[0]);
+  out[1] = Math.floor(a[1]);
+  out[2] = Math.floor(a[2]);
+  out[3] = Math.floor(a[3]);
+  return out;
+}
+function min2(out, a, b) {
+  out[0] = Math.min(a[0], b[0]);
+  out[1] = Math.min(a[1], b[1]);
+  out[2] = Math.min(a[2], b[2]);
+  out[3] = Math.min(a[3], b[3]);
+  return out;
+}
+function max2(out, a, b) {
+  out[0] = Math.max(a[0], b[0]);
+  out[1] = Math.max(a[1], b[1]);
+  out[2] = Math.max(a[2], b[2]);
+  out[3] = Math.max(a[3], b[3]);
+  return out;
+}
+function round3(out, a) {
+  out[0] = round(a[0]);
+  out[1] = round(a[1]);
+  out[2] = round(a[2]);
+  out[3] = round(a[3]);
+  return out;
+}
+function scale3(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  out[3] = a[3] * b;
+  return out;
+}
+function scaleAndAdd2(out, a, b, scale5) {
+  out[0] = a[0] + b[0] * scale5;
+  out[1] = a[1] + b[1] * scale5;
+  out[2] = a[2] + b[2] * scale5;
+  out[3] = a[3] + b[3] * scale5;
+  return out;
+}
+function distance2(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  var w = b[3] - a[3];
+  return Math.sqrt(x * x + y * y + z * z + w * w);
+}
+function squaredDistance2(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  var w = b[3] - a[3];
+  return x * x + y * y + z * z + w * w;
+}
+function length2(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var w = a[3];
+  return Math.sqrt(x * x + y * y + z * z + w * w);
+}
+function squaredLength2(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var w = a[3];
+  return x * x + y * y + z * z + w * w;
+}
+function negate2(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  out[3] = -a[3];
+  return out;
+}
+function inverse2(out, a) {
+  out[0] = 1 / a[0];
+  out[1] = 1 / a[1];
+  out[2] = 1 / a[2];
+  out[3] = 1 / a[3];
+  return out;
+}
+function normalize2(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var w = a[3];
+  var len4 = x * x + y * y + z * z + w * w;
+  if (len4 > 0) {
+    len4 = 1 / Math.sqrt(len4);
+  }
+  out[0] = x * len4;
+  out[1] = y * len4;
+  out[2] = z * len4;
+  out[3] = w * len4;
+  return out;
+}
+function dot2(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+}
+function cross2(out, u, v, w) {
+  var A = v[0] * w[1] - v[1] * w[0], B = v[0] * w[2] - v[2] * w[0], C = v[0] * w[3] - v[3] * w[0], D = v[1] * w[2] - v[2] * w[1], E = v[1] * w[3] - v[3] * w[1], F = v[2] * w[3] - v[3] * w[2];
+  var G = u[0];
+  var H = u[1];
+  var I = u[2];
+  var J = u[3];
+  out[0] = H * F - I * E + J * D;
+  out[1] = -(G * F) + I * C - J * B;
+  out[2] = G * E - H * C + J * A;
+  out[3] = -(G * D) + H * B - I * A;
+  return out;
+}
+function lerp2(out, a, b, t) {
+  var ax = a[0];
+  var ay = a[1];
+  var az = a[2];
+  var aw = a[3];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  out[2] = az + t * (b[2] - az);
+  out[3] = aw + t * (b[3] - aw);
+  return out;
+}
+function random2(out, scale5) {
+  scale5 = scale5 === void 0 ? 1 : scale5;
+  var v1, v2, v3, v4;
+  var s1, s2;
+  var rand;
+  rand = RANDOM();
+  v1 = rand * 2 - 1;
+  v2 = (4 * RANDOM() - 2) * Math.sqrt(rand * -rand + rand);
+  s1 = v1 * v1 + v2 * v2;
+  rand = RANDOM();
+  v3 = rand * 2 - 1;
+  v4 = (4 * RANDOM() - 2) * Math.sqrt(rand * -rand + rand);
+  s2 = v3 * v3 + v4 * v4;
+  var d = Math.sqrt((1 - s1) / s2);
+  out[0] = scale5 * v1;
+  out[1] = scale5 * v2;
+  out[2] = scale5 * v3 * d;
+  out[3] = scale5 * v4 * d;
+  return out;
+}
+function transformMat42(out, a, m) {
+  var x = a[0], y = a[1], z = a[2], w = a[3];
+  out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
+  out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
+  out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
+  out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
+  return out;
+}
+function transformQuat2(out, a, q) {
+  var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+  var vx = a[0], vy = a[1], vz = a[2];
+  var tx = qy * vz - qz * vy;
+  var ty = qz * vx - qx * vz;
+  var tz = qx * vy - qy * vx;
+  tx = tx + tx;
+  ty = ty + ty;
+  tz = tz + tz;
+  out[0] = vx + qw * tx + qy * tz - qz * ty;
+  out[1] = vy + qw * ty + qz * tx - qx * tz;
+  out[2] = vz + qw * tz + qx * ty - qy * tx;
+  out[3] = a[3];
+  return out;
+}
+function zero2(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  return out;
+}
+function str3(a) {
+  return "vec4(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ")";
+}
+function exactEquals3(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+}
+function equals3(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+  var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3));
+}
+var sub3 = subtract3;
+var mul3 = multiply3;
+var div2 = divide2;
+var dist2 = distance2;
+var sqrDist2 = squaredDistance2;
+var len2 = length2;
+var sqrLen2 = squaredLength2;
+var forEach2 = (function() {
+  var vec = create4();
+  return function(a, stride, offset, count, fn, arg) {
+    var i, l;
+    if (!stride) {
+      stride = 4;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      vec[2] = a[i + 2];
+      vec[3] = a[i + 3];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+      a[i + 2] = vec[2];
+      a[i + 3] = vec[3];
+    }
+    return a;
+  };
+})();
+
+// ../../node_modules/gl-matrix/esm/quat.js
+function create5() {
+  var out = new ARRAY_TYPE(4);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  out[3] = 1;
+  return out;
+}
+function identity2(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 1;
+  return out;
+}
+function setAxisAngle(out, axis, rad) {
+  rad = rad * 0.5;
+  var s = Math.sin(rad);
+  out[0] = s * axis[0];
+  out[1] = s * axis[1];
+  out[2] = s * axis[2];
+  out[3] = Math.cos(rad);
+  return out;
+}
+function getAxisAngle(out_axis, q) {
+  var rad = Math.acos(q[3]) * 2;
+  var s = Math.sin(rad / 2);
+  if (s > EPSILON) {
+    out_axis[0] = q[0] / s;
+    out_axis[1] = q[1] / s;
+    out_axis[2] = q[2] / s;
+  } else {
+    out_axis[0] = 1;
+    out_axis[1] = 0;
+    out_axis[2] = 0;
+  }
+  return rad;
+}
+function getAngle(a, b) {
+  var dotproduct = dot3(a, b);
+  return Math.acos(2 * dotproduct * dotproduct - 1);
+}
+function multiply4(out, a, b) {
+  var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  var bx = b[0], by = b[1], bz = b[2], bw = b[3];
+  out[0] = ax * bw + aw * bx + ay * bz - az * by;
+  out[1] = ay * bw + aw * by + az * bx - ax * bz;
+  out[2] = az * bw + aw * bz + ax * by - ay * bx;
+  out[3] = aw * bw - ax * bx - ay * by - az * bz;
+  return out;
+}
+function rotateX3(out, a, rad) {
+  rad *= 0.5;
+  var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  var bx = Math.sin(rad), bw = Math.cos(rad);
+  out[0] = ax * bw + aw * bx;
+  out[1] = ay * bw + az * bx;
+  out[2] = az * bw - ay * bx;
+  out[3] = aw * bw - ax * bx;
+  return out;
+}
+function rotateY3(out, a, rad) {
+  rad *= 0.5;
+  var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  var by = Math.sin(rad), bw = Math.cos(rad);
+  out[0] = ax * bw - az * by;
+  out[1] = ay * bw + aw * by;
+  out[2] = az * bw + ax * by;
+  out[3] = aw * bw - ay * by;
+  return out;
+}
+function rotateZ3(out, a, rad) {
+  rad *= 0.5;
+  var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  var bz = Math.sin(rad), bw = Math.cos(rad);
+  out[0] = ax * bw + ay * bz;
+  out[1] = ay * bw - ax * bz;
+  out[2] = az * bw + aw * bz;
+  out[3] = aw * bw - az * bz;
+  return out;
+}
+function calculateW(out, a) {
+  var x = a[0], y = a[1], z = a[2];
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = Math.sqrt(Math.abs(1 - x * x - y * y - z * z));
+  return out;
+}
+function exp(out, a) {
+  var x = a[0], y = a[1], z = a[2], w = a[3];
+  var r = Math.sqrt(x * x + y * y + z * z);
+  var et = Math.exp(w);
+  var s = r > 0 ? et * Math.sin(r) / r : 0;
+  out[0] = x * s;
+  out[1] = y * s;
+  out[2] = z * s;
+  out[3] = et * Math.cos(r);
+  return out;
+}
+function ln(out, a) {
+  var x = a[0], y = a[1], z = a[2], w = a[3];
+  var r = Math.sqrt(x * x + y * y + z * z);
+  var t = r > 0 ? Math.atan2(r, w) / r : 0;
+  out[0] = x * t;
+  out[1] = y * t;
+  out[2] = z * t;
+  out[3] = 0.5 * Math.log(x * x + y * y + z * z + w * w);
+  return out;
+}
+function pow(out, a, b) {
+  ln(out, a);
+  scale4(out, out, b);
+  exp(out, out);
+  return out;
+}
+function slerp2(out, a, b, t) {
+  var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  var bx = b[0], by = b[1], bz = b[2], bw = b[3];
+  var omega, cosom, sinom, scale0, scale1;
+  cosom = ax * bx + ay * by + az * bz + aw * bw;
+  if (cosom < 0) {
+    cosom = -cosom;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+  if (1 - cosom > EPSILON) {
+    omega = Math.acos(cosom);
+    sinom = Math.sin(omega);
+    scale0 = Math.sin((1 - t) * omega) / sinom;
+    scale1 = Math.sin(t * omega) / sinom;
+  } else {
+    scale0 = 1 - t;
+    scale1 = t;
+  }
+  out[0] = scale0 * ax + scale1 * bx;
+  out[1] = scale0 * ay + scale1 * by;
+  out[2] = scale0 * az + scale1 * bz;
+  out[3] = scale0 * aw + scale1 * bw;
+  return out;
+}
+function random3(out) {
+  var u1 = RANDOM();
+  var u2 = RANDOM();
+  var u3 = RANDOM();
+  var sqrt1MinusU1 = Math.sqrt(1 - u1);
+  var sqrtU1 = Math.sqrt(u1);
+  out[0] = sqrt1MinusU1 * Math.sin(2 * Math.PI * u2);
+  out[1] = sqrt1MinusU1 * Math.cos(2 * Math.PI * u2);
+  out[2] = sqrtU1 * Math.sin(2 * Math.PI * u3);
+  out[3] = sqrtU1 * Math.cos(2 * Math.PI * u3);
+  return out;
+}
+function invert2(out, a) {
+  var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+  var dot4 = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
+  var invDot = dot4 ? 1 / dot4 : 0;
+  out[0] = -a0 * invDot;
+  out[1] = -a1 * invDot;
+  out[2] = -a2 * invDot;
+  out[3] = a3 * invDot;
+  return out;
+}
+function conjugate(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  out[3] = a[3];
+  return out;
+}
+function fromMat3(out, m) {
+  var fTrace = m[0] + m[4] + m[8];
+  var fRoot;
+  if (fTrace > 0) {
+    fRoot = Math.sqrt(fTrace + 1);
+    out[3] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[0] = (m[5] - m[7]) * fRoot;
+    out[1] = (m[6] - m[2]) * fRoot;
+    out[2] = (m[1] - m[3]) * fRoot;
+  } else {
+    var i = 0;
+    if (m[4] > m[0]) i = 1;
+    if (m[8] > m[i * 3 + i]) i = 2;
+    var j = (i + 1) % 3;
+    var k = (i + 2) % 3;
+    fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1);
+    out[i] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
+    out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
+    out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
+  }
+  return out;
+}
+function fromEuler(out, x, y, z) {
+  var order = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : ANGLE_ORDER;
+  var halfToRad = Math.PI / 360;
+  x *= halfToRad;
+  z *= halfToRad;
+  y *= halfToRad;
+  var sx = Math.sin(x);
+  var cx = Math.cos(x);
+  var sy = Math.sin(y);
+  var cy = Math.cos(y);
+  var sz = Math.sin(z);
+  var cz = Math.cos(z);
+  switch (order) {
+    case "xyz":
+      out[0] = sx * cy * cz + cx * sy * sz;
+      out[1] = cx * sy * cz - sx * cy * sz;
+      out[2] = cx * cy * sz + sx * sy * cz;
+      out[3] = cx * cy * cz - sx * sy * sz;
+      break;
+    case "xzy":
+      out[0] = sx * cy * cz - cx * sy * sz;
+      out[1] = cx * sy * cz - sx * cy * sz;
+      out[2] = cx * cy * sz + sx * sy * cz;
+      out[3] = cx * cy * cz + sx * sy * sz;
+      break;
+    case "yxz":
+      out[0] = sx * cy * cz + cx * sy * sz;
+      out[1] = cx * sy * cz - sx * cy * sz;
+      out[2] = cx * cy * sz - sx * sy * cz;
+      out[3] = cx * cy * cz + sx * sy * sz;
+      break;
+    case "yzx":
+      out[0] = sx * cy * cz + cx * sy * sz;
+      out[1] = cx * sy * cz + sx * cy * sz;
+      out[2] = cx * cy * sz - sx * sy * cz;
+      out[3] = cx * cy * cz - sx * sy * sz;
+      break;
+    case "zxy":
+      out[0] = sx * cy * cz - cx * sy * sz;
+      out[1] = cx * sy * cz + sx * cy * sz;
+      out[2] = cx * cy * sz + sx * sy * cz;
+      out[3] = cx * cy * cz - sx * sy * sz;
+      break;
+    case "zyx":
+      out[0] = sx * cy * cz - cx * sy * sz;
+      out[1] = cx * sy * cz + sx * cy * sz;
+      out[2] = cx * cy * sz - sx * sy * cz;
+      out[3] = cx * cy * cz + sx * sy * sz;
+      break;
+    default:
+      throw new Error("Unknown angle order " + order);
+  }
+  return out;
+}
+function str4(a) {
+  return "quat(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ")";
+}
+var clone4 = clone3;
+var fromValues4 = fromValues3;
+var copy4 = copy3;
+var set4 = set3;
+var add4 = add3;
+var mul4 = multiply4;
+var scale4 = scale3;
+var dot3 = dot2;
+var lerp3 = lerp2;
+var length3 = length2;
+var len3 = length3;
+var squaredLength3 = squaredLength2;
+var sqrLen3 = squaredLength3;
+var normalize3 = normalize2;
+var exactEquals4 = exactEquals3;
+function equals4(a, b) {
+  return Math.abs(dot2(a, b)) >= 1 - EPSILON;
+}
+var rotationTo = (function() {
+  var tmpvec3 = create3();
+  var xUnitVec3 = fromValues2(1, 0, 0);
+  var yUnitVec3 = fromValues2(0, 1, 0);
+  return function(out, a, b) {
+    var dot4 = dot(a, b);
+    if (dot4 < -0.999999) {
+      cross(tmpvec3, xUnitVec3, a);
+      if (len(tmpvec3) < 1e-6) cross(tmpvec3, yUnitVec3, a);
+      normalize(tmpvec3, tmpvec3);
+      setAxisAngle(out, tmpvec3, Math.PI);
+      return out;
+    } else if (dot4 > 0.999999) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+      out[3] = 1;
+      return out;
+    } else {
+      cross(tmpvec3, a, b);
+      out[0] = tmpvec3[0];
+      out[1] = tmpvec3[1];
+      out[2] = tmpvec3[2];
+      out[3] = 1 + dot4;
+      return normalize3(out, out);
+    }
+  };
+})();
+var sqlerp = (function() {
+  var temp1 = create5();
+  var temp2 = create5();
+  return function(out, a, b, c, d, t) {
+    slerp2(temp1, a, d, t);
+    slerp2(temp2, b, c, t);
+    slerp2(out, temp1, temp2, 2 * t * (1 - t));
+    return out;
+  };
+})();
+var setAxes = (function() {
+  var matr = create();
+  return function(out, view, right, up) {
+    matr[0] = right[0];
+    matr[3] = right[1];
+    matr[6] = right[2];
+    matr[1] = up[0];
+    matr[4] = up[1];
+    matr[7] = up[2];
+    matr[2] = -view[0];
+    matr[5] = -view[1];
+    matr[8] = -view[2];
+    return normalize3(out, fromMat3(out, matr));
+  };
+})();
+
+// ../GenesisGL/src/Core/classes/Camera.ts
+var Camera = class {
+  constructor(viewportWidth, viewportHeight) {
+    this.viewportWidth = viewportWidth;
+    this.viewportHeight = viewportHeight;
+  }
+  viewportWidth;
+  viewportHeight;
+  target = [0, 0, 0];
+  // camera looks at this
+  /* Translation */
+  position = [0, 0, 0];
+  // 3D position
+  /* Zoom */
+  zoom = 1;
+  minZoom = 0.5;
+  maxZoom = 10;
+  zoomSpeed = 0.06;
+  /* Rotation */
+  yaw = 0;
+  // horizontal rotation
+  pitch = 0.5;
+  // vertical rotation
+  near = 0.01;
+  far = 1e3;
+  /* Render Utils */
+  lastViewMatrix;
+  lastProjectionMatrix;
+  // ── Cached matrices (rebuilt only when camera state changes) ──
+  _view = mat4_exports.create();
+  _proj = mat4_exports.create();
+  _mvp = mat4_exports.create();
+  _viewDirty = true;
+  _projDirty = true;
+  /** Translate the camera by a delta. */
+  move(dx, dy, dz = 0) {
+    this.position[0] += dx;
+    this.position[1] += dy;
+    this.position[2] += dz;
+    this._viewDirty = true;
+  }
+  /** Clamp-set the zoom level. */
+  setZoom(zoom) {
+    this.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, zoom));
+    this._viewDirty = true;
+    this._projDirty = true;
+  }
+  /**
+   * Mark the view matrix as dirty so it is rebuilt on the next
+   * {@link getViewMatrix} call.  Call this after directly mutating
+   * {@link target} or {@link position} (e.g. from a follow-camera update).
+   */
+  invalidate() {
+    this._viewDirty = true;
+  }
+  /** Zoom by a signed delta (positive = zoom in). */
+  zoomBy(delta) {
+    const factor = Math.exp(delta * this.zoomSpeed);
+    this.setZoom(this.zoom * factor);
+  }
+  worldToNDC(x, y) {
+    const ndcX = (x - this.position[0]) / this.viewportWidth * 2 * this.zoom;
+    const ndcY = (y - this.position[1]) / this.viewportHeight * 2 * this.zoom;
+    return [ndcX, ndcY];
+  }
+  worldScale(scale5) {
+    return [
+      scale5[0] / this.viewportWidth * 2 * this.zoom,
+      scale5[1] / this.viewportHeight * 2 * this.zoom
+    ];
+  }
+  setViewport(width, height) {
+    this.viewportWidth = width;
+    this.viewportHeight = height;
+    this._projDirty = true;
+  }
+  /** Compute the eye position from yaw/pitch/distance to target. */
+  getComputedPosition() {
+    const radius = vec3_exports.distance(this.position, this.target);
+    const camX = this.target[0] + radius * Math.cos(this.pitch) * Math.sin(this.yaw);
+    const camY = this.target[1] + radius * Math.sin(this.pitch);
+    const camZ = this.target[2] + radius * Math.cos(this.pitch) * Math.cos(this.yaw);
+    return vec3_exports.fromValues(camX, camY, camZ);
+  }
+  /** Build the view matrix (lookAt). Returns a cached matrix rebuilt only when the camera moves. */
+  getViewMatrix() {
+    if (this._viewDirty) {
+      const eye = this.getComputedPosition();
+      mat4_exports.lookAt(this._view, eye, this.target, vec3_exports.fromValues(0, 1, 0));
+      this._viewDirty = false;
+      this.lastViewMatrix = this._view;
+    }
+    return this._view;
+  }
+  /** Build the perspective projection matrix. Returns a cached matrix rebuilt only when viewport/zoom changes. */
+  getProjectionMatrix() {
+    if (this._projDirty) {
+      const aspect = this.viewportWidth / this.viewportHeight;
+      const fov = Math.PI / 4 / this.zoom;
+      mat4_exports.perspective(this._proj, fov, aspect, this.near, this.far);
+      this._projDirty = false;
+      this.lastProjectionMatrix = this._proj;
+    }
+    return this._proj;
+  }
+  worldToNDC3D(x, y, z = 0) {
+    const world = vec4_exports.fromValues(x, y, z, 1);
+    mat4_exports.multiply(this._mvp, this.getProjectionMatrix(), this.getViewMatrix());
+    vec4_exports.transformMat4(world, world, this._mvp);
+    return [world[0] / world[3], world[1] / world[3], world[2] / world[3]];
+  }
+  worldScale3D(scale5) {
+    return [
+      scale5[0] / this.viewportWidth * 2 * this.zoom,
+      scale5[1] / this.viewportHeight * 2 * this.zoom,
+      scale5[2] / ((this.viewportWidth + this.viewportHeight) / 2) * 2 * this.zoom
+    ];
+  }
+  minPitch = -Math.PI / 2 + 1.49;
+  maxPitch = Math.PI / 2 - 0.01;
+  rotate(deltaYaw, deltaPitch) {
+    this.yaw += deltaYaw;
+    this.pitch += deltaPitch;
+    this.pitch = Math.max(this.minPitch, Math.min(this.maxPitch, this.pitch));
+    this._viewDirty = true;
+  }
+};
+
+// ../GenesisGL/src/Core/controls/Mouse/MouseWheelControl.ts
+var MouseWheelControl = class {
+  listeners = [];
+  wheelHandler;
+  enable() {
+    if (this.wheelHandler) return;
+    this.wheelHandler = (e) => {
+      const direction = e.deltaY < 0 ? "up" : "down";
+      this.notify(direction, e.deltaY);
+    };
+    window.addEventListener("wheel", this.wheelHandler, { passive: true });
+  }
+  disable() {
+    if (this.wheelHandler) {
+      window.removeEventListener("wheel", this.wheelHandler);
+      this.wheelHandler = void 0;
+    }
+  }
+  onChange(listener) {
+    this.listeners.push(listener);
+  }
+  /** Remove a previously registered listener. */
+  removeListener(listener) {
+    this.listeners = this.listeners.filter((l) => l !== listener);
+  }
+  notify(direction, delta) {
+    for (const listener of this.listeners) listener(direction, delta);
+  }
+};
+
+// ../GenesisGL/src/Core/controls/Mouse/MouseDragControl.ts
+var MouseDragControl = class {
+  constructor(element) {
+    this.element = element;
+  }
+  element;
+  listeners = [];
+  isDragging = false;
+  dragButton = 0;
+  // 0 = left, 2 = right
+  lastX = 0;
+  lastY = 0;
+  enable() {
+    this.element.addEventListener("mousedown", this.onMouseDown);
+    window.addEventListener("mouseup", this.onMouseUp);
+    window.addEventListener("mousemove", this.onMouseMove);
+  }
+  disable() {
+    this.element.removeEventListener("mousedown", this.onMouseDown);
+    window.removeEventListener("mouseup", this.onMouseUp);
+    window.removeEventListener("mousemove", this.onMouseMove);
+  }
+  onChange(listener) {
+    this.listeners.push(listener);
+  }
+  /** Remove a previously registered listener. */
+  removeListener(listener) {
+    this.listeners = this.listeners.filter((l) => l !== listener);
+  }
+  onMouseDown = (e) => {
+    this.isDragging = true;
+    this.dragButton = e.button;
+    this.lastX = e.clientX;
+    this.lastY = e.clientY;
+  };
+  onMouseUp = () => {
+    this.isDragging = false;
+  };
+  onMouseMove = (e) => {
+    if (!this.isDragging) return;
+    const dx = e.clientX - this.lastX;
+    const dy = e.clientY - this.lastY;
+    this.lastX = e.clientX;
+    this.lastY = e.clientY;
+    for (const listener of this.listeners) listener(dx, dy, this.dragButton);
+  };
+};
+
+// ../GenesisGL/src/Core/controls/Mouse/MousePointerLockControl.ts
+var MousePointerLockControl = class {
+  constructor(element, sensitivity = 1) {
+    this.element = element;
+    this.sensitivity = sensitivity;
+  }
+  element;
+  sensitivity;
+  listeners = [];
+  isEnabled = false;
+  isPointerLocked = false;
+  enable() {
+    if (this.isEnabled) return;
+    this.isEnabled = true;
+    this.element.addEventListener("click", this.requestPointerLock);
+    document.addEventListener("pointerlockchange", this.onPointerLockChange);
+    document.addEventListener("mousemove", this.onMouseMove);
+  }
+  disable() {
+    if (!this.isEnabled) return;
+    this.isEnabled = false;
+    this.element.removeEventListener("click", this.requestPointerLock);
+    document.removeEventListener("pointerlockchange", this.onPointerLockChange);
+    document.removeEventListener("mousemove", this.onMouseMove);
+    if (this.isPointerLocked) document.exitPointerLock();
+  }
+  onChange(listener) {
+    this.listeners.push(listener);
+  }
+  /** Remove a previously registered listener. */
+  removeListener(listener) {
+    this.listeners = this.listeners.filter((l) => l !== listener);
+  }
+  setSensitivity(value) {
+    this.sensitivity = value;
+  }
+  requestPointerLock = () => {
+    this.element.requestPointerLock();
+  };
+  onPointerLockChange = () => {
+    this.isPointerLocked = document.pointerLockElement === this.element;
+  };
+  onMouseMove = (e) => {
+    if (!this.isPointerLocked) return;
+    const dx = e.movementX * this.sensitivity;
+    const dy = e.movementY * this.sensitivity;
+    for (const listener of this.listeners) listener(dx, dy);
+  };
+};
+
+// ../GenesisGL/src/Core/classes/Viewport.ts
+var Viewport = class _Viewport {
+  /**
+   * @param canvasOrId - An HTMLCanvasElement or the `id` attribute of one.
+   * @param width      - Logical viewport width.
+   * @param height     - Logical viewport height.
+   * @param webglCore  - Optional WebGLCore instance. When provided, the existing
+   *                     GL context is reused for viewport resize instead of
+   *                     requesting a new one.
+   */
+  constructor(canvasOrId, width, height, webglCore, options = {}) {
+    this.width = width;
+    this.height = height;
+    this.canvas = typeof canvasOrId === "string" ? document.getElementById(canvasOrId) : canvasOrId;
+    if (!this.canvas) throw new Error("Canvas not found");
+    this.webglCore = webglCore ?? null;
+    this.camera = new Camera(width, height);
+    this.dragControl = new MouseDragControl(this.canvas);
+    this.moveControl = new MousePointerLockControl(this.canvas, 0.25);
+    this.resizeCanvas();
+    this.setupControls(options.pointerLock ?? true);
+    window.addEventListener("resize", this.resizeHandler);
+  }
+  width;
+  height;
+  static zoomInterval = 25;
+  wheelControl = new MouseWheelControl();
+  dragControl;
+  moveControl;
+  lastZoomTime = 0;
+  canvas;
+  scale = 1;
+  webglCore = null;
+  resizeHandler = () => this.resizeCanvas();
+  camera;
+  setupControls(pointerLock) {
+    const zoomInterval = _Viewport.zoomInterval;
+    this.wheelControl.onChange((direction) => {
+      const now = performance.now();
+      if (now - this.lastZoomTime < zoomInterval) return;
+      const zoomDelta = direction === "up" ? 1 : -1;
+      this.camera.zoomBy(zoomDelta);
+      this.lastZoomTime = now;
+    });
+    this.wheelControl.enable();
+    if (pointerLock) {
+      this.moveControl.onChange((dx, dy) => {
+        const factor = 0.01 * this.camera.zoom;
+        this.camera.rotate(-dx * factor, -dy * factor);
+      });
+      this.moveControl.enable();
+    }
+    this.canvas.addEventListener("contextmenu", (e) => e.preventDefault());
+  }
+  isDraggingCamera() {
+    return this.dragControl.isDragging;
+  }
+  resizeCanvas() {
+    const screenWidth = window.innerWidth;
+    const screenHeight = window.innerHeight;
+    const aspectViewport = this.width / this.height;
+    const aspectScreen = screenWidth / screenHeight;
+    let canvasWidth, canvasHeight;
+    if (aspectScreen > aspectViewport) {
+      canvasHeight = screenHeight;
+      canvasWidth = canvasHeight * aspectViewport;
+    } else {
+      canvasWidth = screenWidth;
+      canvasHeight = canvasWidth / aspectViewport;
+    }
+    this.canvas.width = canvasWidth;
+    this.canvas.height = canvasHeight;
+    this.scale = canvasWidth / this.width;
+    const gl = this.webglCore ? this.webglCore.getRenderingContext() : this.canvas.getContext("webgl2") ?? this.canvas.getContext("webgl");
+    if (!gl) throw new Error("WebGL not supported");
+    gl.viewport(0, 0, canvasWidth, canvasHeight);
+    this.camera.setViewport(canvasWidth, canvasHeight);
+  }
+  getCanvas() {
+    return this.canvas;
+  }
+  getWebGLCore() {
+    return this.webglCore;
+  }
+  getScale() {
+    return this.scale;
+  }
+  /** Release event listeners. Call when the viewport is no longer needed. */
+  dispose() {
+    window.removeEventListener("resize", this.resizeHandler);
+    this.wheelControl.disable();
+    this.dragControl.disable();
+    this.moveControl.disable();
+  }
+};
+
+// ../GenesisGL/src/Core/utils/compute-bounds.ts
+function computeVertexBounds(vertices) {
+  if (!vertices || vertices.length === 0) {
+    return { min: [0, 0, 0], max: [0, 0, 0] };
+  }
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (let i = 0; i < vertices.length; i += 3) {
+    const x = vertices[i];
+    const y = vertices[i + 1];
+    const z = vertices[i + 2];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (z < minZ) minZ = z;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+    if (z > maxZ) maxZ = z;
+  }
+  return {
+    min: [minX, minY, minZ],
+    max: [maxX, maxY, maxZ]
+  };
+}
+
+// ../GenesisGL/src/Core/classes/Mesh.ts
+var GL_LINES = 1;
+var GL_TRIANGLES = 4;
+var INITIAL_BOUNDING_BOX = { min: [0, 0, 0], max: [0, 0, 0] };
+var Mesh = class _Mesh {
+  name;
+  vertices;
+  normals;
+  texCoords;
+  indices;
+  mode;
+  material;
+  // ── Skinning data (optional) ─────────────────────────────────
+  /** Per-vertex joint indices (vec4 per vertex, 4 influences). */
+  jointIndices = null;
+  /** Per-vertex joint weights (vec4 per vertex, 4 influences). */
+  jointWeights = null;
+  // WebGL buffers aggregate
+  buffers = null;
+  boundingBox = INITIAL_BOUNDING_BOX;
+  isCollidable = true;
+  isInitialized = false;
+  constructor(name, vertices, normals, material, texCoords = new Float32Array(), indices = null) {
+    this.mode = GL_TRIANGLES;
+    this.name = name;
+    this.normals = normals;
+    this.indices = indices;
+    this.vertices = vertices;
+    this.texCoords = texCoords;
+    this.material = material;
+    this.computeBounds();
+  }
+  setMode(newMode) {
+    this.mode = newMode;
+  }
+  /** Whether this mesh has skinning data for skeletal animation. */
+  get isSkinned() {
+    return this.jointIndices !== null && this.jointWeights !== null;
+  }
+  computeBounds() {
+    this.boundingBox = computeVertexBounds(this.vertices);
+  }
+  clone() {
+    const clonedMesh = new _Mesh(
+      this.name,
+      new Float32Array(this.vertices),
+      new Float32Array(this.normals),
+      this.material,
+      // shallow ref — call Material.clone() if independent material is needed
+      new Float32Array(this.texCoords),
+      this.indices ? this.indices instanceof Uint16Array ? new Uint16Array(this.indices) : new Uint32Array(this.indices) : null
+    );
+    clonedMesh.setMode(this.mode);
+    clonedMesh.isCollidable = this.isCollidable;
+    if (this.jointIndices)
+      clonedMesh.jointIndices = new Float32Array(this.jointIndices);
+    if (this.jointWeights)
+      clonedMesh.jointWeights = new Float32Array(this.jointWeights);
+    return clonedMesh;
+  }
+  /** Initialize GPU buffers safely */
+  initBuffer(webglCore) {
+    const gl = webglCore.getRenderingContext();
+    if (!gl) {
+      console.warn(
+        `[Mesh:${this.name}] GL context not available, skipping buffer init.`
+      );
+      return;
+    }
+    if (this.isInitialized) return;
+    this.buffers = new MeshBuffers();
+    this.buffers.init(gl, this);
+    this.isInitialized = true;
+  }
+  /** Dispose of GPU buffers safely */
+  dispose(webglCore) {
+    const gl = webglCore.getRenderingContext();
+    if (!gl || !this.buffers) return;
+    this.buffers.dispose(gl);
+    this.buffers = null;
+    this.isInitialized = false;
+  }
+};
+var MeshBuffers = class {
+  vao = null;
+  vertexBuffer = null;
+  normalBuffer = null;
+  texCoordBuffer = null;
+  indexBuffer = null;
+  jointIndexBuffer = null;
+  jointWeightBuffer = null;
+  init(gl, mesh) {
+    if (!gl) throw new Error("Cannot init MeshBuffers: invalid GL context");
+    const isWebGL2 = gl instanceof WebGL2RenderingContext;
+    const gl2 = isWebGL2 ? gl : null;
+    if (gl2) {
+      this.vao = gl2.createVertexArray();
+      gl2.bindVertexArray(this.vao);
+    }
+    const program = mesh.material?.program;
+    const aPosition = program ? gl.getAttribLocation(program, "aPosition") : 0;
+    const aNormal = program ? gl.getAttribLocation(program, "aNormal") : 1;
+    const aTexCoord = program ? gl.getAttribLocation(program, "aTexCoord") : 2;
+    this.vertexBuffer = gl.createBuffer();
+    if (!this.vertexBuffer) throw new Error("Failed to create vertex buffer");
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, mesh.vertices, gl.STATIC_DRAW);
+    if (aPosition !== -1) {
+      gl.enableVertexAttribArray(aPosition);
+      gl.vertexAttribPointer(aPosition, 3, gl.FLOAT, false, 0, 0);
+    }
+    this.normalBuffer = gl.createBuffer();
+    if (!this.normalBuffer) throw new Error("Failed to create normal buffer");
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.normalBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, mesh.normals, gl.STATIC_DRAW);
+    if (aNormal !== -1) {
+      gl.enableVertexAttribArray(aNormal);
+      gl.vertexAttribPointer(aNormal, 3, gl.FLOAT, false, 0, 0);
+    }
+    if (mesh.texCoords.length > 0) {
+      this.texCoordBuffer = gl.createBuffer();
+      if (!this.texCoordBuffer)
+        throw new Error("Failed to create texCoord buffer");
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.texCoordBuffer);
+      gl.bufferData(gl.ARRAY_BUFFER, mesh.texCoords, gl.STATIC_DRAW);
+      if (aTexCoord !== -1) {
+        gl.enableVertexAttribArray(aTexCoord);
+        gl.vertexAttribPointer(aTexCoord, 2, gl.FLOAT, false, 0, 0);
+      }
+    }
+    if (mesh.indices && mesh.indices.length > 0) {
+      this.indexBuffer = gl.createBuffer();
+      if (!this.indexBuffer) throw new Error("Failed to create index buffer");
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, mesh.indices, gl.STATIC_DRAW);
+    }
+    const aJointIndices = program ? gl.getAttribLocation(program, "aJointIndices") : -1;
+    if (mesh.jointIndices && mesh.jointIndices.length > 0 && aJointIndices !== -1) {
+      this.jointIndexBuffer = gl.createBuffer();
+      if (!this.jointIndexBuffer)
+        throw new Error("Failed to create joint index buffer");
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.jointIndexBuffer);
+      gl.bufferData(gl.ARRAY_BUFFER, mesh.jointIndices, gl.STATIC_DRAW);
+      gl.enableVertexAttribArray(aJointIndices);
+      gl.vertexAttribPointer(aJointIndices, 4, gl.FLOAT, false, 0, 0);
+    }
+    const aJointWeights = program ? gl.getAttribLocation(program, "aJointWeights") : -1;
+    if (mesh.jointWeights && mesh.jointWeights.length > 0 && aJointWeights !== -1) {
+      this.jointWeightBuffer = gl.createBuffer();
+      if (!this.jointWeightBuffer)
+        throw new Error("Failed to create joint weight buffer");
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.jointWeightBuffer);
+      gl.bufferData(gl.ARRAY_BUFFER, mesh.jointWeights, gl.STATIC_DRAW);
+      gl.enableVertexAttribArray(aJointWeights);
+      gl.vertexAttribPointer(aJointWeights, 4, gl.FLOAT, false, 0, 0);
+    }
+    if (gl2) {
+      gl2.bindVertexArray(null);
+    }
+  }
+  dispose(gl) {
+    if (!gl) {
+      console.warn("Cannot dispose MeshBuffers: invalid GL context");
+      return;
+    }
+    const isWebGL2 = gl instanceof WebGL2RenderingContext;
+    if (this.vertexBuffer) gl.deleteBuffer(this.vertexBuffer);
+    if (this.normalBuffer) gl.deleteBuffer(this.normalBuffer);
+    if (this.texCoordBuffer) gl.deleteBuffer(this.texCoordBuffer);
+    if (this.indexBuffer) gl.deleteBuffer(this.indexBuffer);
+    if (this.jointIndexBuffer) gl.deleteBuffer(this.jointIndexBuffer);
+    if (this.jointWeightBuffer) gl.deleteBuffer(this.jointWeightBuffer);
+    if (isWebGL2 && this.vao) {
+      gl.deleteVertexArray(this.vao);
+    }
+    this.vertexBuffer = this.normalBuffer = this.texCoordBuffer = this.indexBuffer = this.jointIndexBuffer = this.jointWeightBuffer = this.vao = null;
+  }
+};
+
+// ../GenesisGL/src/Core/utils/load-texture.ts
+async function loadWebGlTexture(gl, url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const texture = gl.createTexture();
+    if (!texture) return reject(new Error("Failed to create texture"));
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    const level = 0;
+    const internalFormat = gl.RGBA;
+    const width = 1;
+    const height = 1;
+    const border = 0;
+    const srcFormat = gl.RGBA;
+    const srcType = gl.UNSIGNED_BYTE;
+    const pixel = new Uint8Array([128, 128, 128, 255]);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      level,
+      internalFormat,
+      width,
+      height,
+      border,
+      srcFormat,
+      srcType,
+      pixel
+    );
+    const image = new Image();
+    image.crossOrigin = "anonymous";
+    image.onload = () => {
+      gl.bindTexture(gl.TEXTURE_2D, texture);
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        level,
+        internalFormat,
+        srcFormat,
+        srcType,
+        image
+      );
+      if (isPowerOf2(image.width) && isPowerOf2(image.height)) {
+        gl.generateMipmap(gl.TEXTURE_2D);
+        gl.texParameteri(
+          gl.TEXTURE_2D,
+          gl.TEXTURE_MIN_FILTER,
+          gl.LINEAR_MIPMAP_LINEAR
+        );
+        if (options.repeat) {
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
+        }
+      } else {
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+      }
+      resolve(texture);
+    };
+    image.onerror = reject;
+    image.src = url;
+  });
+}
+function isPowerOf2(value) {
+  return (value & value - 1) === 0;
+}
+
+// ../GenesisGL/src/Core/utils/parse-hex-to-rgb.ts
+function parseHexToRgbArray(hex) {
+  if (hex.startsWith("#")) hex = hex.slice(1);
+  let r = 1, g = 1, b = 1, a = 1;
+  if (hex.length === 6) {
+    r = parseInt(hex.slice(0, 2), 16) / 255;
+    g = parseInt(hex.slice(2, 4), 16) / 255;
+    b = parseInt(hex.slice(4, 6), 16) / 255;
+    a = 1;
+  } else if (hex.length === 8) {
+    r = parseInt(hex.slice(0, 2), 16) / 255;
+    g = parseInt(hex.slice(2, 4), 16) / 255;
+    b = parseInt(hex.slice(4, 6), 16) / 255;
+    a = parseInt(hex.slice(6, 8), 16) / 255;
+  } else {
+    throw new Error("Invalid hex color format. Use #RRGGBB or #RRGGBBAA.");
+  }
+  return [r, g, b, a];
+}
+
+// ../GenesisGL/src/Core/classes/Material.ts
+var MAX_LIGHTS = 5;
+var Material = class _Material {
+  constructor(webglCore, options = {}) {
+    this.webglCore = webglCore;
+    this.program = webglCore.getProgram();
+    const { gl } = webglCore;
+    const names = [
+      "uColor",
+      "uUnlit",
+      "uModel",
+      "uView",
+      "uProjection",
+      "uLightCount",
+      "uUseTexture",
+      "uTexture",
+      // --- LIGHTING UNIFORMS ---
+      "uViewPosition",
+      // Camera position for specular light
+      "uShininess",
+      "uSpecularColor",
+      "uAmbientColor",
+      "uDissolve",
+      "uDiffuseColor",
+      "uLightDirection[0]",
+      "uLightColor[0]",
+      "uLightIntensity[0]",
+      "uLightType[0]",
+      "uLightPosition[0]",
+      // NEW: For Point Lights
+      "uLightConstant[0]",
+      // NEW: Attenuation
+      "uLightLinear[0]",
+      // NEW: Attenuation
+      "uLightQuadratic[0]",
+      // NEW: Attenuation
+      // --- SKINNING UNIFORMS ---
+      "uUseSkinning",
+      "uJointMatrices[0]"
+    ];
+    for (const name of names) {
+      this.uniformLocations[name] = gl.getUniformLocation(this.program, name);
+    }
+    const attribs = [
+      "aPosition",
+      "aNormal",
+      "aTexCoord",
+      "aJointIndices",
+      "aJointWeights"
+    ];
+    for (const name of attribs) {
+      this.attribLocations[name] = gl.getAttribLocation(this.program, name);
+    }
+    Object.assign(this, options);
+  }
+  webglCore;
+  // cache
+  program;
+  uniformLocations = {};
+  attribLocations = {};
+  // Attributes
+  albedoColor = [1, 1, 1, 1];
+  unlit = false;
+  texture;
+  specular = [0.3, 0.3, 0.3];
+  shininess = 64;
+  doubleSided = false;
+  //others
+  ambientColor = [0.1, 0.1, 0.1];
+  // Ka
+  dissolve = 1;
+  // d or Tr
+  diffuse = [1, 1, 1];
+  // Kd
+  /** Physics friction coefficient [0–1]. 0 = no resistance (ice), 1 = instant stop. */
+  friction = 0.3;
+  // ── Pre-allocated light uniform buffers (reused every frame, zero GC pressure) ──
+  _lightDirs = new Float32Array(MAX_LIGHTS * 3);
+  _lightColors = new Float32Array(MAX_LIGHTS * 3);
+  _lightIntensities = new Float32Array(MAX_LIGHTS);
+  _lightTypes = new Int32Array(MAX_LIGHTS);
+  _lightPositions = new Float32Array(MAX_LIGHTS * 3);
+  _lightConstants = new Float32Array(MAX_LIGHTS);
+  _lightLinears = new Float32Array(MAX_LIGHTS);
+  _lightQuadratics = new Float32Array(MAX_LIGHTS);
+  setColorHex(hex) {
+    this.albedoColor = parseHexToRgbArray(hex);
+  }
+  setColor(rgba) {
+    this.albedoColor = rgba;
+    this.dissolve = rgba[3];
+    this.diffuse = [rgba[0], rgba[1], rgba[2]];
+  }
+  /**
+   * Load an image from URL and create a WebGL texture.
+   */
+  async loadTexture(url, options) {
+    const { gl } = this.webglCore;
+    this.texture = await loadWebGlTexture(gl, url, options);
+  }
+  /**
+   * Create an independent copy of this material.
+   * Shares the same WebGL program but copies all mutable properties.
+   * The texture reference is shared (immutable GPU resource).
+   */
+  clone() {
+    const copy5 = new _Material(this.webglCore);
+    copy5.albedoColor = [...this.albedoColor];
+    copy5.specular = [...this.specular];
+    copy5.ambientColor = [...this.ambientColor];
+    copy5.diffuse = [...this.diffuse];
+    copy5.shininess = this.shininess;
+    copy5.dissolve = this.dissolve;
+    copy5.unlit = this.unlit;
+    copy5.doubleSided = this.doubleSided;
+    copy5.friction = this.friction;
+    copy5.texture = this.texture;
+    return copy5;
+  }
+  apply(gl, lights, viewPosition) {
+    if (this.uniformLocations["uColor"])
+      gl.uniform4fv(this.uniformLocations["uColor"], this.albedoColor);
+    if (this.uniformLocations["uUnlit"])
+      gl.uniform1i(this.uniformLocations["uUnlit"], this.unlit ? 1 : 0);
+    if (this.uniformLocations["uShininess"])
+      gl.uniform1f(this.uniformLocations["uShininess"], this.shininess);
+    if (this.uniformLocations["uSpecularColor"])
+      gl.uniform3fv(this.uniformLocations["uSpecularColor"], this.specular);
+    if (this.uniformLocations["uDissolve"])
+      gl.uniform1f(this.uniformLocations["uDissolve"], this.dissolve);
+    if (this.uniformLocations["uAmbientColor"])
+      gl.uniform3fv(this.uniformLocations["uAmbientColor"], this.ambientColor);
+    if (this.uniformLocations["uDiffuseColor"])
+      gl.uniform3fv(this.uniformLocations["uDiffuseColor"], this.diffuse);
+    if (viewPosition && this.uniformLocations["uViewPosition"]) {
+      gl.uniform3fv(this.uniformLocations["uViewPosition"], viewPosition);
+    }
+    const hasTexture = !!this.texture;
+    if (this.uniformLocations["uUseTexture"])
+      gl.uniform1i(this.uniformLocations["uUseTexture"], hasTexture ? 1 : 0);
+    if (hasTexture && this.texture) {
+      gl.activeTexture(gl.TEXTURE0);
+      gl.bindTexture(gl.TEXTURE_2D, this.texture);
+      if (this.uniformLocations["uTexture"])
+        gl.uniform1i(this.uniformLocations["uTexture"], 0);
+    }
+    if (!this.unlit && lights?.length) {
+      const count = Math.min(lights.length, MAX_LIGHTS);
+      if (this.uniformLocations["uLightCount"])
+        gl.uniform1i(this.uniformLocations["uLightCount"], count);
+      for (let i = 0; i < count; i++) {
+        const light = lights[i];
+        const i3 = i * 3;
+        let typeInt = 0;
+        if (light.type === "point") typeInt = 1;
+        else if (light.type === "ambient") typeInt = 2;
+        this._lightTypes[i] = typeInt;
+        const dir = light.direction ?? [0, 0, 0];
+        this._lightDirs[i3] = dir[0];
+        this._lightDirs[i3 + 1] = dir[1];
+        this._lightDirs[i3 + 2] = dir[2];
+        const pos = light.position ?? [0, 0, 0];
+        this._lightPositions[i3] = pos[0];
+        this._lightPositions[i3 + 1] = pos[1];
+        this._lightPositions[i3 + 2] = pos[2];
+        this._lightColors[i3] = light.color[0];
+        this._lightColors[i3 + 1] = light.color[1];
+        this._lightColors[i3 + 2] = light.color[2];
+        this._lightIntensities[i] = light.intensity;
+        this._lightConstants[i] = light.constant;
+        this._lightLinears[i] = light.linear;
+        this._lightQuadratics[i] = light.quadratic;
+      }
+      if (this.uniformLocations["uLightDirection[0]"])
+        gl.uniform3fv(
+          this.uniformLocations["uLightDirection[0]"],
+          this._lightDirs
+        );
+      if (this.uniformLocations["uLightColor[0]"])
+        gl.uniform3fv(
+          this.uniformLocations["uLightColor[0]"],
+          this._lightColors
+        );
+      if (this.uniformLocations["uLightIntensity[0]"])
+        gl.uniform1fv(
+          this.uniformLocations["uLightIntensity[0]"],
+          this._lightIntensities
+        );
+      if (this.uniformLocations["uLightType[0]"])
+        gl.uniform1iv(this.uniformLocations["uLightType[0]"], this._lightTypes);
+      if (this.uniformLocations["uLightPosition[0]"])
+        gl.uniform3fv(
+          this.uniformLocations["uLightPosition[0]"],
+          this._lightPositions
+        );
+      if (this.uniformLocations["uLightConstant[0]"])
+        gl.uniform1fv(
+          this.uniformLocations["uLightConstant[0]"],
+          this._lightConstants
+        );
+      if (this.uniformLocations["uLightLinear[0]"])
+        gl.uniform1fv(
+          this.uniformLocations["uLightLinear[0]"],
+          this._lightLinears
+        );
+      if (this.uniformLocations["uLightQuadratic[0]"])
+        gl.uniform1fv(
+          this.uniformLocations["uLightQuadratic[0]"],
+          this._lightQuadratics
+        );
+    }
+  }
+};
+
+// ../GenesisGL/src/Core/classes/Light.ts
+var Light = class {
+  constructor(type = "directional", position = [0, 10, 0], direction = [0, -1, -1], color = [1, 1, 1], intensity = 1, constant = 1, linear = 0, quadratic = 0) {
+    this.type = type;
+    this.position = position;
+    this.direction = direction;
+    this.color = color;
+    this.intensity = intensity;
+    this.constant = constant;
+    this.linear = linear;
+    this.quadratic = quadratic;
+  }
+  type;
+  position;
+  direction;
+  color;
+  intensity;
+  // Attenuation factors are initialized to standard values (no falloff)
+  constant = 1;
+  linear = 0;
+  quadratic = 0;
+  move(dx, dy, dz) {
+    this.position[0] += dx;
+    this.position[1] += dy;
+    this.position[2] += dz;
+  }
+  rotateY(delta) {
+    if (this.type === "directional") {
+      const cos = Math.cos(delta);
+      const sin = Math.sin(delta);
+      const [x, y, z] = this.direction;
+      this.direction[0] = x * cos - z * sin;
+      this.direction[2] = x * sin + z * cos;
+    }
+  }
+};
+
+// ../GenesisGL/src/Core/classes/Scene.ts
+var Scene = class _Scene {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructor(webglCore) {
+    this.webglCore = webglCore;
+  }
+  webglCore;
+  models = [];
+  modelsMap = /* @__PURE__ */ new Map();
+  lights = [];
+  // ─────────────────────────────────────────────
+  // ░░░ Factory: pre-configured 3-point lighting ░░░
+  // ─────────────────────────────────────────────
+  /**
+   * Create a Scene pre-loaded with a classic **3-point lighting** rig
+   * (ambient + key + fill + back).
+   *
+   * Use this for quick prototyping; for production, create a plain Scene and
+   * add your own lights.
+   */
+  static withDefaultLights(webglCore) {
+    const scene = new _Scene(webglCore);
+    scene.addLight(
+      "ambient_base",
+      new Light("ambient", [0, 0, 0], [0, 0, 0], [0.3, 0.3, 0.35], 0.5)
+    );
+    scene.addLight(
+      "directional_key",
+      new Light(
+        "directional",
+        [5, 10, 5],
+        [-0.5, -1, -0.5],
+        [1, 0.95, 0.9],
+        1.2
+      )
+    );
+    scene.addLight(
+      "directional_fill",
+      new Light(
+        "directional",
+        [-10, 5, 10],
+        [0.5, -0.2, -0.7],
+        [0.8, 0.8, 1],
+        0.5
+      )
+    );
+    scene.addLight(
+      "directional_back",
+      new Light(
+        "directional",
+        [0, 15, -10],
+        [0, -0.8, 1],
+        [1, 1, 1],
+        0.7
+      )
+    );
+    return scene;
+  }
+  /** Register a light source in the scene. */
+  addLight(id, light) {
+    this.lights.push(light);
+  }
+  /** Add a model to the scene with a unique key. */
+  add(id, model) {
+    this.models.push(model);
+    this.modelsMap.set(id, model);
+  }
+  /** Remove a model from the scene by key. */
+  remove(key) {
+    const mesh = this.modelsMap.get(key);
+    if (!mesh) return;
+    this.models = this.models.filter((m) => m !== mesh);
+    this.modelsMap.delete(key);
+  }
+  getModels() {
+    return this.models;
+  }
+  getLights() {
+    return this.lights;
+  }
+  /** Retrieve a model by its key. */
+  getModel(key) {
+    const mesh = this.modelsMap.get(key);
+    return mesh;
+  }
+  hasMesh(key) {
+    return this.modelsMap.has(key);
+  }
+  /** Returns all [id, model] pairs — useful for debug/inspector tools. */
+  getEntries() {
+    return [...this.modelsMap.entries()];
+  }
+  dispose(webglCore) {
+    for (const model of this.models) {
+      model.dispose(webglCore);
+    }
+    this.models.length = 0;
+    this.modelsMap.clear();
+    this.lights.length = 0;
+  }
+};
+
+// ../GenesisGL/src/Core/domain/value-objects/Collider.ts
+var Collider = class {
+  type;
+  offset;
+  size;
+  constructor(type, offset = [0, 0, 0], size = [1, 1, 1]) {
+    this.type = type;
+    this.offset = offset;
+    this.size = size;
+  }
+};
+
+// ../GenesisGL/src/Core/utils/gltf-utils.ts
+function transformPoint(out, m, p) {
+  const v = vec3_exports.fromValues(p[0], p[1], p[2]);
+  vec3_exports.transformMat4(v, v, m);
+  out[0] = v[0];
+  out[1] = v[1];
+  out[2] = v[2];
+}
+function transformAABB(min3, max3, m) {
+  const corners = [
+    [min3[0], min3[1], min3[2]],
+    [min3[0], min3[1], max3[2]],
+    [min3[0], max3[1], min3[2]],
+    [min3[0], max3[1], max3[2]],
+    [max3[0], min3[1], min3[2]],
+    [max3[0], min3[1], max3[2]],
+    [max3[0], max3[1], min3[2]],
+    [max3[0], max3[1], max3[2]]
+  ];
+  const outMin = [Infinity, Infinity, Infinity];
+  const outMax = [-Infinity, -Infinity, -Infinity];
+  const t = [0, 0, 0];
+  for (const c of corners) {
+    transformPoint(t, m, c);
+    for (let i = 0; i < 3; i++) {
+      outMin[i] = Math.min(outMin[i], t[i]);
+      outMax[i] = Math.max(outMax[i], t[i]);
+    }
+  }
+  return { min: outMin, max: outMax };
+}
+
+// ../GenesisGL/src/Core/classes/Model.ts
+var Model = class _Model {
+  name;
+  meshes;
+  collider;
+  translation;
+  rotation;
+  scale;
+  // ── Skeletal animation ──────────────────────────────────────
+  /** The skeleton driving skinned meshes (set after GLB load if present). */
+  skeleton = null;
+  /** Named animation clips available on this model. */
+  animations = /* @__PURE__ */ new Map();
+  /** The currently playing animation clip (if any). */
+  activeAnimation = null;
+  _boundingBox = { min: [0, 0, 0], max: [0, 0, 0] };
+  _bboxDirty = false;
+  _boundsDefinedManually = false;
+  _modelMatrix = mat4_exports.create();
+  _matrixDirty = true;
+  _poseMap = /* @__PURE__ */ new Map();
+  /** World-space AABB, lazily recomputed after any transform change. */
+  get boundingBox() {
+    if (this._bboxDirty && !this._boundsDefinedManually) {
+      this._boundingBox = this.computeBoundingBox();
+      this._bboxDirty = false;
+    }
+    return this._boundingBox;
+  }
+  set boundingBox(value) {
+    this._boundingBox = value;
+    this._bboxDirty = false;
+  }
+  /** When `false` the model is excluded from collision detection. */
+  collidable = true;
+  constructor(meshes, translation = [0, 0, 0], scale5 = [1, 1, 1], _name = "model", skeleton = null) {
+    this.meshes = meshes;
+    this.translation = translation;
+    this.scale = scale5;
+    this.rotation = [0, 0, 0];
+    this.collider = new Collider("box");
+    this.name = _name;
+    this.skeleton = skeleton;
+    this._boundingBox = this.computeBoundingBox();
+    this.translation[1] -= this._boundingBox.min[1];
+    this._matrixDirty = true;
+    this._bboxDirty = true;
+  }
+  // ─────────────────────────────────────────────
+  // ░░░ Transform API ░░░
+  // ─────────────────────────────────────────────
+  /** Set absolute position. Marks matrix and bounding box dirty. */
+  setTranslation(x, y, z) {
+    this.translation = [x, y, z];
+    this._matrixDirty = true;
+    this._bboxDirty = true;
+  }
+  /** Set absolute rotation (radians per axis). */
+  setRotation(x, y, z) {
+    this.rotation = [x, y, z];
+    this._matrixDirty = true;
+    this._bboxDirty = true;
+  }
+  /** Set absolute scale. */
+  setScale(x, y, z) {
+    this.scale = [x, y, z];
+    this._matrixDirty = true;
+    this._bboxDirty = true;
+  }
+  /** Translate the model by a delta. */
+  move(dx, dy, dz = 0) {
+    this.translation[0] += dx;
+    this.translation[1] += dy;
+    this.translation[2] += dz;
+    this._matrixDirty = true;
+    this._bboxDirty = true;
+  }
+  // ─────────────────────────────────────────────
+  // ░░░ Matrix Handling ░░░
+  // ─────────────────────────────────────────────
+  getModelMatrix() {
+    if (this._matrixDirty) {
+      mat4_exports.identity(this._modelMatrix);
+      mat4_exports.translate(this._modelMatrix, this._modelMatrix, this.translation);
+      mat4_exports.rotateX(this._modelMatrix, this._modelMatrix, this.rotation[0]);
+      mat4_exports.rotateY(this._modelMatrix, this._modelMatrix, this.rotation[1]);
+      mat4_exports.rotateZ(this._modelMatrix, this._modelMatrix, this.rotation[2]);
+      mat4_exports.scale(this._modelMatrix, this._modelMatrix, this.scale);
+      this._matrixDirty = false;
+    }
+    return this._modelMatrix;
+  }
+  // ─────────────────────────────────────────────
+  // ░░░ Bounding Box & Collider ░░░
+  // ─────────────────────────────────────────────
+  /**
+   * Manually define the collision bounding box relative to the model's
+   * current translation.
+   */
+  setBounds(xOffset, yOffset, zOffset, width, height, depth) {
+    this.boundingBox.min = [
+      this.translation[0] + xOffset,
+      this.translation[1] + yOffset,
+      this.translation[2] + zOffset
+    ];
+    this.boundingBox.max = [
+      this.boundingBox.min[0] + width,
+      this.boundingBox.min[1] + height,
+      this.boundingBox.min[2] + depth
+    ];
+    this._boundsDefinedManually = true;
+  }
+  computeBoundingBox() {
+    if (this.meshes.length === 0) {
+      return { min: [...this.translation], max: [...this.translation] };
+    }
+    const modelMat = this.getModelMatrix();
+    let effectiveMat = modelMat;
+    if (this.skeleton) {
+      effectiveMat = mat4_exports.create();
+      mat4_exports.multiply(effectiveMat, modelMat, this.skeleton.rootTransform);
+    }
+    const min3 = [Infinity, Infinity, Infinity];
+    const max3 = [-Infinity, -Infinity, -Infinity];
+    for (const mesh of this.meshes) {
+      if (!mesh.isCollidable) continue;
+      mesh.computeBounds();
+      const mb = mesh.boundingBox;
+      const isDegenerate = mb.min[0] === mb.max[0] && mb.min[1] === mb.max[1] && mb.min[2] === mb.max[2];
+      if (isDegenerate) continue;
+      const transformed = transformAABB(
+        mesh.boundingBox.min,
+        mesh.boundingBox.max,
+        effectiveMat
+      );
+      for (let i = 0; i < 3; i++) {
+        min3[i] = Math.min(min3[i], transformed.min[i]);
+        max3[i] = Math.max(max3[i], transformed.max[i]);
+      }
+    }
+    if (!isFinite(min3[0])) {
+      const t = effectiveMat;
+      const tx = t[12];
+      const ty = t[13];
+      const tz = t[14];
+      return {
+        min: [tx - 0.5, ty, tz - 0.5],
+        max: [tx + 0.5, ty + 1, tz + 0.5]
+      };
+    }
+    return { min: min3, max: max3 };
+  }
+  /** Recompute the world-space AABB from mesh data (unless manually set). */
+  updateBoundingBox() {
+    if (this._boundsDefinedManually) return;
+    this.boundingBox = this.computeBoundingBox();
+  }
+  /** World-space centre of the bounding box. */
+  getCenter() {
+    const { min: min3, max: max3 } = this.boundingBox;
+    return [
+      (min3[0] + max3[0]) / 2,
+      (min3[1] + max3[1]) / 2,
+      (min3[2] + max3[2]) / 2
+    ];
+  }
+  /** Extents of the bounding box in each axis. */
+  getSize() {
+    const { min: min3, max: max3 } = this.boundingBox;
+    return [max3[0] - min3[0], max3[1] - min3[1], max3[2] - min3[2]];
+  }
+  /** Test for intersection with another model using their colliders. */
+  intersects(other) {
+    const a = this.collider;
+    const b = other.collider;
+    if (a.type !== "box" || b.type !== "box") {
+      console.warn(
+        `[Model] Collider types '${a.type}' / '${b.type}' not yet implemented \u2014 falling back to AABB.`
+      );
+    }
+    return this.intersectAABB(other);
+  }
+  intersectAABB(other) {
+    const a = this.boundingBox;
+    const b = other.boundingBox;
+    return !(a.max[0] < b.min[0] || a.min[0] > b.max[0] || a.max[1] < b.min[1] || a.min[1] > b.max[1] || a.max[2] < b.min[2] || a.min[2] > b.max[2]);
+  }
+  // ─────────────────────────────────────────────
+  // ░░░ Resource Management ░░░
+  // ─────────────────────────────────────────────
+  /** Release all GPU resources held by this model's meshes. */
+  dispose(glCore) {
+    for (const mesh of this.meshes) {
+      mesh.dispose?.(glCore);
+    }
+    this.meshes = [];
+  }
+  // ─────────────────────────────────────────────
+  // ░░░ Cloning ░░░
+  // ─────────────────────────────────────────────
+  /** Deep-clone the model including all meshes. Materials are shared. */
+  clone() {
+    const clonedMeshes = this.meshes.map((m) => m.clone ? m.clone() : m);
+    const c = new _Model(
+      clonedMeshes,
+      [...this.translation],
+      [...this.scale],
+      this.name,
+      this.skeleton?.clone() ?? null
+    );
+    c.rotation = [...this.rotation];
+    c.collider = new Collider(this.collider.type);
+    c.boundingBox = {
+      min: [...this.boundingBox.min],
+      max: [...this.boundingBox.max]
+    };
+    for (const [name, clip] of this.animations) {
+      c.animations.set(name, clip.clone());
+    }
+    return c;
+  }
+  // ─────────────────────────────────────────────
+  // ░░░ Animation ░░░
+  // ─────────────────────────────────────────────
+  /**
+   * Start playing a named animation clip.
+   * @param name - Must match a key in {@link animations}.
+   * @param loop - Whether the clip should loop (default `true`).
+   */
+  playAnimation(name, loop = true) {
+    const clip = this.animations.get(name);
+    if (!clip) {
+      console.warn(`[Model:${this.name}] Animation "${name}" not found`);
+      return;
+    }
+    this.activeAnimation = clip;
+    clip.loop = loop;
+    clip.reset();
+    clip.play();
+  }
+  /** Pause the active animation without rewinding. */
+  pauseAnimation() {
+    this.activeAnimation?.pause();
+  }
+  /** Stop the active animation and rewind. */
+  stopAnimation() {
+    if (this.activeAnimation) {
+      this.activeAnimation.stop();
+      this.activeAnimation = null;
+    }
+  }
+  /** List the names of all available animations. */
+  getAnimationNames() {
+    return [...this.animations.keys()];
+  }
+  /**
+   * Advance animation and recompute joint matrices.
+   * Call this every frame from your game loop.
+   *
+   * @param deltaTime - Elapsed time in seconds since the last frame.
+   */
+  update(deltaTime) {
+    if (!this.activeAnimation || !this.skeleton) return;
+    this.activeAnimation.update(deltaTime);
+    this.activeAnimation.sample(this._poseMap);
+    this.skeleton.computeJointMatrices(this._poseMap);
+  }
+};
+
+// ../GenesisGL/src/Core/classes/AnimationClip.ts
+var _sv0Vec3 = vec3_exports.create();
+var _sv1Vec3 = vec3_exports.create();
+var _sOutVec3 = vec3_exports.create();
+var _sv0Quat = quat_exports.create();
+var _sv1Quat = quat_exports.create();
+var _sOutQuat = quat_exports.create();
+
+// ../GenesisGL/src/Core/utils/create-wire-box.ts
+function createWireBox(min3, max3, material) {
+  const [minX, minY, minZ] = min3;
+  const [maxX, maxY, maxZ] = max3;
+  const vertices = [
+    minX,
+    minY,
+    minZ,
+    maxX,
+    minY,
+    minZ,
+    maxX,
+    maxY,
+    minZ,
+    minX,
+    maxY,
+    minZ,
+    minX,
+    minY,
+    maxZ,
+    maxX,
+    minY,
+    maxZ,
+    maxX,
+    maxY,
+    maxZ,
+    minX,
+    maxY,
+    maxZ
+  ];
+  const indices = [
+    0,
+    1,
+    1,
+    2,
+    2,
+    3,
+    3,
+    0,
+    // bottom face
+    4,
+    5,
+    5,
+    6,
+    6,
+    7,
+    7,
+    4,
+    // top face
+    0,
+    4,
+    1,
+    5,
+    2,
+    6,
+    3,
+    7
+    // vertical edges
+  ];
+  const lineVertices = [];
+  for (let i = 0; i < indices.length; i++) {
+    const idx = indices[i];
+    lineVertices.push(
+      vertices[idx * 3],
+      vertices[idx * 3 + 1],
+      vertices[idx * 3 + 2]
+    );
+  }
+  const normals = new Float32Array(lineVertices.length);
+  const mesh = new Mesh(
+    "hitbox",
+    new Float32Array(lineVertices),
+    normals,
+    material,
+    new Float32Array(),
+    null
+  );
+  mesh.setMode(GL_LINES);
+  return mesh;
+}
+
+// ../GenesisGL/src/Core/classes/Renderer.ts
+var Renderer = class {
+  constructor(webglCore, viewport) {
+    this.webglCore = webglCore;
+    this.viewport = viewport;
+    const gl = webglCore.getRenderingContext();
+    this._isWebGL2 = gl instanceof WebGL2RenderingContext;
+    if (gl) gl.enable(gl.DEPTH_TEST);
+  }
+  webglCore;
+  viewport;
+  /** Set to `true` to render wireframe bounding boxes for debugging. */
+  debug = false;
+  // Cached debug materials to avoid per-frame GPU allocations
+  _modelHitboxMaterial = null;
+  _meshHitboxMaterial = null;
+  // Cache wire-box debug meshes: recreated only when the bounding box changes.
+  _modelWireBoxCache = /* @__PURE__ */ new WeakMap();
+  _meshWireBoxCache = /* @__PURE__ */ new WeakMap();
+  /** Pre-allocated identity matrix for world-space hitbox draws. */
+  _identity = mat4_exports.create();
+  /** Cached `gl instanceof WebGL2RenderingContext` — computed once at construction. */
+  _isWebGL2;
+  /** Lazily-created material for model-level hitboxes (red). */
+  get modelHitboxMaterial() {
+    if (!this._modelHitboxMaterial) {
+      this._modelHitboxMaterial = new Material(this.webglCore);
+      this._modelHitboxMaterial.setColorHex("#ff0404ff");
+      this._modelHitboxMaterial.unlit = true;
+    }
+    return this._modelHitboxMaterial;
+  }
+  /** Lazily-created material for mesh-level hitboxes (green). */
+  get meshHitboxMaterial() {
+    if (!this._meshHitboxMaterial) {
+      this._meshHitboxMaterial = new Material(this.webglCore);
+      this._meshHitboxMaterial.setColorHex("#04ff0cff");
+      this._meshHitboxMaterial.unlit = true;
+    }
+    return this._meshHitboxMaterial;
+  }
+  clearFrame(color = [0.2, 0.5, 0.95, 1]) {
+    const gl = this.webglCore.getRenderingContext();
+    if (!gl) return;
+    gl.clearColor(...color);
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+  }
+  render(scene) {
+    const gl = this.webglCore.getRenderingContext();
+    if (!gl) return;
+    const models = scene.getModels();
+    const lights = scene.getLights();
+    const camera = this.viewport.camera;
+    const viewPosition = camera.getComputedPosition();
+    this.clearFrame();
+    const viewMatrix = camera.getViewMatrix();
+    const projMatrix = camera.getProjectionMatrix();
+    let activeProgram = null;
+    for (const model of models) {
+      activeProgram = this.drawModel(
+        gl,
+        model,
+        lights,
+        viewPosition,
+        viewMatrix,
+        projMatrix,
+        activeProgram
+      );
+    }
+  }
+  drawModel(gl, model, lights, viewPosition, viewMatrix, projMatrix, activeProgram) {
+    const modelMatrix = model.getModelMatrix();
+    const hasSkeleton = model.skeleton !== null;
+    for (const mesh of model.meshes) {
+      activeProgram = this.drawMesh(
+        mesh,
+        lights,
+        viewPosition,
+        modelMatrix,
+        viewMatrix,
+        projMatrix,
+        activeProgram,
+        hasSkeleton && mesh.isSkinned ? model : null
+      );
+      if (this.debug) {
+        this.drawHitBoxForMesh(
+          mesh,
+          modelMatrix,
+          viewMatrix,
+          projMatrix,
+          activeProgram
+        );
+      }
+    }
+    if (this.debug) {
+      this.drawHitBox(model, activeProgram);
+    }
+    return activeProgram;
+  }
+  drawMesh(mesh, lights, viewPosition, modelMatrix, viewMatrix, projMatrix, activeProgram, skinnedModel = null) {
+    const gl = this.webglCore.getRenderingContext();
+    if (!gl) return activeProgram;
+    if (!mesh.material) return activeProgram;
+    mesh.initBuffer(this.webglCore);
+    const { program, uniformLocations } = mesh.material;
+    if (program !== activeProgram) {
+      gl.useProgram(program);
+      activeProgram = program;
+      if (uniformLocations["uView"])
+        gl.uniformMatrix4fv(uniformLocations["uView"], false, viewMatrix);
+      if (uniformLocations["uProjection"])
+        gl.uniformMatrix4fv(uniformLocations["uProjection"], false, projMatrix);
+    }
+    const isWebGL2 = this._isWebGL2;
+    if (isWebGL2 && mesh.buffers?.vao) {
+      gl.bindVertexArray(
+        mesh.buffers.vao
+      );
+    } else {
+      const aPosition = mesh.material.attribLocations["aPosition"];
+      if (aPosition !== -1 && mesh.buffers?.vertexBuffer) {
+        gl.bindBuffer(gl.ARRAY_BUFFER, mesh.buffers.vertexBuffer);
+        gl.enableVertexAttribArray(aPosition);
+        gl.vertexAttribPointer(aPosition, 3, gl.FLOAT, false, 0, 0);
+      }
+      const aNormal = mesh.material.attribLocations["aNormal"];
+      if (aNormal !== -1 && mesh.buffers?.normalBuffer) {
+        gl.bindBuffer(gl.ARRAY_BUFFER, mesh.buffers.normalBuffer);
+        gl.enableVertexAttribArray(aNormal);
+        gl.vertexAttribPointer(aNormal, 3, gl.FLOAT, false, 0, 0);
+      }
+      const aTexCoord = mesh.material.attribLocations["aTexCoord"];
+      if (aTexCoord !== -1 && mesh.buffers?.texCoordBuffer) {
+        gl.bindBuffer(gl.ARRAY_BUFFER, mesh.buffers.texCoordBuffer);
+        gl.enableVertexAttribArray(aTexCoord);
+        gl.vertexAttribPointer(aTexCoord, 2, gl.FLOAT, false, 0, 0);
+      }
+      const aJointIndices = mesh.material.attribLocations["aJointIndices"];
+      if (aJointIndices !== -1 && mesh.buffers?.jointIndexBuffer) {
+        gl.bindBuffer(gl.ARRAY_BUFFER, mesh.buffers.jointIndexBuffer);
+        gl.enableVertexAttribArray(aJointIndices);
+        gl.vertexAttribPointer(aJointIndices, 4, gl.FLOAT, false, 0, 0);
+      }
+      const aJointWeights = mesh.material.attribLocations["aJointWeights"];
+      if (aJointWeights !== -1 && mesh.buffers?.jointWeightBuffer) {
+        gl.bindBuffer(gl.ARRAY_BUFFER, mesh.buffers.jointWeightBuffer);
+        gl.enableVertexAttribArray(aJointWeights);
+        gl.vertexAttribPointer(aJointWeights, 4, gl.FLOAT, false, 0, 0);
+      }
+    }
+    mesh.material.apply(gl, lights, viewPosition);
+    const uUseSkinning = uniformLocations["uUseSkinning"];
+    const skeleton = skinnedModel?.skeleton ?? null;
+    if (skeleton && mesh.isSkinned) {
+      if (uUseSkinning) gl.uniform1i(uUseSkinning, 1);
+      const uJointMatrices = uniformLocations["uJointMatrices[0]"];
+      if (uJointMatrices) {
+        gl.uniformMatrix4fv(uJointMatrices, false, skeleton.jointMatrices);
+      }
+    } else {
+      if (uUseSkinning) gl.uniform1i(uUseSkinning, 0);
+    }
+    const uModel = mesh.material.uniformLocations["uModel"];
+    if (uModel) gl.uniformMatrix4fv(uModel, false, modelMatrix);
+    if (mesh.buffers?.indexBuffer && mesh.indices) {
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, mesh.buffers.indexBuffer);
+      const type = mesh.indices instanceof Uint32Array ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      gl.drawElements(mesh.mode, mesh.indices.length, type, 0);
+    } else {
+      gl.drawArrays(mesh.mode, 0, mesh.vertices.length / 3);
+    }
+    if (isWebGL2 && mesh.buffers?.vao) {
+      gl.bindVertexArray(null);
+    } else {
+      gl.bindBuffer(gl.ARRAY_BUFFER, null);
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    }
+    return activeProgram;
+  }
+  drawHitBox(model, activeProgram) {
+    const bbox = model.boundingBox;
+    const key = `${bbox.min[0]},${bbox.min[1]},${bbox.min[2]},${bbox.max[0]},${bbox.max[1]},${bbox.max[2]}`;
+    const cached = this._modelWireBoxCache.get(model);
+    let hitboxMesh;
+    if (!cached || cached.key !== key) {
+      hitboxMesh = createWireBox(bbox.min, bbox.max, this.modelHitboxMaterial);
+      hitboxMesh.isCollidable = false;
+      this._modelWireBoxCache.set(model, { mesh: hitboxMesh, key });
+    } else {
+      hitboxMesh = cached.mesh;
+    }
+    const camera = this.viewport.camera;
+    const viewMatrix = camera.getViewMatrix();
+    const projMatrix = camera.getProjectionMatrix();
+    this.drawMesh(
+      hitboxMesh,
+      [],
+      camera.position,
+      this._identity,
+      viewMatrix,
+      projMatrix,
+      activeProgram
+    );
+  }
+  drawHitBoxForMesh(mesh, modelMatrix, viewMatrix, projMatrix, activeProgram) {
+    if (!mesh.boundingBox) return;
+    const { min: min3, max: max3 } = mesh.boundingBox;
+    const key = `${min3[0]},${min3[1]},${min3[2]},${max3[0]},${max3[1]},${max3[2]}`;
+    const cached = this._meshWireBoxCache.get(mesh);
+    let wireBox;
+    if (!cached || cached.key !== key) {
+      wireBox = createWireBox(min3, max3, this.meshHitboxMaterial);
+      wireBox.isCollidable = false;
+      this._meshWireBoxCache.set(mesh, { mesh: wireBox, key });
+    } else {
+      wireBox = cached.mesh;
+    }
+    const camera = this.viewport.camera;
+    this.drawMesh(
+      wireBox,
+      [],
+      camera.position,
+      modelMatrix,
+      viewMatrix,
+      projMatrix,
+      activeProgram
+    );
+  }
+};
+
+// ../GenesisGL/src/Core/utils/parse-obj.ts
+function computeNormal(p1, p2, p3) {
+  const u = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+  const v = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+  return [
+    u[1] * v[2] - u[2] * v[1],
+    u[2] * v[0] - u[0] * v[2],
+    u[0] * v[1] - u[1] * v[0]
+  ];
+}
+async function loadMTL(url, webglCore) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Failed to load MTL: ${url}`);
+  const text = await response.text();
+  const materials = {};
+  let current = null;
+  const basePath = url.split("/").slice(0, -1).join("/") + "/";
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const parts = trimmed.split(/\s+/);
+    switch (parts[0].toLowerCase()) {
+      case "newmtl":
+        current = new Material(webglCore, { albedoColor: [1, 1, 1, 1] });
+        materials[parts[1]] = current;
+        break;
+      case "kd":
+        if (!current) continue;
+        current.diffuse = [
+          parseFloat(parts[1]),
+          parseFloat(parts[2]),
+          parseFloat(parts[3])
+        ];
+        current.albedoColor = [...current.diffuse, 1];
+        break;
+      case "ks":
+        if (!current) continue;
+        current.specular = [
+          parseFloat(parts[1]),
+          parseFloat(parts[2]),
+          parseFloat(parts[3])
+        ];
+        break;
+      case "ns":
+        if (!current) continue;
+        current.shininess = parseFloat(parts[1]);
+        break;
+      case "map_kd":
+        if (!current) continue;
+        await current.loadTexture(basePath + parts[1]);
+        break;
+    }
+  }
+  return materials;
+}
+async function loadOBJWithMTL(webglCore, objUrl, mtlUrl, translation = [0, 0, 0], scale5 = [1, 1, 1], defaultMaterial = new Material(webglCore, { albedoColor: [1, 1, 1, 1] })) {
+  const materials = mtlUrl ? await loadMTL(mtlUrl, webglCore) : {};
+  const response = await fetch(objUrl);
+  if (!response.ok) throw new Error(`Failed to load OBJ: ${objUrl}`);
+  const objText = await response.text();
+  const positions = [];
+  const texCoords = [];
+  const vertexNormals = [];
+  const meshesData = {};
+  let currentMaterialName = null;
+  const lines = objText.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const parts = trimmed.split(/\s+/);
+    switch (parts[0]) {
+      case "v":
+        positions.push([
+          parseFloat(parts[1]),
+          parseFloat(parts[2]),
+          parseFloat(parts[3])
+        ]);
+        break;
+      case "vt":
+        texCoords.push([
+          parseFloat(parts[1]),
+          1 - parseFloat(parts[2])
+          // flip V for WebGL
+        ]);
+        break;
+      case "vn":
+        vertexNormals.push([
+          parseFloat(parts[1]),
+          parseFloat(parts[2]),
+          parseFloat(parts[3])
+        ]);
+        break;
+      case "usemtl":
+        currentMaterialName = parts[1];
+        if (!meshesData[currentMaterialName])
+          meshesData[currentMaterialName] = {
+            vertices: [],
+            normals: [],
+            uvs: []
+          };
+        break;
+      case "f": {
+        if (!currentMaterialName) currentMaterialName = "default";
+        if (!meshesData[currentMaterialName])
+          meshesData[currentMaterialName] = {
+            vertices: [],
+            normals: [],
+            uvs: []
+          };
+        const faceVertices = parts.slice(1).map((token) => {
+          const [v, vt, vn] = token.split("/");
+          let vIdx = parseInt(v);
+          let tIdx = vt ? parseInt(vt) : null;
+          let nIdx = vn ? parseInt(vn) : null;
+          if (vIdx < 0) vIdx = positions.length + vIdx;
+          else vIdx--;
+          if (tIdx !== null) {
+            if (tIdx < 0) tIdx = texCoords.length + tIdx;
+            else tIdx--;
+          }
+          if (nIdx !== null) {
+            if (nIdx < 0) nIdx = vertexNormals.length + nIdx;
+            else nIdx--;
+          }
+          return { vIdx, tIdx, nIdx };
+        });
+        const { vertices, normals, uvs } = meshesData[currentMaterialName];
+        for (let i = 1; i < faceVertices.length - 1; i++) {
+          const tri = [faceVertices[0], faceVertices[i], faceVertices[i + 1]];
+          const p = tri.map((v) => positions[v.vIdx]);
+          let n;
+          if (tri.every((v) => v.nIdx !== null)) {
+            n = tri.map((v) => vertexNormals[v.nIdx]);
+          } else {
+            const normal = computeNormal(p[0], p[1], p[2]);
+            n = [normal, normal, normal];
+          }
+          for (let j = 0; j < 3; j++) {
+            vertices.push(...p[j]);
+            normals.push(...n[j]);
+            const tIdx = tri[j].tIdx;
+            const uv = tIdx !== null ? texCoords[tIdx] : [0, 0];
+            uvs.push(...uv);
+          }
+        }
+        break;
+      }
+    }
+  }
+  const meshes = [];
+  for (const [matName, data] of Object.entries(meshesData)) {
+    const material = materials[matName] || defaultMaterial || new Material(webglCore, { albedoColor: [1, 1, 1, 1] });
+    const mesh = new Mesh(
+      matName,
+      new Float32Array(data.vertices),
+      new Float32Array(data.normals),
+      material,
+      new Float32Array(data.uvs),
+      null
+    );
+    meshes.push(mesh);
+  }
+  const modelName = objUrl.split("/").pop().replace(".obj", "");
+  return new Model(meshes, translation, scale5, modelName);
+}
+
+// src/hooks/useGenesisGL.ts
+var nullLoadOBJ = () => Promise.reject(new Error("GenesisGL not initialized"));
+function useGenesisGL(options) {
+  const [context, setContext] = useState({
+    renderer: null,
+    scene: null,
+    viewport: null,
+    webglCore: null,
+    loadOBJ: nullLoadOBJ
+  });
+  const contextRef = useRef(context);
+  useEffect(() => {
+    const {
+      canvasRef,
+      onReady,
+      onError,
+      width,
+      height,
+      initialYaw,
+      initialPitch,
+      initialZoom
+    } = options;
+    if (!canvasRef.current) return;
+    try {
+      const canvas = canvasRef.current;
+      const vpWidth = width ?? window.innerWidth;
+      const vpHeight = height ?? window.innerHeight;
+      const webglCore = new WebGLCore(canvas);
+      const viewport = new Viewport(canvas, vpWidth, vpHeight, webglCore, {
+        pointerLock: false
+      });
+      const renderer = new Renderer(webglCore, viewport);
+      const scene = Scene.withDefaultLights(webglCore);
+      viewport.camera.target = [0, 0, 0];
+      viewport.camera.position = [4, 2, 8];
+      if (initialYaw !== void 0) viewport.camera.yaw = initialYaw;
+      if (initialPitch !== void 0) viewport.camera.pitch = initialPitch;
+      if (initialZoom !== void 0) viewport.camera.setZoom(initialZoom);
+      viewport.camera.invalidate();
+      const loadOBJ = (objUrl, opts = {}) => loadOBJWithMTL(
+        webglCore,
+        objUrl,
+        opts.mtlUrl ?? null,
+        opts.translation,
+        opts.scale
+      );
+      const ctx = {
+        renderer,
+        scene,
+        viewport,
+        webglCore,
+        loadOBJ
+      };
+      contextRef.current = ctx;
+      setContext(ctx);
+      if (onReady) onReady(ctx);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error("Failed to initialize GenesisGL:", err);
+      if (onError) onError(err);
+    }
+    return () => {
+      const { scene, viewport, webglCore } = contextRef.current;
+      if (scene && webglCore) scene.dispose(webglCore);
+      if (viewport) viewport.dispose();
+      if (webglCore) webglCore.dispose();
+    };
+  }, []);
+  return context;
+}
+
+// src/hooks/useRenderer.ts
+import { useRef as useRef2, useEffect as useEffect2 } from "react";
+function useRenderer(options) {
+  const { renderer, onFrame, enabled = true } = options;
+  const animationIdRef = useRef2(null);
+  useEffect2(() => {
+    if (!renderer || !enabled) return;
+    const animate = (time) => {
+      if (onFrame) onFrame(time);
+      animationIdRef.current = requestAnimationFrame(animate);
+    };
+    animationIdRef.current = requestAnimationFrame(animate);
+    return () => {
+      if (animationIdRef.current !== null) {
+        cancelAnimationFrame(animationIdRef.current);
+      }
+    };
+  }, [renderer, onFrame, enabled]);
+}
+
+// src/hooks/useWorldToScreen.ts
+import { useState as useState2, useCallback } from "react";
+function mat4TransformVec4(m, x, y, z, w) {
+  return {
+    x: m[0] * x + m[4] * y + m[8] * z + m[12] * w,
+    y: m[1] * x + m[5] * y + m[9] * z + m[13] * w,
+    z: m[2] * x + m[6] * y + m[10] * z + m[14] * w,
+    w: m[3] * x + m[7] * y + m[11] * z + m[15] * w
+  };
+}
+function useWorldToScreen(context) {
+  const [, forceUpdate] = useState2(0);
+  const project = useCallback(
+    (worldX, worldY, worldZ) => {
+      if (!context?.viewport) return { x: 0, y: 0, visible: false };
+      const { viewport } = context;
+      const camera = viewport.camera;
+      const canvas = viewport.getCanvas();
+      const view = camera.getViewMatrix();
+      const proj = camera.getProjectionMatrix();
+      const v = mat4TransformVec4(view, worldX, worldY, worldZ, 1);
+      const c = mat4TransformVec4(proj, v.x, v.y, v.z, v.w);
+      if (Math.abs(c.w) < 1e-6) return { x: 0, y: 0, visible: false };
+      const ndcX = c.x / c.w;
+      const ndcY = c.y / c.w;
+      const ndcZ = c.z / c.w;
+      const visible = ndcZ > -1 && ndcZ < 1 && Math.abs(ndcX) < 1.2 && Math.abs(ndcY) < 1.2;
+      return {
+        x: (ndcX + 1) * 0.5 * canvas.clientWidth,
+        y: (1 - ndcY) * 0.5 * canvas.clientHeight,
+        visible
+      };
+    },
+    [context]
+  );
+  const tick = useCallback(() => forceUpdate((n) => n + 1), []);
+  return { project, tick };
+}
+
+// src/hooks/useCameraControls.ts
+import { useCallback as useCallback2, useState as useState3 } from "react";
+var DEFAULT_YAW = 0;
+var DEFAULT_PITCH = 0;
+var DEFAULT_ZOOM = 1;
+function useCameraControls(ctx) {
+  const [camera, setCameraState] = useState3({
+    yaw: DEFAULT_YAW,
+    pitch: DEFAULT_PITCH,
+    zoom: DEFAULT_ZOOM
+  });
+  const sync = useCallback2((c) => {
+    setCameraState({ yaw: c.yaw, pitch: c.pitch, zoom: c.zoom });
+  }, []);
+  const rotate2 = useCallback2(
+    (deltaYaw, deltaPitch) => {
+      const c = ctx?.viewport?.camera;
+      if (!c) return;
+      c.rotate(deltaYaw, deltaPitch);
+      sync(c);
+    },
+    [ctx, sync]
+  );
+  const zoomBy = useCallback2(
+    (delta) => {
+      const c = ctx?.viewport?.camera;
+      if (!c) return;
+      c.zoomBy(delta);
+      sync(c);
+    },
+    [ctx, sync]
+  );
+  const setZoom = useCallback2(
+    (zoom) => {
+      const c = ctx?.viewport?.camera;
+      if (!c) return;
+      c.setZoom(zoom);
+      sync(c);
+    },
+    [ctx, sync]
+  );
+  const setYaw = useCallback2(
+    (yaw) => {
+      const c = ctx?.viewport?.camera;
+      if (!c) return;
+      c.yaw = yaw;
+      c.invalidate();
+      sync(c);
+    },
+    [ctx, sync]
+  );
+  const setPitch = useCallback2(
+    (pitch) => {
+      const c = ctx?.viewport?.camera;
+      if (!c) return;
+      c.pitch = pitch;
+      c.invalidate();
+      sync(c);
+    },
+    [ctx, sync]
+  );
+  const reset = useCallback2(() => {
+    const c = ctx?.viewport?.camera;
+    if (!c) return;
+    c.yaw = DEFAULT_YAW;
+    c.pitch = DEFAULT_PITCH;
+    c.invalidate();
+    c.setZoom(DEFAULT_ZOOM);
+    sync(c);
+  }, [ctx, sync]);
+  return { camera, rotate: rotate2, setYaw, setPitch, zoomBy, setZoom, reset };
+}
+
+// src/hooks/useCameraMouseDrag.ts
+import { useEffect as useEffect3, useRef as useRef3 } from "react";
+import { MouseDragControl as MouseDragControl2 } from "@fonsecabarreto/genesis-gl-core/Core";
+var SENSITIVITY = 8e-3;
+function useCameraMouseDrag(ctx, canvasRef) {
+  const { rotate: rotate2 } = useCameraControls(ctx);
+  const rotateRef = useRef3(rotate2);
+  rotateRef.current = rotate2;
+  useEffect3(() => {
+    const el = canvasRef.current;
+    if (!el || !ctx) return;
+    const drag = new MouseDragControl2(el);
+    const onDrag = (dx, dy, button) => {
+      if (button !== 2) return;
+      rotateRef.current(-dx * SENSITIVITY, dy * SENSITIVITY);
+    };
+    drag.onChange(onDrag);
+    drag.enable();
+    const onMouseDown = (e) => {
+      if (e.button !== 2) return;
+      el.style.cursor = "grabbing";
+    };
+    const onMouseUp = (e) => {
+      if (e.button !== 2) return;
+      el.style.cursor = "grab";
+    };
+    const onMouseEnter = () => {
+      el.style.cursor = "grab";
+    };
+    const onMouseLeave = () => {
+      el.style.cursor = "";
+    };
+    const onContextMenu = (e) => e.preventDefault();
+    el.addEventListener("mousedown", onMouseDown);
+    el.addEventListener("mouseenter", onMouseEnter);
+    el.addEventListener("mouseleave", onMouseLeave);
+    window.addEventListener("mouseup", onMouseUp);
+    el.addEventListener("contextmenu", onContextMenu);
+    return () => {
+      drag.disable();
+      el.removeEventListener("mousedown", onMouseDown);
+      el.removeEventListener("mouseenter", onMouseEnter);
+      el.removeEventListener("mouseleave", onMouseLeave);
+      window.removeEventListener("mouseup", onMouseUp);
+      el.removeEventListener("contextmenu", onContextMenu);
+      el.style.cursor = "";
+    };
+  }, [ctx]);
+}
+
+export {
+  useGenesisGL,
+  useRenderer,
+  useWorldToScreen,
+  useCameraControls,
+  useCameraMouseDrag
+};
+//# sourceMappingURL=chunk-QXHXGH2T.js.map