@babylonjs/lite 0.1.1

package/gltf-feature-draco-yGSMGTE3.js

@@ -0,0 +1,124 @@
+let dracoBaseUrl = "/";
+let modulePromise = null;
+let scriptLoadPromise = null;
+function loadDracoScript() {
+  if (scriptLoadPromise) {
+    return scriptLoadPromise;
+  }
+  scriptLoadPromise = new Promise((resolve, reject) => {
+    const existing = globalThis.DracoDecoderModule;
+    if (existing) {
+      resolve(existing);
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = dracoBaseUrl + "draco_decoder.js";
+    script.onload = () => {
+      const factory = globalThis.DracoDecoderModule;
+      if (!factory) {
+        reject(new Error("draco_decoder.js loaded but DracoDecoderModule is undefined"));
+      } else {
+        resolve(factory);
+      }
+    };
+    script.onerror = () => reject(new Error("Failed to load draco_decoder.js from " + script.src));
+    document.head.appendChild(script);
+  });
+  return scriptLoadPromise;
+}
+async function getDracoModule() {
+  if (modulePromise) {
+    return modulePromise;
+  }
+  modulePromise = (async () => {
+    const factory = await loadDracoScript();
+    return factory({ locateFile: (f) => dracoBaseUrl + f });
+  })();
+  return modulePromise;
+}
+async function decodeDracoPrimitive(compressed, attributeMap, accessorTypes) {
+  const module = await getDracoModule();
+  const decoder = new module.Decoder();
+  const buffer = new module.DecoderBuffer();
+  buffer.Init(compressed, compressed.byteLength);
+  const mesh = new module.Mesh();
+  const status = decoder.DecodeBufferToMesh(buffer, mesh);
+  if (!status.ok()) {
+    const err = status.error_msg();
+    module.destroy(buffer);
+    module.destroy(mesh);
+    module.destroy(decoder);
+    throw new Error("Draco decode failed: " + err);
+  }
+  const numPoints = mesh.num_points();
+  const numFaces = mesh.num_faces();
+  const indexCount = numFaces * 3;
+  const indexByteLength = indexCount * 4;
+  const indexPtr = module._malloc(indexByteLength);
+  decoder.GetTrianglesUInt32Array(mesh, indexByteLength, indexPtr);
+  const indices = new Uint32Array(module.HEAPU32.buffer, indexPtr, indexCount).slice();
+  module._free(indexPtr);
+  const attributes = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(attributeMap)) {
+    const uniqueId = attributeMap[name];
+    const attr = decoder.GetAttributeByUniqueId(mesh, uniqueId);
+    const componentCount = accessorTypes[name] ?? 3;
+    const totalComponents = numPoints * componentCount;
+    const isIntAttr = name === "JOINTS_0" || name === "JOINTS_1";
+    const bytesPerElement = 4;
+    const byteLength = totalComponents * bytesPerElement;
+    const ptr = module._malloc(byteLength);
+    const dataType = isIntAttr ? module.DT_INT32 : module.DT_FLOAT32;
+    decoder.GetAttributeDataArrayForAllPoints(mesh, attr, dataType, byteLength, ptr);
+    if (isIntAttr) {
+      attributes.set(name, new Int32Array(module.HEAP32.buffer, ptr, totalComponents).slice());
+    } else {
+      attributes.set(name, new Float32Array(module.HEAPF32.buffer, ptr, totalComponents).slice());
+    }
+    module._free(ptr);
+  }
+  module.destroy(buffer);
+  module.destroy(mesh);
+  module.destroy(decoder);
+  return { _attributes: attributes, _indices: indices, _vertexCount: numPoints, _indexCount: indexCount };
+}
+function getDracoBufferViewBytes(json, binChunk, bufferViewIdx) {
+  const view = json.bufferViews[bufferViewIdx];
+  if (!view) {
+    throw new Error(`Draco bufferView ${bufferViewIdx} not found`);
+  }
+  const offset = binChunk.byteOffset + (view.byteOffset ?? 0);
+  return new Uint8Array(binChunk.buffer, offset, view.byteLength);
+}
+const TYPE_COMPONENT_COUNTS = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };
+const feature = {
+  id: "KHR_draco_mesh_compression",
+  async preMesh(jsonIn, binChunk) {
+    var _a, _b, _c;
+    const json = jsonIn;
+    const out = /* @__PURE__ */ new Map();
+    for (const mesh of json.meshes ?? []) {
+      for (const primitive of mesh.primitives ?? []) {
+        const ext = (_a = primitive.extensions) == null ? void 0 : _a.KHR_draco_mesh_compression;
+        if (!ext) {
+          continue;
+        }
+        const bytes = getDracoBufferViewBytes(json, binChunk, ext.bufferView);
+        const accessorTypes = {};
+        for (const name of Object.keys(ext.attributes)) {
+          const accIdx = (_b = primitive.attributes) == null ? void 0 : _b[name];
+          if (accIdx !== void 0 && ((_c = json.accessors) == null ? void 0 : _c[accIdx])) {
+            accessorTypes[name] = TYPE_COMPONENT_COUNTS[json.accessors[accIdx].type] ?? 3;
+          }
+        }
+        const decoded = await decodeDracoPrimitive(bytes, ext.attributes, accessorTypes);
+        out.set(primitive, decoded);
+      }
+    }
+    return out;
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-draco-yGSMGTE3.js.map

package/gltf-feature-draco-yGSMGTE3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-draco-yGSMGTE3.js","sources":["../src/loader-gltf/draco-decode.ts","../src/loader-gltf/gltf-feature-draco.ts"],"sourcesContent":["/**\n * Lazy KHR_draco_mesh_compression decoder.\n *\n * The Draco decoder (JS glue + WASM) is loaded from `/draco_decoder.js` and\n * `/draco_decoder.wasm` on first use via a `<script>` injection. This keeps\n * bundle size at zero bytes for scenes that do not load Draco-compressed\n * glTF assets — the entire module (including this file) is dynamically\n * imported from extractAllMeshes only when a primitive carries\n * `KHR_draco_mesh_compression`.\n *\n * The decoder output is always 32-bit: Float32 for FLOAT accessors,\n * Uint32Array for indices. Vertex attributes match glTF accessor types\n * (POSITION/NORMAL/TANGENT=VEC3, TEXCOORD_0=VEC2, ...).\n */\n\nimport type { DecodedPrimitive } from \"./gltf-feature.js\";\n\n// Public base URL where the decoder JS + WASM are hosted. Defaults to site root.\nlet dracoBaseUrl = \"/\";\n\n/** Override the base URL where draco_decoder.js and draco_decoder.wasm are hosted. */\nexport function setDracoBaseUrl(url: string): void {\n    dracoBaseUrl = url.endsWith(\"/\") ? url : url + \"/\";\n}\n\ninterface DracoModule {\n    Decoder: new () => {\n        DecodeBufferToMesh(buffer: unknown, mesh: unknown): { ok(): boolean; error_msg(): string };\n        GetTrianglesUInt32Array(mesh: unknown, byteLength: number, outPtr: number): void;\n        GetAttributeByUniqueId(mesh: unknown, uniqueId: number): unknown;\n        GetAttributeDataArrayForAllPoints(mesh: unknown, attr: unknown, dataType: number, byteLength: number, outPtr: number): boolean;\n    };\n    DecoderBuffer: new () => { Init(data: Uint8Array, size: number): void };\n    Mesh: new () => { num_faces(): number; num_points(): number };\n    destroy(obj: unknown): void;\n    HEAPF32: Float32Array;\n    HEAPU32: Uint32Array;\n    HEAP32: Int32Array;\n    DT_FLOAT32: number;\n    DT_INT32: number;\n    _malloc(size: number): number;\n    _free(ptr: number): void;\n}\n\ntype DracoFactory = (cfg: { locateFile?: (file: string) => string }) => Promise<DracoModule>;\n\nlet modulePromise: Promise<DracoModule> | null = null;\nlet scriptLoadPromise: Promise<DracoFactory> | null = null;\n\nfunction loadDracoScript(): Promise<DracoFactory> {\n    if (scriptLoadPromise) {\n        return scriptLoadPromise;\n    }\n    scriptLoadPromise = new Promise<DracoFactory>((resolve, reject) => {\n        const existing = (globalThis as { DracoDecoderModule?: DracoFactory }).DracoDecoderModule;\n        if (existing) {\n            resolve(existing);\n            return;\n        }\n        const script = document.createElement(\"script\");\n        script.src = dracoBaseUrl + \"draco_decoder.js\";\n        script.onload = () => {\n            const factory = (globalThis as { DracoDecoderModule?: DracoFactory }).DracoDecoderModule;\n            if (!factory) {\n                reject(new Error(\"draco_decoder.js loaded but DracoDecoderModule is undefined\"));\n            } else {\n                resolve(factory);\n            }\n        };\n        script.onerror = () => reject(new Error(\"Failed to load draco_decoder.js from \" + script.src));\n        document.head.appendChild(script);\n    });\n    return scriptLoadPromise;\n}\n\nasync function getDracoModule(): Promise<DracoModule> {\n    if (modulePromise) {\n        return modulePromise;\n    }\n    modulePromise = (async () => {\n        const factory = await loadDracoScript();\n        return factory({ locateFile: (f: string) => dracoBaseUrl + f });\n    })();\n    return modulePromise;\n}\n\n/**\n * Decode a KHR_draco_mesh_compression primitive.\n * @param compressed - The raw bytes of the bufferView referenced by the extension.\n * @param attributeMap - Map of glTF attribute name (POSITION, NORMAL, ...) to Draco unique id.\n * @param accessorTypes - Map of glTF attribute name to component count (3 for VEC3, 2 for VEC2, 4 for VEC4).\n */\nexport async function decodeDracoPrimitive(compressed: Uint8Array, attributeMap: Record<string, number>, accessorTypes: Record<string, number>): Promise<DecodedPrimitive> {\n    const module = await getDracoModule();\n    const decoder = new module.Decoder();\n    const buffer = new module.DecoderBuffer();\n    buffer.Init(compressed, compressed.byteLength);\n    const mesh = new module.Mesh();\n    const status = decoder.DecodeBufferToMesh(buffer, mesh);\n    if (!status.ok()) {\n        const err = status.error_msg();\n        module.destroy(buffer);\n        module.destroy(mesh);\n        module.destroy(decoder);\n        throw new Error(\"Draco decode failed: \" + err);\n    }\n\n    const numPoints = mesh.num_points();\n    const numFaces = mesh.num_faces();\n    const indexCount = numFaces * 3;\n\n    // Indices: Draco returns Uint32 triangles. Always slice() off the heap\n    // view because module._malloc may grow the WASM memory and invalidate\n    // the typed-array views we already hold.\n    const indexByteLength = indexCount * 4;\n    const indexPtr = module._malloc(indexByteLength);\n    decoder.GetTrianglesUInt32Array(mesh, indexByteLength, indexPtr);\n    const indices = new Uint32Array(module.HEAPU32.buffer, indexPtr, indexCount).slice();\n    module._free(indexPtr);\n\n    const attributes = new Map<string, Float32Array | Uint32Array | Int32Array>();\n    for (const name of Object.keys(attributeMap)) {\n        const uniqueId = attributeMap[name]!;\n        const attr = decoder.GetAttributeByUniqueId(mesh, uniqueId);\n        const componentCount = accessorTypes[name] ?? 3;\n        const totalComponents = numPoints * componentCount;\n        const isIntAttr = name === \"JOINTS_0\" || name === \"JOINTS_1\";\n        const bytesPerElement = 4;\n        const byteLength = totalComponents * bytesPerElement;\n        const ptr = module._malloc(byteLength);\n        const dataType = isIntAttr ? module.DT_INT32 : module.DT_FLOAT32;\n        decoder.GetAttributeDataArrayForAllPoints(mesh, attr, dataType, byteLength, ptr);\n        // Re-read the HEAP view AFTER malloc/decode — the underlying buffer\n        // may have been reallocated during decoding.\n        if (isIntAttr) {\n            attributes.set(name, new Int32Array(module.HEAP32.buffer, ptr, totalComponents).slice());\n        } else {\n            attributes.set(name, new Float32Array(module.HEAPF32.buffer, ptr, totalComponents).slice());\n        }\n        module._free(ptr);\n    }\n\n    module.destroy(buffer);\n    module.destroy(mesh);\n    module.destroy(decoder);\n\n    return { _attributes: attributes, _indices: indices, _vertexCount: numPoints, _indexCount: indexCount };\n}\n\n/**\n * Read the bufferView slice referenced by the Draco extension into a Uint8Array.\n */\nexport function getDracoBufferViewBytes(json: { bufferViews: Array<{ byteOffset?: number; byteLength: number }> }, binChunk: DataView, bufferViewIdx: number): Uint8Array {\n    const view = json.bufferViews[bufferViewIdx];\n    if (!view) {\n        throw new Error(`Draco bufferView ${bufferViewIdx} not found`);\n    }\n    const offset = binChunk.byteOffset + (view.byteOffset ?? 0);\n    return new Uint8Array(binChunk.buffer, offset, view.byteLength);\n}\n","/**\n * KHR_draco_mesh_compression feature.\n *\n * Runs as a `preMesh` hook — before mesh extraction — so the core loader\n * stays unaware of Draco. This module is only dynamic-imported when the\n * asset's `extensionsUsed` lists KHR_draco_mesh_compression, which in turn\n * dynamic-imports the actual Emscripten-based decoder (`draco-decode.ts`).\n */\n\nimport type { DecodedPrimitive, GltfFeature } from \"./gltf-feature.js\";\nimport { decodeDracoPrimitive, getDracoBufferViewBytes } from \"./draco-decode.js\";\n\nconst TYPE_COMPONENT_COUNTS: Record<string, number> = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };\n\nconst feature: GltfFeature = {\n    id: \"KHR_draco_mesh_compression\",\n    async preMesh(jsonIn, binChunk) {\n        const json = jsonIn as {\n            meshes?: Array<{\n                primitives?: Array<{ attributes?: Record<string, number>; extensions?: Record<string, { bufferView: number; attributes: Record<string, number> }> }>;\n            }>;\n            accessors?: Array<{ type: string }>;\n        };\n        const out = new Map<unknown, DecodedPrimitive>();\n        for (const mesh of json.meshes ?? []) {\n            for (const primitive of mesh.primitives ?? []) {\n                const ext = primitive.extensions?.KHR_draco_mesh_compression;\n                if (!ext) {\n                    continue;\n                }\n                const bytes = getDracoBufferViewBytes(json as { bufferViews: Array<{ byteOffset?: number; byteLength: number }> }, binChunk, ext.bufferView);\n                const accessorTypes: Record<string, number> = {};\n                for (const name of Object.keys(ext.attributes)) {\n                    const accIdx = primitive.attributes?.[name];\n                    if (accIdx !== undefined && json.accessors?.[accIdx]) {\n                        accessorTypes[name] = TYPE_COMPONENT_COUNTS[json.accessors[accIdx].type] ?? 3;\n                    }\n                }\n                const decoded = await decodeDracoPrimitive(bytes, ext.attributes, accessorTypes);\n                out.set(primitive, decoded);\n            }\n        }\n        return out;\n    },\n};\n\nexport default feature;\n"],"names":[],"mappings":"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"}

