@fonsecabarreto/genesis-gl-core 0.1.0

package/dist/Core/utils/load-glb.js

@@ -0,0 +1,697 @@
+import {
+  AnimationClip,
+  GL_TRIANGLES,
+  Mesh,
+  Skeleton
+} from "../../chunk-QCQVJCSR.js";
+import {
+  Material
+} from "../../chunk-6LS6AO5H.js";
+import {
+  Model
+} from "../../chunk-JK2HEZAT.js";
+import "../../chunk-3ULETMWF.js";
+import "../../chunk-5TAAXI6S.js";
+
+// src/Core/utils/load-glb.ts
+import { mat4, quat, vec3 } from "gl-matrix";
+var GLB_MAGIC = 1179937895;
+var GLB_CHUNK_JSON = 1313821514;
+var GLB_CHUNK_BIN = 5130562;
+var GLB_HEADER_SIZE = 12;
+var CHUNK_HEADER_SIZE = 8;
+var COMPONENT_COUNT = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var TYPED_ARRAY_CTOR = {
+  [5120 /* BYTE */]: Int8Array,
+  [5121 /* UNSIGNED_BYTE */]: Uint8Array,
+  [5122 /* SHORT */]: Int16Array,
+  [5123 /* UNSIGNED_SHORT */]: Uint16Array,
+  [5125 /* UNSIGNED_INT */]: Uint32Array,
+  [5126 /* FLOAT */]: Float32Array
+};
+var COMPONENT_SIZES = {
+  [5120 /* BYTE */]: 1,
+  [5121 /* UNSIGNED_BYTE */]: 1,
+  [5122 /* SHORT */]: 2,
+  [5123 /* UNSIGNED_SHORT */]: 2,
+  [5125 /* UNSIGNED_INT */]: 4,
+  [5126 /* FLOAT */]: 4
+};
+var GLBLoader = class {
+  gl;
+  core;
+  constructor(core) {
+    this.gl = core.gl;
+    this.core = core;
+  }
+  // ━━━ Public API ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /**
+   * Fetch and parse a `.glb` file.
+   *
+   * @param url  - URL to the GLB resource.
+   * @param name - Logical name assigned to the resulting {@link Model}.
+   * @returns Parsed model, optional skeleton, and animation clips.
+   */
+  async load(url, name = "model") {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `[GLBLoader] Failed to fetch "${url}" (HTTP ${response.status})`
+      );
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return this.parse(arrayBuffer, name);
+  }
+  /**
+   * Parse a raw GLB `ArrayBuffer` that was already loaded (e.g. from drag-and-drop).
+   */
+  async parse(arrayBuffer, name = "model") {
+    const { gltf, binChunkData } = this.parseGlbHeader(arrayBuffer);
+    const buffers = [binChunkData];
+    let skeleton = null;
+    if (gltf.skins && gltf.skins.length > 0) {
+      skeleton = this.parseSkin(gltf, buffers, 0);
+      skeleton.computeJointMatrices();
+    }
+    const meshes = await this.parseMeshes(gltf, buffers, skeleton);
+    const animations = /* @__PURE__ */ new Map();
+    if (gltf.animations && skeleton) {
+      const nodeToJoint = /* @__PURE__ */ new Map();
+      for (let ji = 0; ji < skeleton.joints.length; ji++) {
+        nodeToJoint.set(skeleton.joints[ji].nodeIndex, ji);
+      }
+      for (let ai = 0; ai < gltf.animations.length; ai++) {
+        const clip = this.parseAnimation(gltf, buffers, ai, nodeToJoint);
+        animations.set(clip.name, clip);
+      }
+    }
+    const model = new Model(meshes, [0, 0, 0], [1, 1, 1], name, skeleton);
+    const center = model.getCenter();
+    model.setTranslation(
+      model.translation[0] - center[0],
+      model.translation[1],
+      model.translation[2] - center[2]
+    );
+    return { model, skeleton, animations };
+  }
+  // ━━━ GLB header parsing ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  parseGlbHeader(arrayBuffer) {
+    const view = new DataView(arrayBuffer);
+    const magic = view.getUint32(0, true);
+    if (magic !== GLB_MAGIC) {
+      throw new Error(
+        `[GLBLoader] Invalid GLB magic: 0x${magic.toString(16)} (expected 0x${GLB_MAGIC.toString(16)})`
+      );
+    }
+    const version = view.getUint32(4, true);
+    if (version !== 2) {
+      throw new Error(
+        `[GLBLoader] Unsupported glTF version ${version} (only v2 is supported)`
+      );
+    }
+    const jsonChunkLength = view.getUint32(GLB_HEADER_SIZE, true);
+    const jsonChunkType = view.getUint32(GLB_HEADER_SIZE + 4, true);
+    if (jsonChunkType !== GLB_CHUNK_JSON) {
+      throw new Error("[GLBLoader] First chunk is not JSON");
+    }
+    const jsonStart = GLB_HEADER_SIZE + CHUNK_HEADER_SIZE;
+    const jsonText = new TextDecoder().decode(
+      new Uint8Array(arrayBuffer, jsonStart, jsonChunkLength)
+    );
+    const gltf = JSON.parse(jsonText);
+    const binChunkOffset = jsonStart + jsonChunkLength;
+    const binChunkLength = view.getUint32(binChunkOffset, true);
+    const binChunkType = view.getUint32(binChunkOffset + 4, true);
+    if (binChunkType !== GLB_CHUNK_BIN) {
+      throw new Error("[GLBLoader] Second chunk is not BIN");
+    }
+    const binChunkData = arrayBuffer.slice(
+      binChunkOffset + CHUNK_HEADER_SIZE,
+      binChunkOffset + CHUNK_HEADER_SIZE + binChunkLength
+    );
+    return { gltf, binChunkData };
+  }
+  // ━━━ Mesh parsing ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /**
+   * Walk the active scene's node tree and return all renderable meshes.
+   *
+   * Each scene node that references a mesh is visited in hierarchy order.
+   * Non-skinned mesh nodes that are children of joint nodes (e.g. eyes /
+   * hair parented to the Head bone in Blender) are automatically handled:
+   * their vertex data is pre-transformed into skin-space and synthetic
+   * single-joint weights are generated so they deform with the parent bone.
+   *
+   * @param skeleton – already-parsed skin for this model (or null).
+   */
+  async parseMeshes(gltf, buffers, skeleton) {
+    if (!gltf.meshes || !gltf.nodes) return [];
+    const nodeToJointIndex = /* @__PURE__ */ new Map();
+    if (skeleton) {
+      for (let ji = 0; ji < skeleton.joints.length; ji++) {
+        nodeToJointIndex.set(skeleton.joints[ji].nodeIndex, ji);
+      }
+    }
+    const nodeParentMap = /* @__PURE__ */ new Map();
+    for (let ni = 0; ni < gltf.nodes.length; ni++) {
+      const children = gltf.nodes[ni].children;
+      if (children) {
+        for (const ci of children) nodeParentMap.set(ci, ni);
+      }
+    }
+    const findAncestorJoint = (nodeIdx) => {
+      let cur = nodeParentMap.get(nodeIdx);
+      while (cur !== void 0) {
+        const ji = nodeToJointIndex.get(cur);
+        if (ji !== void 0) return ji;
+        cur = nodeParentMap.get(cur);
+      }
+      return null;
+    };
+    const entries = [];
+    const sceneNodes = gltf.scenes?.[gltf.scene ?? 0]?.nodes ?? [];
+    const walk = (nodeIdx) => {
+      const node = gltf.nodes[nodeIdx];
+      if (node.mesh !== void 0) {
+        entries.push({ meshIdx: node.mesh, skinIdx: node.skin, nodeIdx });
+      }
+      node.children?.forEach((c) => walk(c));
+    };
+    for (const r of sceneNodes) walk(r);
+    const meshes = [];
+    for (const { meshIdx, skinIdx, nodeIdx } of entries) {
+      const meshDef = gltf.meshes[meshIdx];
+      for (let pi = 0; pi < meshDef.primitives.length; pi++) {
+        const prim = meshDef.primitives[pi];
+        const mesh = await this.parsePrimitive(
+          gltf,
+          buffers,
+          prim,
+          meshDef.name ?? `mesh_${meshIdx}_${pi}`
+        );
+        if (!mesh.isSkinned && skeleton && skinIdx === void 0) {
+          const ancestorJointIdx = findAncestorJoint(nodeIdx);
+          if (ancestorJointIdx !== null) {
+            this.applyBoneParenting(
+              mesh,
+              gltf.nodes[nodeIdx],
+              ancestorJointIdx,
+              skeleton.joints[ancestorJointIdx].inverseBindMatrix
+            );
+          }
+        }
+        meshes.push(mesh);
+      }
+    }
+    return meshes;
+  }
+  /**
+   * Pre-transform a bone-parented non-skinned mesh into skin coordinate space
+   * and synthesise single-joint weights so it deforms with its parent bone.
+   *
+   * The transform applied to each vertex is:
+   *   T = inv(IBM_parentJoint) × nodeLocalTransform
+   *
+   * After this call `mesh.isSkinned` returns `true`.
+   */
+  applyBoneParenting(mesh, node, jointIdx, ibm) {
+    const bindGlobal = mat4.create();
+    mat4.invert(bindGlobal, ibm);
+    const nodeLocal = this.getNodeLocalMatrix(node);
+    const preT = mat4.create();
+    mat4.multiply(preT, bindGlobal, nodeLocal);
+    const normMat = mat4.create();
+    mat4.invert(normMat, preT);
+    mat4.transpose(normMat, normMat);
+    const srcV = mesh.vertices;
+    const v = new Float32Array(srcV.length);
+    for (let i = 0; i < srcV.length; i += 3) {
+      const x = srcV[i], y = srcV[i + 1], z = srcV[i + 2];
+      v[i] = preT[0] * x + preT[4] * y + preT[8] * z + preT[12];
+      v[i + 1] = preT[1] * x + preT[5] * y + preT[9] * z + preT[13];
+      v[i + 2] = preT[2] * x + preT[6] * y + preT[10] * z + preT[14];
+    }
+    mesh.vertices = v;
+    const srcN = mesh.normals;
+    if (srcN && srcN.length > 0) {
+      const n = new Float32Array(srcN.length);
+      for (let i = 0; i < srcN.length; i += 3) {
+        const x = srcN[i], y = srcN[i + 1], z = srcN[i + 2];
+        n[i] = normMat[0] * x + normMat[4] * y + normMat[8] * z;
+        n[i + 1] = normMat[1] * x + normMat[5] * y + normMat[9] * z;
+        n[i + 2] = normMat[2] * x + normMat[6] * y + normMat[10] * z;
+      }
+      mesh.normals = n;
+    }
+    const vertexCount = mesh.vertices.length / 3;
+    const ji = new Float32Array(vertexCount * 4);
+    const jw = new Float32Array(vertexCount * 4);
+    for (let i = 0; i < vertexCount; i++) {
+      ji[i * 4] = jointIdx;
+      jw[i * 4] = 1;
+    }
+    mesh.jointIndices = ji;
+    mesh.jointWeights = jw;
+  }
+  async parsePrimitive(gltf, buffers, prim, name) {
+    const accessors = gltf.accessors;
+    const bufferViews = gltf.bufferViews;
+    const vertices = this.getAccessorData(
+      accessors[prim.attributes.POSITION],
+      bufferViews,
+      buffers
+    );
+    const normals = prim.attributes.NORMAL !== void 0 ? this.getAccessorData(
+      accessors[prim.attributes.NORMAL],
+      bufferViews,
+      buffers
+    ) : this.generateFlatNormals(vertices);
+    const texCoords = prim.attributes.TEXCOORD_0 !== void 0 ? this.getAccessorData(
+      accessors[prim.attributes.TEXCOORD_0],
+      bufferViews,
+      buffers
+    ) : new Float32Array();
+    const indices = prim.indices !== void 0 ? this.getAccessorData(
+      accessors[prim.indices],
+      bufferViews,
+      buffers
+    ) : null;
+    const material = await this.parseMaterial(gltf, buffers, prim.material);
+    const mesh = new Mesh(
+      name,
+      vertices,
+      normals,
+      material,
+      texCoords,
+      indices
+    );
+    mesh.setMode(prim.mode ?? GL_TRIANGLES);
+    if (prim.attributes.JOINTS_0 !== void 0 && prim.attributes.WEIGHTS_0 !== void 0) {
+      const rawJoints = this.getAccessorData(
+        accessors[prim.attributes.JOINTS_0],
+        bufferViews,
+        buffers
+      );
+      mesh.jointIndices = new Float32Array(rawJoints);
+      mesh.jointWeights = this.getAccessorData(
+        accessors[prim.attributes.WEIGHTS_0],
+        bufferViews,
+        buffers
+      );
+    }
+    return mesh;
+  }
+  // ━━━ Material parsing ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  async parseMaterial(gltf, buffers, materialIndex) {
+    const material = new Material(this.core, {});
+    if (materialIndex === void 0 || !gltf.materials) return material;
+    const matDef = gltf.materials[materialIndex];
+    if (!matDef) return material;
+    const pbr = matDef.pbrMetallicRoughness;
+    if (pbr) {
+      if (pbr.baseColorFactor) {
+        const [r, g, b, a] = pbr.baseColorFactor;
+        material.albedoColor = [r, g, b, a];
+        material.diffuse = [r, g, b];
+        material.dissolve = a;
+      }
+      if (pbr.baseColorTexture !== void 0) {
+        const tex = await this.loadEmbeddedTexture(
+          gltf,
+          buffers,
+          pbr.baseColorTexture.index
+        );
+        if (tex) material.texture = tex;
+      }
+      const roughness = pbr.roughnessFactor ?? 1;
+      material.shininess = Math.max(2, (1 - roughness) * 128);
+    }
+    const specGloss = matDef.extensions;
+    const sg = specGloss?.["KHR_materials_pbrSpecularGlossiness"];
+    if (sg) {
+      if (sg.diffuseFactor && !material.texture) {
+        const [r, g, b, a] = sg.diffuseFactor;
+        material.albedoColor = [r, g, b, a];
+        material.diffuse = [r, g, b];
+        material.dissolve = a;
+      }
+      if (sg.diffuseTexture && !material.texture) {
+        const diffTex = sg.diffuseTexture;
+        const tex = await this.loadEmbeddedTexture(
+          gltf,
+          buffers,
+          diffTex.index
+        );
+        if (tex) material.texture = tex;
+      }
+      if (sg.glossinessFactor !== void 0) {
+        material.shininess = Math.max(2, sg.glossinessFactor * 128);
+      }
+    }
+    if (matDef.emissiveFactor) {
+      const [er, eg, eb] = matDef.emissiveFactor;
+      material.ambientColor = [
+        material.ambientColor[0] + er,
+        material.ambientColor[1] + eg,
+        material.ambientColor[2] + eb
+      ];
+    }
+    if (matDef.alphaMode === "BLEND") {
+      material.dissolve = material.albedoColor[3];
+    } else if (matDef.alphaMode === "MASK") {
+      material.dissolve = 1;
+    } else {
+      material.dissolve = 1;
+    }
+    if (matDef.doubleSided) {
+      material.doubleSided = true;
+    }
+    return material;
+  }
+  // ━━━ Texture loading ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /**
+   * Decode a texture embedded in the GLB binary chunk and upload to GPU.
+   */
+  async loadEmbeddedTexture(gltf, buffers, textureIndex) {
+    const texDef = gltf.textures?.[textureIndex];
+    if (!texDef || texDef.source === void 0) return null;
+    const imageDef = gltf.images?.[texDef.source];
+    if (!imageDef) return null;
+    if (imageDef.bufferView !== void 0) {
+      const bv = gltf.bufferViews[imageDef.bufferView];
+      const buffer = buffers[bv.buffer];
+      const offset = bv.byteOffset ?? 0;
+      const data = new Uint8Array(buffer, offset, bv.byteLength);
+      const mimeType = imageDef.mimeType ?? "image/png";
+      const blob = new Blob([data], { type: mimeType });
+      const url = URL.createObjectURL(blob);
+      try {
+        return await this.createTextureFromUrl(url);
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+    }
+    if (imageDef.uri) {
+      return this.createTextureFromUrl(imageDef.uri);
+    }
+    return null;
+  }
+  createTextureFromUrl(url) {
+    return new Promise((resolve) => {
+      const img = new Image();
+      img.crossOrigin = "anonymous";
+      img.onload = () => {
+        const gl = this.gl;
+        const tex = gl.createTexture();
+        if (!tex) {
+          resolve(null);
+          return;
+        }
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texImage2D(
+          gl.TEXTURE_2D,
+          0,
+          gl.RGBA,
+          gl.RGBA,
+          gl.UNSIGNED_BYTE,
+          img
+        );
+        if (isPowerOfTwo(img.width) && isPowerOfTwo(img.height)) {
+          gl.generateMipmap(gl.TEXTURE_2D);
+        } 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(tex);
+      };
+      img.onerror = () => {
+        console.warn(`[GLBLoader] Failed to load texture from "${url}"`);
+        resolve(null);
+      };
+      img.src = url;
+    });
+  }
+  // ━━━ Skin / Skeleton parsing ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  parseSkin(gltf, buffers, skinIndex) {
+    const skinDef = gltf.skins[skinIndex];
+    const nodes = gltf.nodes;
+    const accessors = gltf.accessors;
+    const bufferViews = gltf.bufferViews;
+    let inverseBindMatrices = null;
+    if (skinDef.inverseBindMatrices !== void 0) {
+      inverseBindMatrices = this.getAccessorData(
+        accessors[skinDef.inverseBindMatrices],
+        bufferViews,
+        buffers
+      );
+    }
+    const nodeToJointIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < skinDef.joints.length; i++) {
+      nodeToJointIndex.set(skinDef.joints[i], i);
+    }
+    const joints = [];
+    for (let ji = 0; ji < skinDef.joints.length; ji++) {
+      const nodeIdx = skinDef.joints[ji];
+      const node = nodes[nodeIdx];
+      let parentIndex = -1;
+      if (node) {
+        for (let pji = 0; pji < skinDef.joints.length; pji++) {
+          if (pji === ji) continue;
+          const pNode = nodes[skinDef.joints[pji]];
+          if (pNode.children?.includes(nodeIdx)) {
+            parentIndex = pji;
+            break;
+          }
+        }
+      }
+      const ibm = mat4.create();
+      if (inverseBindMatrices) {
+        for (let k = 0; k < 16; k++) {
+          ibm[k] = inverseBindMatrices[ji * 16 + k];
+        }
+      }
+      const t = node.translation ? vec3.fromValues(
+        node.translation[0],
+        node.translation[1],
+        node.translation[2]
+      ) : vec3.create();
+      const r = node.rotation ? quat.fromValues(
+        node.rotation[0],
+        node.rotation[1],
+        node.rotation[2],
+        node.rotation[3]
+      ) : quat.create();
+      const s = node.scale ? vec3.fromValues(node.scale[0], node.scale[1], node.scale[2]) : vec3.fromValues(1, 1, 1);
+      joints.push({
+        name: node.name ?? `joint_${ji}`,
+        nodeIndex: nodeIdx,
+        parentIndex,
+        localTranslation: t,
+        localRotation: r,
+        localScale: s,
+        inverseBindMatrix: ibm
+      });
+    }
+    const skinRootTransform = this.computeSkinRootTransform(
+      gltf,
+      skinDef.joints,
+      joints
+    );
+    return new Skeleton(joints, skinRootTransform);
+  }
+  /**
+   * Compute the accumulated global transform of all non-joint ancestor
+   * nodes above the skeleton's root joint(s).
+   */
+  computeSkinRootTransform(gltf, jointNodeIndices, joints) {
+    const nodes = gltf.nodes;
+    const nodeParentMap = /* @__PURE__ */ new Map();
+    for (let ni = 0; ni < nodes.length; ni++) {
+      const children = nodes[ni].children;
+      if (children) {
+        for (const ci of children) {
+          nodeParentMap.set(ci, ni);
+        }
+      }
+    }
+    const rootJoint = joints.find((j) => j.parentIndex === -1);
+    if (!rootJoint) return mat4.create();
+    const skinRoot = mat4.create();
+    let ancestor = nodeParentMap.get(rootJoint.nodeIndex);
+    while (ancestor !== void 0) {
+      const localMat = this.getNodeLocalMatrix(nodes[ancestor]);
+      mat4.multiply(skinRoot, localMat, skinRoot);
+      ancestor = nodeParentMap.get(ancestor);
+    }
+    return skinRoot;
+  }
+  // ━━━ Animation parsing ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  parseAnimation(gltf, buffers, animIndex, nodeToJoint) {
+    const animDef = gltf.animations[animIndex];
+    const accessors = gltf.accessors;
+    const bufferViews = gltf.bufferViews;
+    const channels = [];
+    let maxTime = 0;
+    for (const chDef of animDef.channels) {
+      const targetNode = chDef.target.node;
+      if (targetNode === void 0) continue;
+      const jointIndex = nodeToJoint.get(targetNode);
+      if (jointIndex === void 0) continue;
+      const path = chDef.target.path;
+      if (path === "weights") continue;
+      const samplerDef = animDef.samplers[chDef.sampler];
+      const times = this.getAccessorData(
+        accessors[samplerDef.input],
+        bufferViews,
+        buffers
+      );
+      const values = this.getAccessorData(
+        accessors[samplerDef.output],
+        bufferViews,
+        buffers
+      );
+      if (times.length > 0) {
+        maxTime = Math.max(maxTime, times[times.length - 1]);
+      }
+      const sampler = {
+        times,
+        values,
+        interpolation: samplerDef.interpolation ?? "LINEAR"
+      };
+      channels.push({
+        jointIndex,
+        path,
+        sampler
+      });
+    }
+    return new AnimationClip(
+      animDef.name ?? `animation_${animIndex}`,
+      channels,
+      maxTime
+    );
+  }
+  // ━━━ Accessor data extraction ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /**
+   * Extract a typed array from a glTF accessor + bufferView.
+   * Handles byte-stride (interleaved buffers) and all glTF component types.
+   */
+  getAccessorData(accessor, bufferViews, buffers) {
+    if (accessor.bufferView === void 0) {
+      const count2 = accessor.count * COMPONENT_COUNT[accessor.type];
+      const Ctor2 = TYPED_ARRAY_CTOR[accessor.componentType] ?? Float32Array;
+      return new Ctor2(count2);
+    }
+    const bv = bufferViews[accessor.bufferView];
+    const buffer = buffers[bv.buffer];
+    const numComponents = COMPONENT_COUNT[accessor.type];
+    const componentSize = COMPONENT_SIZES[accessor.componentType] ?? 4;
+    const byteOffset = (bv.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+    const count = accessor.count;
+    const Ctor = TYPED_ARRAY_CTOR[accessor.componentType];
+    if (!Ctor) {
+      throw new Error(
+        `[GLBLoader] Unsupported componentType: ${accessor.componentType}`
+      );
+    }
+    const stride = bv.byteStride ?? 0;
+    const tightStride = numComponents * componentSize;
+    if (stride === 0 || stride === tightStride) {
+      return new Ctor(buffer, byteOffset, count * numComponents);
+    }
+    const out = new Ctor(count * numComponents);
+    const src = new DataView(buffer);
+    for (let i = 0; i < count; i++) {
+      const base = byteOffset + i * stride;
+      for (let c = 0; c < numComponents; c++) {
+        const off = base + c * componentSize;
+        out[i * numComponents + c] = readComponent(
+          src,
+          off,
+          accessor.componentType
+        );
+      }
+    }
+    return out;
+  }
+  // ━━━ Node-tree helpers ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /** Compute the local transform matrix from a glTF node's TRS or matrix. */
+  getNodeLocalMatrix(node) {
+    const m = mat4.create();
+    if (node.matrix) {
+      for (let i = 0; i < 16; i++) {
+        m[i] = node.matrix[i];
+      }
+      return m;
+    }
+    const t = node.translation ?? [0, 0, 0];
+    const r = node.rotation ?? [0, 0, 0, 1];
+    const s = node.scale ?? [1, 1, 1];
+    mat4.fromRotationTranslationScale(
+      m,
+      quat.fromValues(r[0], r[1], r[2], r[3]),
+      vec3.fromValues(t[0], t[1], t[2]),
+      vec3.fromValues(s[0], s[1], s[2])
+    );
+    return m;
+  }
+  // ━━━ Flat-normal generation ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /** Generate flat face-normals when the mesh doesn't include them. */
+  generateFlatNormals(vertices) {
+    const normals = new Float32Array(vertices.length);
+    for (let i = 0; i < vertices.length; i += 9) {
+      const ax = vertices[i], ay = vertices[i + 1], az = vertices[i + 2];
+      const bx = vertices[i + 3], by = vertices[i + 4], bz = vertices[i + 5];
+      const cx = vertices[i + 6], cy = vertices[i + 7], cz = vertices[i + 8];
+      const ux = bx - ax, uy = by - ay, uz = bz - az;
+      const vx = cx - ax, vy = cy - ay, vz = cz - az;
+      let nx = uy * vz - uz * vy;
+      let ny = uz * vx - ux * vz;
+      let nz = ux * vy - uy * vx;
+      const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+      if (len > 0) {
+        nx /= len;
+        ny /= len;
+        nz /= len;
+      }
+      for (let v = 0; v < 3; v++) {
+        normals[i + v * 3] = nx;
+        normals[i + v * 3 + 1] = ny;
+        normals[i + v * 3 + 2] = nz;
+      }
+    }
+    return normals;
+  }
+};
+function isPowerOfTwo(value) {
+  return (value & value - 1) === 0 && value > 0;
+}
+function readComponent(view, offset, componentType) {
+  switch (componentType) {
+    case 5120 /* BYTE */:
+      return view.getInt8(offset);
+    case 5121 /* UNSIGNED_BYTE */:
+      return view.getUint8(offset);
+    case 5122 /* SHORT */:
+      return view.getInt16(offset, true);
+    case 5123 /* UNSIGNED_SHORT */:
+      return view.getUint16(offset, true);
+    case 5125 /* UNSIGNED_INT */:
+      return view.getUint32(offset, true);
+    case 5126 /* FLOAT */:
+      return view.getFloat32(offset, true);
+    default:
+      return 0;
+  }
+}
+export {
+  GLBLoader
+};
+//# sourceMappingURL=load-glb.js.map