@fonsecabarreto/genesis-gl-core 0.1.0

package/dist/chunk-QCQVJCSR.js

@@ -0,0 +1,968 @@
+import {
+  Material
+} from "./chunk-6LS6AO5H.js";
+
+// src/Core/classes/Renderer.ts
+import { mat4 as mat42 } from "gl-matrix";
+
+// 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]
+  };
+}
+
+// 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;
+  }
+};
+
+// 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);
+}
+`
+);
+
+// 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);
+  }
+};
+
+// src/Core/classes/Skeleton.ts
+import { mat4, quat, vec3 } from "gl-matrix";
+var MAX_JOINTS = 128;
+var Skeleton = class _Skeleton {
+  /** Ordered joint list (parent always precedes child). */
+  joints;
+  /**
+   * Flat `Float32Array` of `joints.length` column-major `mat4` values.
+   * Updated by {@link computeJointMatrices} — upload directly to
+   * `uJointMatrices[0]`.
+   */
+  jointMatrices;
+  /**
+   * Global transform of the non-joint ancestor nodes above the skeleton
+   * root.  In many exported models the armature sits under a scene-root
+   * node that carries scale / rotation (e.g. cm → m conversion).  This
+   * transform is pre-multiplied into root-joint globals so that
+   * `global * inverseBindMatrix` evaluates to identity in the bind pose.
+   */
+  rootTransform;
+  constructor(joints, rootTransform) {
+    if (joints.length > MAX_JOINTS) {
+      console.warn(
+        `[Skeleton] ${joints.length} joints exceeds MAX_JOINTS (${MAX_JOINTS}). Extra joints will be ignored by the shader.`
+      );
+    }
+    this.joints = joints;
+    this.jointMatrices = new Float32Array(joints.length * 16);
+    this.rootTransform = rootTransform ?? mat4.create();
+  }
+  /** Number of joints in the skeleton. */
+  get jointCount() {
+    return this.joints.length;
+  }
+  /**
+   * Walk the joint hierarchy, composing global transforms, then multiply by
+   * each joint's inverse-bind matrix.  The result is stored in
+   * {@link jointMatrices} ready for shader upload.
+   *
+   * @param animatedPoses - Optional per-joint local transforms from an
+   *   {@link AnimationClip}.  Map keys are **joint array indices** (not glTF
+   *   node indices).
+   */
+  computeJointMatrices(animatedPoses) {
+    const globals = new Array(this.joints.length);
+    const local = mat4.create();
+    for (let i = 0; i < this.joints.length; i++) {
+      const joint = this.joints[i];
+      const pose = animatedPoses?.get(i);
+      const t = pose?.t ?? joint.localTranslation;
+      const r = pose?.r ?? joint.localRotation;
+      const s = pose?.s ?? joint.localScale;
+      mat4.fromRotationTranslationScale(local, r, t, s);
+      if (joint.parentIndex >= 0) {
+        globals[i] = mat4.create();
+        mat4.multiply(globals[i], globals[joint.parentIndex], local);
+      } else {
+        globals[i] = mat4.create();
+        mat4.multiply(globals[i], this.rootTransform, local);
+      }
+      const final = mat4.create();
+      mat4.multiply(final, globals[i], joint.inverseBindMatrix);
+      this.jointMatrices.set(final, i * 16);
+    }
+  }
+  /**
+   * Create a deep clone of this skeleton (useful when instancing models).
+   */
+  clone() {
+    const clonedJoints = this.joints.map((j) => ({
+      name: j.name,
+      nodeIndex: j.nodeIndex,
+      parentIndex: j.parentIndex,
+      localTranslation: vec3.clone(j.localTranslation),
+      localRotation: quat.clone(j.localRotation),
+      localScale: vec3.clone(j.localScale),
+      inverseBindMatrix: mat4.clone(j.inverseBindMatrix)
+    }));
+    return new _Skeleton(clonedJoints, mat4.clone(this.rootTransform));
+  }
+};
+
+// src/Core/classes/AnimationClip.ts
+import { quat as quat2, vec3 as vec32 } from "gl-matrix";
+var AnimationClip = class _AnimationClip {
+  /** Human-readable name (e.g. "Walk", "Idle"). */
+  name;
+  /** All channels in this clip. */
+  channels;
+  /** Total duration in seconds (derived from the maximum keyframe time). */
+  duration;
+  /** Current playback time in seconds. */
+  currentTime = 0;
+  /** Whether the clip loops when it reaches the end. */
+  loop = true;
+  /** Playback speed multiplier (1 = normal, 2 = double, −1 = reverse). */
+  speed = 1;
+  /** Whether the clip is currently advancing. */
+  playing = false;
+  constructor(name, channels, duration) {
+    this.name = name;
+    this.channels = channels;
+    this.duration = duration;
+  }
+  /** Start / resume playback. */
+  play() {
+    this.playing = true;
+  }
+  /** Pause playback (keeps current time). */
+  pause() {
+    this.playing = false;
+  }
+  /** Stop and rewind to the beginning. */
+  stop() {
+    this.playing = false;
+    this.currentTime = 0;
+  }
+  /** Rewind to the beginning without changing play state. */
+  reset() {
+    this.currentTime = 0;
+  }
+  /**
+   * Advance the playhead by `deltaTime` seconds (respects {@link speed}).
+   * Automatically loops or clamps depending on {@link loop}.
+   */
+  update(deltaTime) {
+    if (!this.playing || this.duration <= 0) return;
+    this.currentTime += deltaTime * this.speed;
+    if (this.loop) {
+      this.currentTime = (this.currentTime % this.duration + this.duration) % this.duration;
+    } else {
+      if (this.currentTime >= this.duration) {
+        this.currentTime = this.duration;
+        this.playing = false;
+      } else if (this.currentTime < 0) {
+        this.currentTime = 0;
+        this.playing = false;
+      }
+    }
+  }
+  /**
+   * Sample every channel at the current playhead and return a map of
+   * joint-index → local pose.
+   */
+  sample() {
+    const result = /* @__PURE__ */ new Map();
+    for (const channel of this.channels) {
+      if (!result.has(channel.jointIndex)) {
+        result.set(channel.jointIndex, {});
+      }
+      const entry = result.get(channel.jointIndex);
+      const value = sampleChannel(channel, this.currentTime);
+      switch (channel.path) {
+        case "translation":
+          entry.t = value;
+          break;
+        case "rotation":
+          entry.r = value;
+          break;
+        case "scale":
+          entry.s = value;
+          break;
+      }
+    }
+    return result;
+  }
+  /**
+   * Create an independent copy of this clip (shares the underlying sampler
+   * data but has its own playback state).
+   */
+  clone() {
+    const copy = new _AnimationClip(this.name, this.channels, this.duration);
+    copy.loop = this.loop;
+    copy.speed = this.speed;
+    return copy;
+  }
+};
+function readValue(values, index, numComponents) {
+  const off = index * numComponents;
+  if (numComponents === 4) {
+    return quat2.fromValues(
+      values[off],
+      values[off + 1],
+      values[off + 2],
+      values[off + 3]
+    );
+  }
+  return vec32.fromValues(values[off], values[off + 1], values[off + 2]);
+}
+function sampleChannel(channel, time) {
+  const { sampler, path } = channel;
+  const { times, values, interpolation } = sampler;
+  const numComponents = path === "rotation" ? 4 : 3;
+  if (times.length === 0) {
+    return numComponents === 4 ? quat2.create() : vec32.create();
+  }
+  if (time <= times[0]) {
+    return readValue(values, 0, numComponents);
+  }
+  if (time >= times[times.length - 1]) {
+    return readValue(values, times.length - 1, numComponents);
+  }
+  let lo = 0;
+  let hi = times.length - 1;
+  while (lo < hi - 1) {
+    const mid = lo + hi >>> 1;
+    if (times[mid] <= time) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  const t0 = times[lo];
+  const t1 = times[hi];
+  const factor = (time - t0) / (t1 - t0);
+  const v0 = readValue(values, lo, numComponents);
+  const v1 = readValue(values, hi, numComponents);
+  if (interpolation === "STEP") {
+    return v0;
+  }
+  if (path === "rotation") {
+    const out2 = quat2.create();
+    quat2.slerp(out2, v0, v1, factor);
+    return out2;
+  }
+  const out = vec32.create();
+  vec32.lerp(out, v0, v1, factor);
+  return out;
+}
+
+// src/Core/utils/create-wire-box.ts
+function createWireBox(min, max, material) {
+  const [minX, minY, minZ] = min;
+  const [maxX, maxY, maxZ] = max;
+  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;
+}
+
+// src/Core/classes/Renderer.ts
+var computeModelMatrix = (model) => {
+  const m = mat42.create();
+  mat42.translate(m, m, model.translation);
+  mat42.rotateX(m, m, model.rotation[0]);
+  mat42.rotateY(m, m, model.rotation[1]);
+  mat42.rotateZ(m, m, model.rotation[2]);
+  mat42.scale(m, m, model.scale);
+  return m;
+};
+var Renderer = class {
+  constructor(webglCore, viewport) {
+    this.webglCore = webglCore;
+    this.viewport = viewport;
+  }
+  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;
+  /** 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);
+    gl.enable(gl.DEPTH_TEST);
+  }
+  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();
+    const activeProgram = null;
+    for (const model of models) {
+      this.drawModel(
+        gl,
+        model,
+        lights,
+        viewPosition,
+        viewMatrix,
+        projMatrix,
+        activeProgram
+      );
+    }
+  }
+  drawModel(gl, model, lights, viewPosition, viewMatrix, projMatrix, activeProgram) {
+    const modelMatrix = computeModelMatrix(model);
+    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, modelMatrix, 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 = gl instanceof WebGL2RenderingContext;
+    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, modelMatrix, activeProgram) {
+    const hitboxMesh = createWireBox(
+      model.boundingBox.min,
+      model.boundingBox.max,
+      this.modelHitboxMaterial
+    );
+    hitboxMesh.isCollidable = false;
+    const camera = this.viewport.camera;
+    const viewMatrix = camera.getViewMatrix();
+    const projMatrix = camera.getProjectionMatrix();
+    const identity = mat42.create();
+    this.drawMesh(
+      hitboxMesh,
+      [],
+      camera.position,
+      identity,
+      viewMatrix,
+      projMatrix,
+      activeProgram
+    );
+  }
+  drawHitBoxForMesh(mesh, modelMatrix, viewMatrix, projMatrix, activeProgram) {
+    const gl = this.webglCore.getRenderingContext();
+    if (!gl || !mesh.boundingBox) return;
+    const { min, max } = mesh.boundingBox;
+    const wireBox = createWireBox(min, max, this.meshHitboxMaterial);
+    wireBox.isCollidable = false;
+    const camera = this.viewport.camera;
+    this.drawMesh(
+      wireBox,
+      [],
+      camera.position,
+      modelMatrix,
+      viewMatrix,
+      projMatrix,
+      activeProgram
+    );
+  }
+};
+
+export {
+  GL_LINES,
+  GL_TRIANGLES,
+  INITIAL_BOUNDING_BOX,
+  Mesh,
+  MeshBuffers,
+  WebGLCore,
+  Renderer,
+  MAX_JOINTS,
+  Skeleton,
+  AnimationClip
+};
+//# sourceMappingURL=chunk-QCQVJCSR.js.map