package/gltf-feature-gpu-instancing-2e_CFQnl.js

@@ -0,0 +1,151 @@
+import { r as resolveAccessor, v as setThinInstances, x as mat4ComposeInto, d as computeAabb, y as mat4Multiply } from "./index-C8HOR2sB.js";
+function collectMeshesUnderNode(tn) {
+  const out = [];
+  for (const c of (tn == null ? void 0 : tn.children) ?? []) {
+    if (c && typeof c === "object" && "material" in c) {
+      out.push(c);
+    }
+  }
+  return out;
+}
+function buildInstanceMatrices(translation, rotation, scale, count) {
+  const matrices = new Float32Array(count * 16);
+  for (let i = 0; i < count; i++) {
+    const tx = translation ? translation[i * 3] : 0;
+    const ty = translation ? translation[i * 3 + 1] : 0;
+    const tz = translation ? translation[i * 3 + 2] : 0;
+    const qx = rotation ? rotation[i * 4] : 0;
+    const qy = rotation ? rotation[i * 4 + 1] : 0;
+    const qz = rotation ? rotation[i * 4 + 2] : 0;
+    const qw = rotation ? rotation[i * 4 + 3] : 1;
+    const sx = scale ? scale[i * 3] : 1;
+    const sy = scale ? scale[i * 3 + 1] : 1;
+    const sz = scale ? scale[i * 3 + 2] : 1;
+    mat4ComposeInto(matrices, i * 16, tx, ty, tz, qx, qy, qz, qw, sx, sy, sz);
+  }
+  return matrices;
+}
+const ext = {
+  id: "EXT_mesh_gpu_instancing",
+  async applyAsset(_meshes, _root, ctx) {
+    var _a, _b, _c;
+    const { _json: json, _binChunk: binChunk, _nodeMap: nodeMap } = ctx;
+    if (!nodeMap) {
+      return {};
+    }
+    const nodes = json.nodes ?? [];
+    for (let nodeIdx = 0; nodeIdx < nodes.length; nodeIdx++) {
+      const attrs = (_c = (_b = (_a = nodes[nodeIdx]) == null ? void 0 : _a.extensions) == null ? void 0 : _b.EXT_mesh_gpu_instancing) == null ? void 0 : _c.attributes;
+      if (!attrs) {
+        continue;
+      }
+      const tn = nodeMap[nodeIdx];
+      if (!tn) {
+        continue;
+      }
+      const meshesForNode = collectMeshesUnderNode(tn);
+      if (meshesForNode.length === 0) {
+        continue;
+      }
+      const tAcc = attrs.TRANSLATION !== void 0 ? resolveAccessor(json, binChunk, attrs.TRANSLATION) : null;
+      const rAcc = attrs.ROTATION !== void 0 ? resolveAccessor(json, binChunk, attrs.ROTATION) : null;
+      const sAcc = attrs.SCALE !== void 0 ? resolveAccessor(json, binChunk, attrs.SCALE) : null;
+      let count = 0;
+      for (const acc of [tAcc, rAcc, sAcc]) {
+        if (!acc) {
+          continue;
+        }
+        if (count === 0) {
+          count = acc._count;
+        } else if (acc._count !== count) {
+          throw new Error(`EXT_mesh_gpu_instancing: accessor count mismatch on node ${nodeIdx}`);
+        }
+      }
+      if (count === 0) {
+        continue;
+      }
+      const matrices = buildInstanceMatrices(
+        tAcc ? tAcc._data : null,
+        rAcc ? rAcc._data : null,
+        sAcc ? sAcc._data : null,
+        count
+      );
+      const nodeWorld = ctx._worldMatrixCache.get(nodeIdx);
+      for (const mesh of meshesForNode) {
+        setThinInstances(mesh, matrices, count);
+        expandMeshAabbForInstances(mesh, matrices, count, nodeWorld);
+      }
+    }
+    return {};
+  }
+};
+function expandMeshAabbForInstances(mesh, matrices, count, nodeWorld) {
+  const positions = mesh._cpuPositions;
+  if (!positions || !nodeWorld || count === 0) {
+    return;
+  }
+  const [lmin, lmax] = computeAabb(positions);
+  if (!isFinite(lmin[0])) {
+    return;
+  }
+  const corners = new Float32Array([
+    lmin[0],
+    lmin[1],
+    lmin[2],
+    lmax[0],
+    lmin[1],
+    lmin[2],
+    lmin[0],
+    lmax[1],
+    lmin[2],
+    lmax[0],
+    lmax[1],
+    lmin[2],
+    lmin[0],
+    lmin[1],
+    lmax[2],
+    lmax[0],
+    lmin[1],
+    lmax[2],
+    lmin[0],
+    lmax[1],
+    lmax[2],
+    lmax[0],
+    lmax[1],
+    lmax[2]
+  ]);
+  let wMinX = Infinity, wMinY = Infinity, wMinZ = Infinity;
+  let wMaxX = -Infinity, wMaxY = -Infinity, wMaxZ = -Infinity;
+  const instWorld = new Float32Array(16);
+  for (let i = 0; i < count; i++) {
+    for (let k = 0; k < 16; k++) {
+      instWorld[k] = matrices[i * 16 + k];
+    }
+    const combined = mat4Multiply(nodeWorld, instWorld);
+    const [imin, imax] = computeAabb(corners, combined);
+    if (imin[0] < wMinX) {
+      wMinX = imin[0];
+    }
+    if (imin[1] < wMinY) {
+      wMinY = imin[1];
+    }
+    if (imin[2] < wMinZ) {
+      wMinZ = imin[2];
+    }
+    if (imax[0] > wMaxX) {
+      wMaxX = imax[0];
+    }
+    if (imax[1] > wMaxY) {
+      wMaxY = imax[1];
+    }
+    if (imax[2] > wMaxZ) {
+      wMaxZ = imax[2];
+    }
+  }
+  mesh.boundMin = [wMinX, wMinY, wMinZ];
+  mesh.boundMax = [wMaxX, wMaxY, wMaxZ];
+}
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-feature-gpu-instancing-2e_CFQnl.js.map

package/gltf-feature-gpu-instancing-2e_CFQnl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-gpu-instancing-2e_CFQnl.js","sources":["../src/loader-gltf/gltf-feature-gpu-instancing.ts"],"sourcesContent":["/** glTF EXT_mesh_gpu_instancing extension.\n *\n *  Attaches hardware-instanced thin instances to every mesh that belongs to a\n *  node carrying `extensions.EXT_mesh_gpu_instancing`. The extension provides\n *  per-instance TRANSLATION / ROTATION / SCALE accessors (all optional); each\n *  instance matrix is composed as T·R·S in the node's local frame. The node's\n *  own TRS is applied through the regular parent-chain world matrix at render\n *  time (`finalWorld = mesh.world * instanceWorld` in thin-instance-fragment),\n *  so instance matrices must NOT pre-multiply the node transform.\n *\n *  Dynamically imported by load-gltf only when the asset declares the\n *  extension in `extensionsUsed`, so bundles pay zero bytes otherwise.\n *\n *  Spec: https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_mesh_gpu_instancing/README.md\n */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport type { Mesh } from \"../mesh/mesh.js\";\nimport { resolveAccessor } from \"./gltf-parser.js\";\nimport { computeAabb } from \"../math/compute-aabb.js\";\nimport { mat4ComposeInto } from \"../math/mat4-compose-into.js\";\nimport { mat4Multiply } from \"../math/mat4-multiply.js\";\nimport type { Mat4 } from \"../math/types.js\";\nimport { setThinInstances } from \"../mesh/thin-instance.js\";\n\n/** Collect every Mesh child (direct children only — matches buildNodeHierarchy). */\nfunction collectMeshesUnderNode(tn: { children?: unknown[] } | undefined): Mesh[] {\n    const out: Mesh[] = [];\n    for (const c of tn?.children ?? []) {\n        if (c && typeof c === \"object\" && \"material\" in (c as object)) {\n            out.push(c as Mesh);\n        }\n    }\n    return out;\n}\n\nfunction buildInstanceMatrices(translation: Float32Array | null, rotation: Float32Array | null, scale: Float32Array | null, count: number): Float32Array {\n    const matrices = new Float32Array(count * 16);\n    for (let i = 0; i < count; i++) {\n        const tx = translation ? translation[i * 3]! : 0;\n        const ty = translation ? translation[i * 3 + 1]! : 0;\n        const tz = translation ? translation[i * 3 + 2]! : 0;\n        const qx = rotation ? rotation[i * 4]! : 0;\n        const qy = rotation ? rotation[i * 4 + 1]! : 0;\n        const qz = rotation ? rotation[i * 4 + 2]! : 0;\n        const qw = rotation ? rotation[i * 4 + 3]! : 1;\n        const sx = scale ? scale[i * 3]! : 1;\n        const sy = scale ? scale[i * 3 + 1]! : 1;\n        const sz = scale ? scale[i * 3 + 2]! : 1;\n        mat4ComposeInto(matrices, i * 16, tx, ty, tz, qx, qy, qz, qw, sx, sy, sz);\n    }\n    return matrices;\n}\n\nconst ext: GltfFeature = {\n    id: \"EXT_mesh_gpu_instancing\",\n    async applyAsset(_meshes, _root, ctx) {\n        const { _json: json, _binChunk: binChunk, _nodeMap: nodeMap } = ctx;\n        if (!nodeMap) {\n            return {};\n        }\n        const nodes = json.nodes ?? [];\n        for (let nodeIdx = 0; nodeIdx < nodes.length; nodeIdx++) {\n            const attrs = nodes[nodeIdx]?.extensions?.EXT_mesh_gpu_instancing?.attributes;\n            if (!attrs) {\n                continue;\n            }\n            const tn = nodeMap[nodeIdx];\n            if (!tn) {\n                continue;\n            }\n            const meshesForNode = collectMeshesUnderNode(tn as unknown as { children?: unknown[] });\n            if (meshesForNode.length === 0) {\n                continue;\n            }\n\n            const tAcc = attrs.TRANSLATION !== undefined ? resolveAccessor(json, binChunk, attrs.TRANSLATION) : null;\n            const rAcc = attrs.ROTATION !== undefined ? resolveAccessor(json, binChunk, attrs.ROTATION) : null;\n            const sAcc = attrs.SCALE !== undefined ? resolveAccessor(json, binChunk, attrs.SCALE) : null;\n\n            let count = 0;\n            for (const acc of [tAcc, rAcc, sAcc]) {\n                if (!acc) {\n                    continue;\n                }\n                if (count === 0) {\n                    count = acc._count;\n                } else if (acc._count !== count) {\n                    throw new Error(`EXT_mesh_gpu_instancing: accessor count mismatch on node ${nodeIdx}`);\n                }\n            }\n            if (count === 0) {\n                continue;\n            }\n\n            const matrices = buildInstanceMatrices(\n                tAcc ? (tAcc._data as Float32Array) : null,\n                rAcc ? (rAcc._data as Float32Array) : null,\n                sAcc ? (sAcc._data as Float32Array) : null,\n                count\n            );\n            const nodeWorld = ctx._worldMatrixCache.get(nodeIdx);\n            for (const mesh of meshesForNode) {\n                setThinInstances(mesh, matrices, count);\n                expandMeshAabbForInstances(mesh, matrices, count, nodeWorld);\n            }\n        }\n        return {};\n    },\n};\nexport default ext;\n\n/** Expand a mesh's world-space AABB to enclose all thin instances so that\n *  auto-framing cameras see the full instanced grid, not just the base mesh. */\nfunction expandMeshAabbForInstances(mesh: Mesh, matrices: Float32Array, count: number, nodeWorld: Mat4 | undefined): void {\n    const positions = mesh._cpuPositions;\n    if (!positions || !nodeWorld || count === 0) {\n        return;\n    }\n    // Local AABB of the base mesh (before any per-instance / node transform).\n    const [lmin, lmax] = computeAabb(positions);\n    if (!isFinite(lmin[0]!)) {\n        return;\n    }\n    // 8 corners of the local AABB, packed as 24 floats for computeAabb.\n    const corners = new Float32Array([\n        lmin[0]!,\n        lmin[1]!,\n        lmin[2]!,\n        lmax[0]!,\n        lmin[1]!,\n        lmin[2]!,\n        lmin[0]!,\n        lmax[1]!,\n        lmin[2]!,\n        lmax[0]!,\n        lmax[1]!,\n        lmin[2]!,\n        lmin[0]!,\n        lmin[1]!,\n        lmax[2]!,\n        lmax[0]!,\n        lmin[1]!,\n        lmax[2]!,\n        lmin[0]!,\n        lmax[1]!,\n        lmax[2]!,\n        lmax[0]!,\n        lmax[1]!,\n        lmax[2]!,\n    ]);\n    let wMinX = Infinity,\n        wMinY = Infinity,\n        wMinZ = Infinity;\n    let wMaxX = -Infinity,\n        wMaxY = -Infinity,\n        wMaxZ = -Infinity;\n    const instWorld = new Float32Array(16) as Mat4;\n    for (let i = 0; i < count; i++) {\n        for (let k = 0; k < 16; k++) {\n            instWorld[k] = matrices[i * 16 + k]!;\n        }\n        const combined = mat4Multiply(nodeWorld, instWorld);\n        const [imin, imax] = computeAabb(corners, combined);\n        if (imin[0]! < wMinX) {\n            wMinX = imin[0]!;\n        }\n        if (imin[1]! < wMinY) {\n            wMinY = imin[1]!;\n        }\n        if (imin[2]! < wMinZ) {\n            wMinZ = imin[2]!;\n        }\n        if (imax[0]! > wMaxX) {\n            wMaxX = imax[0]!;\n        }\n        if (imax[1]! > wMaxY) {\n            wMaxY = imax[1]!;\n        }\n        if (imax[2]! > wMaxZ) {\n            wMaxZ = imax[2]!;\n        }\n    }\n    mesh.boundMin = [wMinX, wMinY, wMinZ];\n    mesh.boundMax = [wMaxX, wMaxY, wMaxZ];\n}\n"],"names":[],"mappings":"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"}

package/gltf-feature-lights-punctual-DDDg4j0U.js

@@ -0,0 +1,71 @@
+import { M as MAX_LIGHTS, s as setMaxLights, g as computeNodeWorldMatrix } from "./index-C8HOR2sB.js";
+const feature = {
+  id: "KHR_lights_punctual",
+  async applyAsset(_meshes, _root, ctx) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const defs = (_b = (_a = ctx._json.extensions) == null ? void 0 : _a.KHR_lights_punctual) == null ? void 0 : _b.lights;
+    if (!(defs == null ? void 0 : defs.length)) {
+      return {};
+    }
+    const lights = [];
+    const nodes = ctx._json.nodes ?? [];
+    let lightNodeCount = 0;
+    for (let i = 0; i < nodes.length; i++) {
+      if (((_e = (_d = (_c = nodes[i]) == null ? void 0 : _c.extensions) == null ? void 0 : _d.KHR_lights_punctual) == null ? void 0 : _e.light) !== void 0) {
+        lightNodeCount++;
+      }
+    }
+    if (lightNodeCount > MAX_LIGHTS) {
+      setMaxLights(lightNodeCount);
+    }
+    for (let nodeIdx = 0; nodeIdx < nodes.length; nodeIdx++) {
+      const lightIdx = (_h = (_g = (_f = nodes[nodeIdx]) == null ? void 0 : _f.extensions) == null ? void 0 : _g.KHR_lights_punctual) == null ? void 0 : _h.light;
+      if (lightIdx === void 0) {
+        continue;
+      }
+      const def = defs[lightIdx];
+      if (!def) {
+        continue;
+      }
+      const world = computeNodeWorldMatrix(ctx._json, nodeIdx, ctx._parentMap, ctx._worldMatrixCache);
+      const px = world[12];
+      const py = world[13];
+      const pz = world[14];
+      const fx = -world[8];
+      const fy = -world[9];
+      const fz = -world[10];
+      const flen = Math.hypot(fx, fy, fz) || 1;
+      const dir = [fx / flen, fy / flen, fz / flen];
+      const color = def.color ? [def.color[0], def.color[1], def.color[2]] : [1, 1, 1];
+      const intensity = def.intensity ?? 1;
+      const range = def.range !== void 0 ? def.range : Number.MAX_VALUE;
+      if (def.type === "point") {
+        const { createPointLight } = await import("./index-C8HOR2sB.js").then((n) => n.gd);
+        const pl = createPointLight([px, py, pz], intensity);
+        pl.diffuse = color;
+        pl.specular = color;
+        pl.range = range;
+        lights.push(pl);
+      } else if (def.type === "directional") {
+        const { createDirectionalLight } = await import("./index-C8HOR2sB.js").then((n) => n.ge);
+        const dl = createDirectionalLight(dir, intensity);
+        dl.diffuse = color;
+        dl.specular = color;
+        lights.push(dl);
+      } else if (def.type === "spot") {
+        const { createSpotLight } = await import("./index-C8HOR2sB.js").then((n) => n.gf);
+        const outer = ((_i = def.spot) == null ? void 0 : _i.outerConeAngle) ?? Math.PI / 4;
+        const sl = createSpotLight([px, py, pz], dir, outer * 2, 1, intensity);
+        sl.diffuse = color;
+        sl.specular = color;
+        sl.range = range;
+        lights.push(sl);
+      }
+    }
+    return { entities: lights };
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-lights-punctual-DDDg4j0U.js.map

package/gltf-feature-lights-punctual-DDDg4j0U.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-lights-punctual-DDDg4j0U.js","sources":["../src/loader-gltf/gltf-feature-lights-punctual.ts"],"sourcesContent":["/** KHR_lights_punctual glTF extension.\n *  Parses point / directional / spot lights from the asset's top-level\n *  KHR_lights_punctual.lights array and instantiates one Lite light per\n *  referencing node, baking the node's world transform into the light's\n *  position / direction. Lights are contributed via the AssetContainer's\n *  `entities` array; addToScene() picks them up through the `lightType`\n *  branch of its traversal. */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport type { LightBase } from \"../light/types.js\";\nimport { MAX_LIGHTS, setMaxLights } from \"../light/types.js\";\nimport { computeNodeWorldMatrix } from \"./gltf-parser.js\";\n\ninterface GltfLightDef {\n    type: \"point\" | \"directional\" | \"spot\";\n    color?: [number, number, number];\n    intensity?: number;\n    range?: number;\n    spot?: { innerConeAngle?: number; outerConeAngle?: number };\n}\n\nconst feature: GltfFeature = {\n    id: \"KHR_lights_punctual\",\n    async applyAsset(_meshes, _root, ctx) {\n        const defs: GltfLightDef[] | undefined = ctx._json.extensions?.KHR_lights_punctual?.lights;\n        if (!defs?.length) {\n            return {};\n        }\n        const lights: LightBase[] = [];\n        const nodes = ctx._json.nodes ?? [];\n        // Count lights first so we can raise MAX_LIGHTS before any pipeline is\n        // compiled (loadGltf runs before addToScene which triggers pipeline\n        // creation). Lite's MAX_LIGHTS is scene-wide, so cover every punctual\n        // light declared by the asset rather than Babylon's per-material cap.\n        let lightNodeCount = 0;\n        for (let i = 0; i < nodes.length; i++) {\n            if (nodes[i]?.extensions?.KHR_lights_punctual?.light !== undefined) {\n                lightNodeCount++;\n            }\n        }\n        if (lightNodeCount > MAX_LIGHTS) {\n            setMaxLights(lightNodeCount);\n        }\n        for (let nodeIdx = 0; nodeIdx < nodes.length; nodeIdx++) {\n            const lightIdx: number | undefined = nodes[nodeIdx]?.extensions?.KHR_lights_punctual?.light;\n            if (lightIdx === undefined) {\n                continue;\n            }\n            const def = defs[lightIdx];\n            if (!def) {\n                continue;\n            }\n            const world = computeNodeWorldMatrix(ctx._json, nodeIdx, ctx._parentMap, ctx._worldMatrixCache);\n            const px = world[12]!;\n            const py = world[13]!;\n            const pz = world[14]!;\n            // glTF convention: light forward is -Z in local space. Extract world-space forward\n            // by transforming (0,0,-1) through the node's upper-3x3. Normalize defensively.\n            const fx = -world[8]!;\n            const fy = -world[9]!;\n            const fz = -world[10]!;\n            const flen = Math.hypot(fx, fy, fz) || 1;\n            const dir: [number, number, number] = [fx / flen, fy / flen, fz / flen];\n            const color: [number, number, number] = def.color ? [def.color[0]!, def.color[1]!, def.color[2]!] : [1, 1, 1];\n            const intensity = def.intensity ?? 1;\n            const range = def.range !== undefined ? def.range : Number.MAX_VALUE;\n\n            if (def.type === \"point\") {\n                const { createPointLight } = await import(\"../light/point-light.js\");\n                const pl = createPointLight([px, py, pz], intensity);\n                pl.diffuse = color;\n                pl.specular = color;\n                pl.range = range;\n                lights.push(pl);\n            } else if (def.type === \"directional\") {\n                const { createDirectionalLight } = await import(\"../light/directional-light.js\");\n                const dl = createDirectionalLight(dir, intensity);\n                dl.diffuse = color;\n                dl.specular = color;\n                lights.push(dl);\n            } else if (def.type === \"spot\") {\n                const { createSpotLight } = await import(\"../light/spot-light.js\");\n                const outer = def.spot?.outerConeAngle ?? Math.PI / 4;\n                const sl = createSpotLight([px, py, pz], dir, outer * 2, 1, intensity);\n                sl.diffuse = color;\n                sl.specular = color;\n                sl.range = range;\n                lights.push(sl);\n            }\n        }\n        return { entities: lights };\n    },\n};\nexport default feature;\n"],"names":[],"mappings":";AAqBA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,WAAW,SAAS,OAAO,KAAK;;AAClC,UAAM,QAAmC,eAAI,MAAM,eAAV,mBAAsB,wBAAtB,mBAA2C;AACpF,QAAI,EAAC,6BAAM,SAAQ;AACf,aAAO,CAAA;AAAA,IACX;AACA,UAAM,SAAsB,CAAA;AAC5B,UAAM,QAAQ,IAAI,MAAM,SAAS,CAAA;AAKjC,QAAI,iBAAiB;AACrB,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,YAAI,uBAAM,CAAC,MAAP,mBAAU,eAAV,mBAAsB,wBAAtB,mBAA2C,WAAU,QAAW;AAChE;AAAA,MACJ;AAAA,IACJ;AACA,QAAI,iBAAiB,YAAY;AAC7B,mBAAa,cAAc;AAAA,IAC/B;AACA,aAAS,UAAU,GAAG,UAAU,MAAM,QAAQ,WAAW;AACrD,YAAM,YAA+B,uBAAM,OAAO,MAAb,mBAAgB,eAAhB,mBAA4B,wBAA5B,mBAAiD;AACtF,UAAI,aAAa,QAAW;AACxB;AAAA,MACJ;AACA,YAAM,MAAM,KAAK,QAAQ;AACzB,UAAI,CAAC,KAAK;AACN;AAAA,MACJ;AACA,YAAM,QAAQ,uBAAuB,IAAI,OAAO,SAAS,IAAI,YAAY,IAAI,iBAAiB;AAC9F,YAAM,KAAK,MAAM,EAAE;AACnB,YAAM,KAAK,MAAM,EAAE;AACnB,YAAM,KAAK,MAAM,EAAE;AAGnB,YAAM,KAAK,CAAC,MAAM,CAAC;AACnB,YAAM,KAAK,CAAC,MAAM,CAAC;AACnB,YAAM,KAAK,CAAC,MAAM,EAAE;AACpB,YAAM,OAAO,KAAK,MAAM,IAAI,IAAI,EAAE,KAAK;AACvC,YAAM,MAAgC,CAAC,KAAK,MAAM,KAAK,MAAM,KAAK,IAAI;AACtE,YAAM,QAAkC,IAAI,QAAQ,CAAC,IAAI,MAAM,CAAC,GAAI,IAAI,MAAM,CAAC,GAAI,IAAI,MAAM,CAAC,CAAE,IAAI,CAAC,GAAG,GAAG,CAAC;AAC5G,YAAM,YAAY,IAAI,aAAa;AACnC,YAAM,QAAQ,IAAI,UAAU,SAAY,IAAI,QAAQ,OAAO;AAE3D,UAAI,IAAI,SAAS,SAAS;AACtB,cAAM,EAAE,iBAAA,IAAqB,MAAM,OAAO,qBAAyB,EAAA,KAAA,OAAA,EAAA,EAAA;AACnE,cAAM,KAAK,iBAAiB,CAAC,IAAI,IAAI,EAAE,GAAG,SAAS;AACnD,WAAG,UAAU;AACb,WAAG,WAAW;AACd,WAAG,QAAQ;AACX,eAAO,KAAK,EAAE;AAAA,MAClB,WAAW,IAAI,SAAS,eAAe;AACnC,cAAM,EAAE,uBAAA,IAA2B,MAAM,OAAO,qBAA+B,EAAA,KAAA,OAAA,EAAA,EAAA;AAC/E,cAAM,KAAK,uBAAuB,KAAK,SAAS;AAChD,WAAG,UAAU;AACb,WAAG,WAAW;AACd,eAAO,KAAK,EAAE;AAAA,MAClB,WAAW,IAAI,SAAS,QAAQ;AAC5B,cAAM,EAAE,gBAAA,IAAoB,MAAM,OAAO,qBAAwB,EAAA,KAAA,OAAA,EAAA,EAAA;AACjE,cAAM,UAAQ,SAAI,SAAJ,mBAAU,mBAAkB,KAAK,KAAK;AACpD,cAAM,KAAK,gBAAgB,CAAC,IAAI,IAAI,EAAE,GAAG,KAAK,QAAQ,GAAG,GAAG,SAAS;AACrE,WAAG,UAAU;AACb,WAAG,WAAW;AACd,WAAG,QAAQ;AACX,eAAO,KAAK,EAAE;AAAA,MAClB;AAAA,IACJ;AACA,WAAO,EAAE,UAAU,OAAA;AAAA,EACvB;AACJ;"}

package/gltf-feature-meshopt-Des96YFI.js

@@ -0,0 +1,84 @@
+let meshoptBaseUrl = "/";
+let scriptLoadPromise = null;
+function loadMeshoptScript() {
+  if (scriptLoadPromise) {
+    return scriptLoadPromise;
+  }
+  scriptLoadPromise = new Promise((resolve, reject) => {
+    const existing = globalThis.MeshoptDecoder;
+    if (existing) {
+      resolve(existing);
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = meshoptBaseUrl + "meshopt_decoder.js";
+    script.onload = () => {
+      const mod = globalThis.MeshoptDecoder;
+      if (!mod) {
+        reject(new Error("meshopt_decoder.js loaded but MeshoptDecoder is undefined"));
+      } else {
+        resolve(mod);
+      }
+    };
+    script.onerror = () => reject(new Error("Failed to load meshopt_decoder.js from " + script.src));
+    document.head.appendChild(script);
+  });
+  return scriptLoadPromise;
+}
+async function getMeshoptDecoder() {
+  const mod = await loadMeshoptScript();
+  await mod.ready;
+  return mod;
+}
+function align4(n) {
+  return n + 3 & -4;
+}
+const feature = {
+  id: "EXT_meshopt_compression",
+  async preParse(json, binChunk) {
+    var _a;
+    const bufferViews = json.bufferViews ?? [];
+    const decoder = await getMeshoptDecoder();
+    const materialized = new Array(bufferViews.length);
+    const newOffsets = new Array(bufferViews.length);
+    let total = 0;
+    for (let i = 0; i < bufferViews.length; i++) {
+      const bv = bufferViews[i];
+      const ext = (_a = bv.extensions) == null ? void 0 : _a.EXT_meshopt_compression;
+      let bytes;
+      if (ext) {
+        if ((ext.buffer ?? 0) !== 0) {
+          throw new Error(`EXT_meshopt_compression: compressed source buffer ${ext.buffer} is not buffer 0 (unsupported)`);
+        }
+        const source = new Uint8Array(binChunk.buffer, binChunk.byteOffset + (ext.byteOffset ?? 0), ext.byteLength);
+        const target = new Uint8Array(ext.count * ext.byteStride);
+        decoder.decodeGltfBuffer(target, ext.count, ext.byteStride, source, ext.mode, ext.filter ?? "NONE");
+        bytes = target;
+      } else {
+        if ((bv.buffer ?? 0) !== 0) {
+          throw new Error(`EXT_meshopt_compression: uncompressed bufferView in buffer ${bv.buffer} is not buffer 0 (unsupported)`);
+        }
+        bytes = new Uint8Array(binChunk.buffer.slice(binChunk.byteOffset + (bv.byteOffset ?? 0), binChunk.byteOffset + (bv.byteOffset ?? 0) + bv.byteLength));
+      }
+      materialized[i] = bytes;
+      newOffsets[i] = total;
+      total = align4(total + bytes.length);
+    }
+    const packed = new Uint8Array(total);
+    for (let i = 0; i < bufferViews.length; i++) {
+      const bv = bufferViews[i];
+      packed.set(materialized[i], newOffsets[i]);
+      bv.buffer = 0;
+      bv.byteOffset = newOffsets[i];
+      bv.byteLength = materialized[i].length;
+      if (bv.extensions) {
+        delete bv.extensions.EXT_meshopt_compression;
+      }
+    }
+    return new DataView(packed.buffer);
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-meshopt-Des96YFI.js.map

package/gltf-feature-meshopt-Des96YFI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-meshopt-Des96YFI.js","sources":["../src/loader-gltf/meshopt-decode.ts","../src/loader-gltf/gltf-feature-meshopt.ts"],"sourcesContent":["/**\n * Lazy EXT_meshopt_compression decoder.\n *\n * The meshoptimizer decoder (JS glue + embedded WASM) is loaded from\n * `/meshopt_decoder.js` on first use via a `<script>` injection — exactly like\n * the Draco decoder. This keeps bundle size at zero bytes for scenes that do\n * not load meshopt-compressed glTF assets: the entire module (including this\n * file) is dynamic-imported from the meshopt feature only when an asset's\n * `extensionsUsed` lists EXT_meshopt_compression.\n */\n\n// Public base URL where meshopt_decoder.js is hosted. Defaults to site root.\nlet meshoptBaseUrl = \"/\";\n\n/** Override the base URL where meshopt_decoder.js is hosted. */\nexport function setMeshoptBaseUrl(url: string): void {\n    meshoptBaseUrl = url.endsWith(\"/\") ? url : url + \"/\";\n}\n\n/** Minimal surface of the global `MeshoptDecoder` object we rely on. */\ninterface MeshoptDecoderModule {\n    ready: Promise<void>;\n    decodeGltfBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string): void;\n}\n\nlet scriptLoadPromise: Promise<MeshoptDecoderModule> | null = null;\n\nfunction loadMeshoptScript(): Promise<MeshoptDecoderModule> {\n    if (scriptLoadPromise) {\n        return scriptLoadPromise;\n    }\n    scriptLoadPromise = new Promise<MeshoptDecoderModule>((resolve, reject) => {\n        const existing = (globalThis as { MeshoptDecoder?: MeshoptDecoderModule }).MeshoptDecoder;\n        if (existing) {\n            resolve(existing);\n            return;\n        }\n        const script = document.createElement(\"script\");\n        script.src = meshoptBaseUrl + \"meshopt_decoder.js\";\n        script.onload = () => {\n            const mod = (globalThis as { MeshoptDecoder?: MeshoptDecoderModule }).MeshoptDecoder;\n            if (!mod) {\n                reject(new Error(\"meshopt_decoder.js loaded but MeshoptDecoder is undefined\"));\n            } else {\n                resolve(mod);\n            }\n        };\n        script.onerror = () => reject(new Error(\"Failed to load meshopt_decoder.js from \" + script.src));\n        document.head.appendChild(script);\n    });\n    return scriptLoadPromise;\n}\n\n/** Resolve the ready meshopt decoder module (WASM instantiated). */\nexport async function getMeshoptDecoder(): Promise<MeshoptDecoderModule> {\n    const mod = await loadMeshoptScript();\n    await mod.ready;\n    return mod;\n}\n","/**\n * EXT_meshopt_compression feature.\n *\n * Runs as a `preParse` hook — before any accessor is read — so the core loader\n * and accessor reader stay unaware of meshopt. This module is only\n * dynamic-imported when the asset's `extensionsUsed` lists\n * EXT_meshopt_compression, which in turn loads the meshoptimizer decoder\n * (`meshopt-decode.ts`) lazily.\n *\n * EXT_meshopt_compression is a bufferView-level codec: each compressed\n * bufferView carries an extension object describing the compressed source\n * (`buffer`/`byteOffset`/`byteLength`), the decoded layout (`count`/`byteStride`)\n * and the codec (`mode`/`filter`). We decode every compressed bufferView, copy\n * through every uncompressed one, and pack the results into a single contiguous\n * binary chunk, rewriting `bufferViews` to point into it. Accessor byteOffsets\n * are bufferView-relative and the per-bufferView layout (count * byteStride) is\n * preserved, so the existing accessor reader resolves the decoded data\n * transparently.\n */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport { getMeshoptDecoder } from \"./meshopt-decode.js\";\n\ninterface MeshoptExt {\n    buffer: number;\n    byteOffset?: number;\n    byteLength: number;\n    byteStride: number;\n    count: number;\n    mode: string;\n    filter?: string;\n}\n\ninterface BufferView {\n    buffer?: number;\n    byteOffset?: number;\n    byteLength: number;\n    byteStride?: number;\n    extensions?: { EXT_meshopt_compression?: MeshoptExt; [k: string]: unknown };\n}\n\n/** Round up to the next 4-byte boundary so relocated bufferViews stay aligned\n *  for Float32Array / Uint16Array / Uint32Array views over the packed buffer. */\nfunction align4(n: number): number {\n    return (n + 3) & ~3;\n}\n\nconst feature: GltfFeature = {\n    id: \"EXT_meshopt_compression\",\n    async preParse(json, binChunk) {\n        const bufferViews: BufferView[] = json.bufferViews ?? [];\n        const decoder = await getMeshoptDecoder();\n\n        // Pass 1: materialize each bufferView (decode meshopt ones, copy the rest)\n        // and compute the packed-buffer offset for each.\n        const materialized: Uint8Array[] = new Array(bufferViews.length);\n        const newOffsets: number[] = new Array(bufferViews.length);\n        let total = 0;\n        for (let i = 0; i < bufferViews.length; i++) {\n            const bv = bufferViews[i]!;\n            const ext = bv.extensions?.EXT_meshopt_compression;\n            let bytes: Uint8Array;\n            if (ext) {\n                if ((ext.buffer ?? 0) !== 0) {\n                    throw new Error(`EXT_meshopt_compression: compressed source buffer ${ext.buffer} is not buffer 0 (unsupported)`);\n                }\n                const source = new Uint8Array(binChunk.buffer, binChunk.byteOffset + (ext.byteOffset ?? 0), ext.byteLength);\n                const target = new Uint8Array(ext.count * ext.byteStride);\n                decoder.decodeGltfBuffer(target, ext.count, ext.byteStride, source, ext.mode, ext.filter ?? \"NONE\");\n                bytes = target;\n            } else {\n                if ((bv.buffer ?? 0) !== 0) {\n                    throw new Error(`EXT_meshopt_compression: uncompressed bufferView in buffer ${bv.buffer} is not buffer 0 (unsupported)`);\n                }\n                bytes = new Uint8Array(binChunk.buffer.slice(binChunk.byteOffset + (bv.byteOffset ?? 0), binChunk.byteOffset + (bv.byteOffset ?? 0) + bv.byteLength));\n            }\n            materialized[i] = bytes;\n            newOffsets[i] = total;\n            total = align4(total + bytes.length);\n        }\n\n        // Pass 2: pack into a single contiguous buffer and rewrite bufferViews.\n        const packed = new Uint8Array(total);\n        for (let i = 0; i < bufferViews.length; i++) {\n            const bv = bufferViews[i]!;\n            packed.set(materialized[i]!, newOffsets[i]!);\n            bv.buffer = 0;\n            bv.byteOffset = newOffsets[i]!;\n            bv.byteLength = materialized[i]!.length;\n            if (bv.extensions) {\n                delete bv.extensions.EXT_meshopt_compression;\n            }\n        }\n\n        return new DataView(packed.buffer);\n    },\n};\n\nexport default feature;\n"],"names":[],"mappings":"AAYA,IAAI,iBAAiB;AAarB,IAAI,oBAA0D;AAE9D,SAAS,oBAAmD;AACxD,MAAI,mBAAmB;AACnB,WAAO;AAAA,EACX;AACA,sBAAoB,IAAI,QAA8B,CAAC,SAAS,WAAW;AACvE,UAAM,WAAY,WAAyD;AAC3E,QAAI,UAAU;AACV,cAAQ,QAAQ;AAChB;AAAA,IACJ;AACA,UAAM,SAAS,SAAS,cAAc,QAAQ;AAC9C,WAAO,MAAM,iBAAiB;AAC9B,WAAO,SAAS,MAAM;AAClB,YAAM,MAAO,WAAyD;AACtE,UAAI,CAAC,KAAK;AACN,eAAO,IAAI,MAAM,2DAA2D,CAAC;AAAA,MACjF,OAAO;AACH,gBAAQ,GAAG;AAAA,MACf;AAAA,IACJ;AACA,WAAO,UAAU,MAAM,OAAO,IAAI,MAAM,4CAA4C,OAAO,GAAG,CAAC;AAC/F,aAAS,KAAK,YAAY,MAAM;AAAA,EACpC,CAAC;AACD,SAAO;AACX;AAGA,eAAsB,oBAAmD;AACrE,QAAM,MAAM,MAAM,kBAAA;AAClB,QAAM,IAAI;AACV,SAAO;AACX;ACfA,SAAS,OAAO,GAAmB;AAC/B,SAAQ,IAAI,IAAK;AACrB;AAEA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,SAAS,MAAM,UAAU;ADrCnC;ACsCQ,UAAM,cAA4B,KAAK,eAAe,CAAA;AACtD,UAAM,UAAU,MAAM,kBAAA;AAItB,UAAM,eAA6B,IAAI,MAAM,YAAY,MAAM;AAC/D,UAAM,aAAuB,IAAI,MAAM,YAAY,MAAM;AACzD,QAAI,QAAQ;AACZ,aAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AACzC,YAAM,KAAK,YAAY,CAAC;AACxB,YAAM,OAAM,QAAG,eAAH,mBAAe;AAC3B,UAAI;AACJ,UAAI,KAAK;AACL,aAAK,IAAI,UAAU,OAAO,GAAG;AACzB,gBAAM,IAAI,MAAM,qDAAqD,IAAI,MAAM,gCAAgC;AAAA,QACnH;AACA,cAAM,SAAS,IAAI,WAAW,SAAS,QAAQ,SAAS,cAAc,IAAI,cAAc,IAAI,IAAI,UAAU;AAC1G,cAAM,SAAS,IAAI,WAAW,IAAI,QAAQ,IAAI,UAAU;AACxD,gBAAQ,iBAAiB,QAAQ,IAAI,OAAO,IAAI,YAAY,QAAQ,IAAI,MAAM,IAAI,UAAU,MAAM;AAClG,gBAAQ;AAAA,MACZ,OAAO;AACH,aAAK,GAAG,UAAU,OAAO,GAAG;AACxB,gBAAM,IAAI,MAAM,8DAA8D,GAAG,MAAM,gCAAgC;AAAA,QAC3H;AACA,gBAAQ,IAAI,WAAW,SAAS,OAAO,MAAM,SAAS,cAAc,GAAG,cAAc,IAAI,SAAS,cAAc,GAAG,cAAc,KAAK,GAAG,UAAU,CAAC;AAAA,MACxJ;AACA,mBAAa,CAAC,IAAI;AAClB,iBAAW,CAAC,IAAI;AAChB,cAAQ,OAAO,QAAQ,MAAM,MAAM;AAAA,IACvC;AAGA,UAAM,SAAS,IAAI,WAAW,KAAK;AACnC,aAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AACzC,YAAM,KAAK,YAAY,CAAC;AACxB,aAAO,IAAI,aAAa,CAAC,GAAI,WAAW,CAAC,CAAE;AAC3C,SAAG,SAAS;AACZ,SAAG,aAAa,WAAW,CAAC;AAC5B,SAAG,aAAa,aAAa,CAAC,EAAG;AACjC,UAAI,GAAG,YAAY;AACf,eAAO,GAAG,WAAW;AAAA,MACzB;AAAA,IACJ;AAEA,WAAO,IAAI,SAAS,OAAO,MAAM;AAAA,EACrC;AACJ;"}

package/gltf-feature-morph-CKCw6tkX.js

@@ -0,0 +1,29 @@
+import { r as resolveAccessor } from "./index-C8HOR2sB.js";
+const feature = {
+  id: "_morph",
+  async applyMesh(meshData, mesh, ctx) {
+    const primitive = meshData._primitive;
+    const targets = primitive.targets;
+    if (!targets || targets.length === 0) {
+      return;
+    }
+    const { _json: json, _binChunk: binChunk } = ctx;
+    const morphTargets = [];
+    for (const target of targets) {
+      const posAcc = target.POSITION !== void 0 ? resolveAccessor(json, binChunk, target.POSITION) : null;
+      const normAcc = target.NORMAL !== void 0 ? resolveAccessor(json, binChunk, target.NORMAL) : null;
+      morphTargets.push({
+        positions: posAcc ? posAcc._data : new Float32Array(meshData._vertexCount * 3),
+        normals: normAcc ? normAcc._data : null
+      });
+    }
+    const parentMesh = json.meshes[json.nodes[meshData._nodeIndex].mesh];
+    const morphWeights = parentMesh.weights ?? new Array(targets.length).fill(0);
+    const { createMorphTargets } = await import("./index-C8HOR2sB.js").then((n) => n.gi);
+    mesh.morphTargets = createMorphTargets(ctx._engine, morphTargets, meshData._vertexCount, morphWeights);
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-morph-CKCw6tkX.js.map

package/gltf-feature-morph-CKCw6tkX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-morph-CKCw6tkX.js","sources":["../src/loader-gltf/gltf-feature-morph.ts"],"sourcesContent":["/** Morph target feature. Extracts per-primitive morph targets lazily so the\n *  core loader doesn't carry any morph-related code for non-morphed assets. */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport { resolveAccessor } from \"./gltf-parser.js\";\n\nconst feature: GltfFeature = {\n    id: \"_morph\",\n    async applyMesh(meshData, mesh, ctx) {\n        const primitive = meshData._primitive;\n        const targets = primitive.targets;\n        if (!targets || targets.length === 0) {\n            return;\n        }\n        const { _json: json, _binChunk: binChunk } = ctx;\n        const morphTargets: { positions: Float32Array; normals: Float32Array | null }[] = [];\n        for (const target of targets) {\n            const posAcc = target.POSITION !== undefined ? resolveAccessor(json, binChunk, target.POSITION) : null;\n            const normAcc = target.NORMAL !== undefined ? resolveAccessor(json, binChunk, target.NORMAL) : null;\n            morphTargets.push({\n                positions: posAcc ? (posAcc._data as Float32Array) : new Float32Array(meshData._vertexCount * 3),\n                normals: normAcc ? (normAcc._data as Float32Array) : null,\n            });\n        }\n        const parentMesh = json.meshes[json.nodes[meshData._nodeIndex].mesh];\n        const morphWeights = parentMesh.weights ?? new Array(targets.length).fill(0);\n        const { createMorphTargets } = await import(\"../morph/create-morph-targets.js\");\n        mesh.morphTargets = createMorphTargets(ctx._engine, morphTargets, meshData._vertexCount, morphWeights);\n    },\n};\nexport default feature;\n"],"names":[],"mappings":";AAMA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,UAAU,UAAU,MAAM,KAAK;AACjC,UAAM,YAAY,SAAS;AAC3B,UAAM,UAAU,UAAU;AAC1B,QAAI,CAAC,WAAW,QAAQ,WAAW,GAAG;AAClC;AAAA,IACJ;AACA,UAAM,EAAE,OAAO,MAAM,WAAW,aAAa;AAC7C,UAAM,eAA4E,CAAA;AAClF,eAAW,UAAU,SAAS;AAC1B,YAAM,SAAS,OAAO,aAAa,SAAY,gBAAgB,MAAM,UAAU,OAAO,QAAQ,IAAI;AAClG,YAAM,UAAU,OAAO,WAAW,SAAY,gBAAgB,MAAM,UAAU,OAAO,MAAM,IAAI;AAC/F,mBAAa,KAAK;AAAA,QACd,WAAW,SAAU,OAAO,QAAyB,IAAI,aAAa,SAAS,eAAe,CAAC;AAAA,QAC/F,SAAS,UAAW,QAAQ,QAAyB;AAAA,MAAA,CACxD;AAAA,IACL;AACA,UAAM,aAAa,KAAK,OAAO,KAAK,MAAM,SAAS,UAAU,EAAE,IAAI;AACnE,UAAM,eAAe,WAAW,WAAW,IAAI,MAAM,QAAQ,MAAM,EAAE,KAAK,CAAC;AAC3E,UAAM,EAAE,mBAAA,IAAuB,MAAM,OAAO,qBAAkC,EAAA,KAAA,OAAA,EAAA,EAAA;AAC9E,SAAK,eAAe,mBAAmB,IAAI,SAAS,cAAc,SAAS,cAAc,YAAY;AAAA,EACzG;AACJ;"}

package/gltf-feature-skeleton-D8hWLqi2.js

@@ -0,0 +1,36 @@
+import { r as resolveAccessor } from "./index-C8HOR2sB.js";
+function resolveAttr(name, primitive, decoded, json, binChunk) {
+  var _a;
+  if (decoded && decoded._attributes.has(name)) {
+    return decoded._attributes.get(name);
+  }
+  const idx = (_a = primitive.attributes) == null ? void 0 : _a[name];
+  return idx !== void 0 ? resolveAccessor(json, binChunk, idx)._data : null;
+}
+const feature = {
+  id: "_skeleton",
+  async applyMesh(meshData, mesh, ctx) {
+    const { _json: json, _binChunk: binChunk, _parentMap: parentMap, _worldMatrixCache: worldMatrixCache } = ctx;
+    const node = json.nodes[meshData._nodeIndex];
+    if (node.skin === void 0 || !json.skins) {
+      return;
+    }
+    const primitive = meshData._primitive;
+    const decoded = meshData._decoded;
+    const joints = resolveAttr("JOINTS_0", primitive, decoded, json, binChunk);
+    const weights = resolveAttr("WEIGHTS_0", primitive, decoded, json, binChunk);
+    if (!joints || !weights) {
+      return;
+    }
+    const joints1 = resolveAttr("JOINTS_1", primitive, decoded, json, binChunk);
+    const weights1 = resolveAttr("WEIGHTS_1", primitive, decoded, json, binChunk);
+    const [{ extractSkin, computeBoneTextureData }, { createSkeleton }] = await Promise.all([import("./gltf-animation-D7uyTyO3.js"), import("./create-skeleton-C9JdIJnb.js")]);
+    const skin = extractSkin(json, binChunk, node.skin, meshData._worldMatrix, parentMap, worldMatrixCache);
+    const boneData = computeBoneTextureData(skin);
+    mesh.skeleton = createSkeleton(ctx._engine, joints, weights, skin.jointNodes.length, boneData, joints1, weights1);
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-skeleton-D8hWLqi2.js.map

package/gltf-feature-skeleton-D8hWLqi2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-skeleton-D8hWLqi2.js","sources":["../src/loader-gltf/gltf-feature-skeleton.ts"],"sourcesContent":["/** Skeletal animation feature. Extracts joints/weights/skin on demand so the\n *  core loader doesn't carry any skinning-related code for non-skinned assets. */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport { resolveAccessor } from \"./gltf-parser.js\";\n\n/** Resolve a vertex attribute by name, preferring any pre-decoded\n *  (e.g. Draco) data over the raw accessor. */\nfunction resolveAttr(name: string, primitive: any, decoded: any, json: any, binChunk: DataView): ArrayBufferView | null {\n    if (decoded && decoded._attributes.has(name)) {\n        return decoded._attributes.get(name)!;\n    }\n    const idx = primitive.attributes?.[name];\n    return idx !== undefined ? (resolveAccessor(json, binChunk, idx)._data as ArrayBufferView) : null;\n}\n\nconst feature: GltfFeature = {\n    id: \"_skeleton\",\n    async applyMesh(meshData, mesh, ctx) {\n        const { _json: json, _binChunk: binChunk, _parentMap: parentMap, _worldMatrixCache: worldMatrixCache } = ctx;\n        const node = json.nodes[meshData._nodeIndex];\n        if (node.skin === undefined || !json.skins) {\n            return;\n        }\n        const primitive = meshData._primitive;\n        const decoded = meshData._decoded;\n        const joints = resolveAttr(\"JOINTS_0\", primitive, decoded, json, binChunk) as Uint16Array | Uint8Array | null;\n        const weights = resolveAttr(\"WEIGHTS_0\", primitive, decoded, json, binChunk) as Float32Array | null;\n        if (!joints || !weights) {\n            return;\n        }\n        const joints1 = resolveAttr(\"JOINTS_1\", primitive, decoded, json, binChunk) as Uint16Array | Uint8Array | null;\n        const weights1 = resolveAttr(\"WEIGHTS_1\", primitive, decoded, json, binChunk) as Float32Array | null;\n\n        const [{ extractSkin, computeBoneTextureData }, { createSkeleton }] = await Promise.all([import(\"./gltf-animation.js\"), import(\"../skeleton/create-skeleton.js\")]);\n        const skin = extractSkin(json, binChunk, node.skin, meshData._worldMatrix, parentMap, worldMatrixCache);\n        const boneData = computeBoneTextureData(skin);\n        mesh.skeleton = createSkeleton(ctx._engine, joints, weights, skin.jointNodes.length, boneData, joints1, weights1);\n    },\n};\nexport default feature;\n"],"names":[],"mappings":";AAQA,SAAS,YAAY,MAAc,WAAgB,SAAc,MAAW,UAA4C;;AACpH,MAAI,WAAW,QAAQ,YAAY,IAAI,IAAI,GAAG;AAC1C,WAAO,QAAQ,YAAY,IAAI,IAAI;AAAA,EACvC;AACA,QAAM,OAAM,eAAU,eAAV,mBAAuB;AACnC,SAAO,QAAQ,SAAa,gBAAgB,MAAM,UAAU,GAAG,EAAE,QAA4B;AACjG;AAEA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,UAAU,UAAU,MAAM,KAAK;AACjC,UAAM,EAAE,OAAO,MAAM,WAAW,UAAU,YAAY,WAAW,mBAAmB,iBAAA,IAAqB;AACzG,UAAM,OAAO,KAAK,MAAM,SAAS,UAAU;AAC3C,QAAI,KAAK,SAAS,UAAa,CAAC,KAAK,OAAO;AACxC;AAAA,IACJ;AACA,UAAM,YAAY,SAAS;AAC3B,UAAM,UAAU,SAAS;AACzB,UAAM,SAAS,YAAY,YAAY,WAAW,SAAS,MAAM,QAAQ;AACzE,UAAM,UAAU,YAAY,aAAa,WAAW,SAAS,MAAM,QAAQ;AAC3E,QAAI,CAAC,UAAU,CAAC,SAAS;AACrB;AAAA,IACJ;AACA,UAAM,UAAU,YAAY,YAAY,WAAW,SAAS,MAAM,QAAQ;AAC1E,UAAM,WAAW,YAAY,aAAa,WAAW,SAAS,MAAM,QAAQ;AAE5E,UAAM,CAAC,EAAE,aAAa,0BAA0B,EAAE,gBAAgB,IAAI,MAAM,QAAQ,IAAI,CAAC,OAAO,8BAAqB,GAAG,OAAO,+BAAgC,CAAC,CAAC;AACjK,UAAM,OAAO,YAAY,MAAM,UAAU,KAAK,MAAM,SAAS,cAAc,WAAW,gBAAgB;AACtG,UAAM,WAAW,uBAAuB,IAAI;AAC5C,SAAK,WAAW,eAAe,IAAI,SAAS,QAAQ,SAAS,KAAK,WAAW,QAAQ,UAAU,SAAS,QAAQ;AAAA,EACpH;AACJ;"}

package/gltf-feature-variants-Ds6v9byg.js

@@ -0,0 +1,17 @@
+const feature = {
+  id: "KHR_materials_variants",
+  async applyAsset(meshes, _root, ctx) {
+    var _a, _b, _c;
+    const variantNames = (_c = (_b = (_a = ctx._json.extensions) == null ? void 0 : _a.KHR_materials_variants) == null ? void 0 : _b.variants) == null ? void 0 : _c.map((v) => v.name);
+    if (!(variantNames == null ? void 0 : variantNames.length)) {
+      return {};
+    }
+    const { loadVariantMaterials } = await import("./gltf-variants-DFbr8EES.js");
+    const materialVariants = await loadVariantMaterials(ctx._json, ctx._binChunk, ctx._baseUrl, variantNames, meshes, ctx._engine, ctx._matExts, ctx._wrapTex);
+    return { materialVariants };
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-variants-Ds6v9byg.js.map

package/gltf-feature-variants-Ds6v9byg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-variants-Ds6v9byg.js","sources":["../src/loader-gltf/gltf-feature-variants.ts"],"sourcesContent":["/** KHR_materials_variants feature.\n *  Triggered when the root extension carries variant definitions. Per-asset\n *  hook builds variant material data shared with the material-ext driver. */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst feature: GltfFeature = {\n    id: \"KHR_materials_variants\",\n    async applyAsset(meshes, _root, ctx) {\n        const variantNames: string[] | undefined = ctx._json.extensions?.KHR_materials_variants?.variants?.map((v: { name: string }) => v.name);\n        if (!variantNames?.length) {\n            return {};\n        }\n        const { loadVariantMaterials } = await import(\"./gltf-variants.js\");\n        const materialVariants = await loadVariantMaterials(ctx._json, ctx._binChunk, ctx._baseUrl, variantNames, meshes, ctx._engine, ctx._matExts, ctx._wrapTex);\n        return { materialVariants };\n    },\n};\nexport default feature;\n"],"names":[],"mappings":"AAMA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,WAAW,QAAQ,OAAO,KAAK;AAFzC;AAGQ,UAAM,gBAAqC,qBAAI,MAAM,eAAV,mBAAsB,2BAAtB,mBAA8C,aAA9C,mBAAwD,IAAI,CAAC,MAAwB,EAAE;AAClI,QAAI,EAAC,6CAAc,SAAQ;AACvB,aAAO,CAAA;AAAA,IACX;AACA,UAAM,EAAE,qBAAA,IAAyB,MAAM,OAAO,6BAAoB;AAClE,UAAM,mBAAmB,MAAM,qBAAqB,IAAI,OAAO,IAAI,WAAW,IAAI,UAAU,cAAc,QAAQ,IAAI,SAAS,IAAI,UAAU,IAAI,QAAQ;AACzJ,WAAO,EAAE,iBAAA;AAAA,EACb;AACJ;"}

package/gltf-feature-xmp-BUfq_IVG.js

@@ -0,0 +1,15 @@
+const feature = {
+  id: "KHR_xmp_json_ld",
+  async applyAsset(_meshes, _root, ctx) {
+    var _a, _b, _c, _d, _e;
+    const json = ctx._json;
+    const packets = ((_b = (_a = json.extensions) == null ? void 0 : _a.KHR_xmp_json_ld) == null ? void 0 : _b.packets) ?? [];
+    const assetPacketIndex = (_e = (_d = (_c = json.asset) == null ? void 0 : _c.extensions) == null ? void 0 : _d.KHR_xmp_json_ld) == null ? void 0 : _e.packet;
+    const assetPacket = assetPacketIndex !== void 0 ? packets[assetPacketIndex] : void 0;
+    return { xmpMetadata: { packets, assetPacket } };
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-xmp-BUfq_IVG.js.map