@babylonjs/lite 0.1.1

package/gltf-ext-dielectric-qHzlnvdl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-dielectric-qHzlnvdl.js","sources":["../src/loader-gltf/gltf-ext-dielectric.ts"],"sourcesContent":["/** Combined loader for the glTF extensions commonly used together for\n *  dielectric / glass-like materials — KHR_materials_ior, _specular,\n *  _transmission, _volume, and _dispersion.\n *\n *  All four are consolidated into a single ext so:\n *   - the three that populate `subsurface` (ior + volume + transmission)\n *     don't need a deep-merge in `runMatExts` (each would otherwise overwrite\n *     the others' subsurface contributions);\n *   - load-gltf.ts pays only one registration-table entry for the whole set.\n *\n *  Loaded when ANY of the four extensions is declared in extensionsUsed.\n *  Only fields actually declared on each material are populated.\n *\n *  KHR_materials_ior:\n *    ior → subsurface.refraction.indexOfRefraction\n *        + base-layer F0 remap (F0 = ((ior-1)/(ior+1))^2).\n *\n *  KHR_materials_specular:\n *    specularFactor        → metallicF0Factor (scalar F0 multiplier)\n *    specularColorFactor   → metallicReflectanceColor (dielectric tint)\n *    specularTexture       → metallicReflectanceTexture (A=F0 scalar)\n *                             (useOnlyMetallicFromMetallicReflectanceTexture=true)\n *    specularColorTexture  → reflectanceTexture (RGB=dielectric tint)\n *\n *  KHR_materials_volume:\n *    thicknessFactor/Texture → subsurface.thickness (G-channel per spec)\n *    attenuationColor/Distance → subsurface.tint\n *\n *  KHR_materials_transmission:\n *    transmissionFactor/Texture → subsurface.refraction.intensity/texture\n *\n *  PR 1 wires the data only — the PBR refraction shader path lands in PR 2.\n *  Until then, transmissive materials render as opaque. */\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport type { PbrMaterialProps, RefractionProps } from \"../material/pbr/pbr-material.js\";\n\nconst ext: GltfFeature = {\n    id: \"KHR_materials_dielectric\",\n    async applyMaterial(mat, ctx) {\n        const exts = mat._rawMatDef?.extensions;\n        if (!exts) {\n            return null;\n        }\n        const eIor = exts.KHR_materials_ior;\n        const eSp = exts.KHR_materials_specular;\n        const eVol = exts.KHR_materials_volume;\n        const eTx = exts.KHR_materials_transmission;\n        const eDisp = exts.KHR_materials_dispersion;\n        if (!eIor && !eSp && !eVol && !eTx && !eDisp) {\n            return null;\n        }\n\n        const [specTex, specColTex, thickTex, transTex] = await Promise.all([\n            ctx._texture(eSp?.specularTexture, false),\n            ctx._texture(eSp?.specularColorTexture, true),\n            ctx._texture(eVol?.thicknessTexture, false),\n            ctx._texture(eTx?.transmissionTexture, false),\n        ]);\n\n        const out: Partial<PbrMaterialProps> = {};\n        const subsurface: NonNullable<PbrMaterialProps[\"subsurface\"]> = {};\n\n        if (eIor) {\n            const ior: number = typeof eIor.ior === \"number\" ? eIor.ior : 1.5;\n            // Skip writing metallicF0Factor at default IOR 1.5 (F0=0.04 → factor=1).\n            // JS floats compute ((0.5/2.5)^2)/0.04 as 1.0000000000000002, which\n            // would trigger the reflectance-factor code path and pull in the\n            // reflectance fragment for every KHR_materials_ior scene with\n            // default IOR. Only write when the factor meaningfully differs.\n            if (ior !== 1.5) {\n                out.metallicF0Factor = ((ior - 1) / (ior + 1)) ** 2 / 0.04;\n                out.specularWeight = 1.0;\n                (out as { _hasReflExt?: boolean })._hasReflExt = true;\n            }\n            subsurface.refraction = { indexOfRefraction: ior };\n        }\n\n        if (eSp) {\n            // specularFactor replaces the base dielectric F0 scalar. When ior was\n            // also specified, this overrides it (spec says specular wins).\n            if (typeof eSp.specularFactor === \"number\") {\n                if (Math.abs(eSp.specularFactor - 1) > 1e-6) {\n                    out.metallicF0Factor = eSp.specularFactor;\n                    out.specularWeight = eSp.specularFactor;\n                    (out as { _hasReflExt?: boolean })._hasReflExt = true;\n                } else {\n                    delete out.metallicF0Factor;\n                    delete out.specularWeight;\n                }\n            }\n            if (Array.isArray(eSp.specularColorFactor) && eSp.specularColorFactor.length === 3) {\n                if (eSp.specularColorFactor[0] !== 1 || eSp.specularColorFactor[1] !== 1 || eSp.specularColorFactor[2] !== 1) {\n                    out.metallicReflectanceColor = [eSp.specularColorFactor[0], eSp.specularColorFactor[1], eSp.specularColorFactor[2]];\n                    (out as { _hasReflExt?: boolean })._hasReflExt = true;\n                }\n            }\n            if (specTex) {\n                out.metallicReflectanceTexture = specTex;\n                out.useOnlyMetallicFromMetallicReflectanceTexture = true;\n            }\n            if (specColTex) {\n                out.reflectanceTexture = specColTex;\n            }\n        }\n\n        if (eVol) {\n            const thicknessFactor: number = typeof eVol.thicknessFactor === \"number\" ? eVol.thicknessFactor : 0;\n            if (thicknessFactor > 0 || thickTex) {\n                subsurface.thickness = {\n                    min: 0,\n                    max: thicknessFactor || 1,\n                    useGlTFChannel: true,\n                    ...(thickTex ? { texture: thickTex } : undefined),\n                };\n            }\n            const color = Array.isArray(eVol.attenuationColor) && eVol.attenuationColor.length === 3 ? (eVol.attenuationColor as [number, number, number]) : undefined;\n            const atDistance: number | undefined = typeof eVol.attenuationDistance === \"number\" ? eVol.attenuationDistance : undefined;\n            if (color || atDistance !== undefined) {\n                subsurface.tint = {\n                    ...(color ? { color } : undefined),\n                    ...(atDistance !== undefined ? { atDistance } : undefined),\n                };\n            } else if (subsurface.thickness) {\n                // KHR_materials_volume without attenuation: spec defaults to white at\n                // infinite distance (no absorption), but the thickness is a real local\n                // depth that must engage the volume path so it is world-scaled (else it\n                // overshoots on non-unit-scaled models, e.g. MosquitoInAmber). White tint\n                // gives volumeParams = log(1)/dist = 0 → ab = exp(0) = 1 (no tint).\n                subsurface.tint = { color: [1, 1, 1], atDistance: 1 };\n            }\n        }\n\n        if (eTx) {\n            const intensity: number = typeof eTx.transmissionFactor === \"number\" ? eTx.transmissionFactor : 0;\n            if (intensity > 0 || transTex) {\n                out.transmissive = true;\n                const refraction: RefractionProps = {\n                    ...(subsurface.refraction ?? {}),\n                    intensity,\n                    useThicknessAsDepth: !!subsurface.thickness,\n                    ...(transTex ? { texture: transTex } : undefined),\n                };\n                subsurface.refraction = refraction;\n            }\n        }\n\n        // KHR_materials_dispersion: per-channel chromatic refraction. Only meaningful on\n        // a volumetric transmissive material (the extension requires KHR_materials_volume).\n        // The shader spread uses Babylon's empirical dispersion strength with a fixed Abbe\n        // number of 20, so the glTF dispersion value maps to strength = 20 / dispersion\n        // (larger glTF dispersion ⇒ larger Abbe ⇒ weaker chromatic spread).\n        if (eDisp && typeof eDisp.dispersion === \"number\" && eDisp.dispersion > 0 && subsurface.refraction && subsurface.thickness) {\n            subsurface.refraction = { ...subsurface.refraction, dispersion: 20.0 / eDisp.dispersion };\n        }\n\n        if (Object.keys(subsurface).length > 0) {\n            out.subsurface = subsurface;\n        }\n        return Object.keys(out).length > 0 ? out : null;\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"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"}

package/gltf-ext-emissive-strength-nzGZXZVK.js

@@ -0,0 +1,19 @@
+const ext = {
+  id: "KHR_materials_emissive_strength",
+  async applyMaterial(mat) {
+    var _a, _b;
+    const e = (_b = (_a = mat._rawMatDef) == null ? void 0 : _a.extensions) == null ? void 0 : _b.KHR_materials_emissive_strength;
+    if (!e) {
+      return null;
+    }
+    const s = e.emissiveStrength ?? 1;
+    const f = mat._emissiveFactor;
+    return {
+      emissiveColor: [f[0] * s, f[1] * s, f[2] * s]
+    };
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-emissive-strength-nzGZXZVK.js.map

package/gltf-ext-emissive-strength-nzGZXZVK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-emissive-strength-nzGZXZVK.js","sources":["../src/loader-gltf/gltf-ext-emissive-strength.ts"],"sourcesContent":["/** glTF KHR_materials_emissive_strength extension.\n *  Multiplies the material's emissiveFactor by `emissiveStrength` and pushes the\n *  result into `emissiveColor` (HDR — may exceed 1.0). The core PBR shader then\n *  samples the emissive texture, multiplies by this factor, and lets tonemap +\n *  exposure compress the result back into display range.\n *\n *  Registering this ext also activates the emissive-color fragment (via\n *  PBR_HAS_EMISSIVE_COLOR in mesh-features.ts → `!!mat.emissiveColor`), so\n *  scenes without the extension pay zero bytes. */\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst ext: GltfFeature = {\n    id: \"KHR_materials_emissive_strength\",\n    async applyMaterial(mat) {\n        const e = mat._rawMatDef?.extensions?.KHR_materials_emissive_strength;\n        if (!e) {\n            return null;\n        }\n        const s = e.emissiveStrength ?? 1.0;\n        const f = mat._emissiveFactor;\n        return {\n            emissiveColor: [f[0] * s, f[1] * s, f[2] * s],\n        };\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"AAWA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,cAAc,KAAK;AAF7B;AAGQ,UAAM,KAAI,eAAI,eAAJ,mBAAgB,eAAhB,mBAA4B;AACtC,QAAI,CAAC,GAAG;AACJ,aAAO;AAAA,IACX;AACA,UAAM,IAAI,EAAE,oBAAoB;AAChC,UAAM,IAAI,IAAI;AACd,WAAO;AAAA,MACH,eAAe,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;AAAA,IAAA;AAAA,EAEpD;AACJ;"}

package/gltf-ext-iridescence-C6bq7jiM.js

@@ -0,0 +1,26 @@
+const ext = {
+  id: "KHR_materials_iridescence",
+  async applyMaterial(mat, ctx) {
+    var _a, _b;
+    const iri = (_b = (_a = mat._rawMatDef) == null ? void 0 : _a.extensions) == null ? void 0 : _b.KHR_materials_iridescence;
+    if (!iri) {
+      return null;
+    }
+    const [tex, thicknessTex] = await Promise.all([ctx._texture(iri.iridescenceTexture, true), ctx._texture(iri.iridescenceThicknessTexture, true)]);
+    return {
+      iridescence: {
+        isEnabled: true,
+        intensity: iri.iridescenceFactor ?? 0,
+        indexOfRefraction: iri.iridescenceIor ?? 1.3,
+        minimumThickness: iri.iridescenceThicknessMinimum ?? 100,
+        maximumThickness: iri.iridescenceThicknessMaximum ?? 400,
+        texture: tex,
+        thicknessTexture: thicknessTex
+      }
+    };
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-iridescence-C6bq7jiM.js.map

package/gltf-ext-iridescence-C6bq7jiM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-iridescence-C6bq7jiM.js","sources":["../src/loader-gltf/gltf-ext-iridescence.ts"],"sourcesContent":["/** glTF KHR_materials_iridescence extension. */\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst ext: GltfFeature = {\n    id: \"KHR_materials_iridescence\",\n    async applyMaterial(mat, ctx) {\n        const iri = mat._rawMatDef?.extensions?.KHR_materials_iridescence;\n        if (!iri) {\n            return null;\n        }\n        // Babylon.js' KHR_materials_iridescence loader samples these extension textures through the gamma-space path.\n        // Use sRGB uploads for parity, even though the glTF channels are scalar data.\n        const [tex, thicknessTex] = await Promise.all([ctx._texture(iri.iridescenceTexture, true), ctx._texture(iri.iridescenceThicknessTexture, true)]);\n        return {\n            iridescence: {\n                isEnabled: true,\n                intensity: iri.iridescenceFactor ?? 0,\n                indexOfRefraction: iri.iridescenceIor ?? 1.3,\n                minimumThickness: iri.iridescenceThicknessMinimum ?? 100,\n                maximumThickness: iri.iridescenceThicknessMaximum ?? 400,\n                texture: tex,\n                thicknessTexture: thicknessTex,\n            },\n        } as Partial<import(\"../material/pbr/pbr-material.js\").PbrMaterialProps>;\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"AAGA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,cAAc,KAAK,KAAK;AAFlC;AAGQ,UAAM,OAAM,eAAI,eAAJ,mBAAgB,eAAhB,mBAA4B;AACxC,QAAI,CAAC,KAAK;AACN,aAAO;AAAA,IACX;AAGA,UAAM,CAAC,KAAK,YAAY,IAAI,MAAM,QAAQ,IAAI,CAAC,IAAI,SAAS,IAAI,oBAAoB,IAAI,GAAG,IAAI,SAAS,IAAI,6BAA6B,IAAI,CAAC,CAAC;AAC/I,WAAO;AAAA,MACH,aAAa;AAAA,QACT,WAAW;AAAA,QACX,WAAW,IAAI,qBAAqB;AAAA,QACpC,mBAAmB,IAAI,kBAAkB;AAAA,QACzC,kBAAkB,IAAI,+BAA+B;AAAA,QACrD,kBAAkB,IAAI,+BAA+B;AAAA,QACrD,SAAS;AAAA,QACT,kBAAkB;AAAA,MAAA;AAAA,IACtB;AAAA,EAER;AACJ;"}

package/gltf-ext-node-visibility-MafA9ot2.js

@@ -0,0 +1,25 @@
+import { h as setSubtreeVisible } from "./index-C8HOR2sB.js";
+function applyVisibility(json, nodeMap) {
+  var _a, _b, _c;
+  const nodes = json.nodes ?? [];
+  for (let i = 0; i < nodes.length; i++) {
+    const vis = (_c = (_b = (_a = nodes[i]) == null ? void 0 : _a.extensions) == null ? void 0 : _b.KHR_node_visibility) == null ? void 0 : _c.visible;
+    const sn = nodeMap[i];
+    if (vis === false && sn) {
+      setSubtreeVisible(sn, false);
+    }
+  }
+}
+const ext = {
+  id: "KHR_node_visibility",
+  async applyAsset(_meshes, _root, ctx) {
+    if (ctx._nodeMap) {
+      applyVisibility(ctx._json, ctx._nodeMap);
+    }
+    return {};
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-node-visibility-MafA9ot2.js.map

package/gltf-ext-node-visibility-MafA9ot2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-node-visibility-MafA9ot2.js","sources":["../src/loader-gltf/gltf-ext-node-visibility.ts"],"sourcesContent":["/** glTF KHR_node_visibility extension.\n *\n *  Sets `node.visible = false` on SceneNodes whose glTF node has\n *  `extensions.KHR_node_visibility.visible === false`, and cascades\n *  through the subtree via `setSubtreeVisible` so that descendants\n *  inherit the invisibility per the extension spec. The render path\n *  and camera-AABB filter then skip them. Combined with\n *  KHR_animation_pointer, the visible flag can also be toggled at runtime.\n *\n *  Dynamically imported by load-gltf only when the asset declares the\n *  extension in `extensionsUsed`, so bundles pay zero bytes otherwise. */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport type { SceneNode } from \"../scene/scene-node.js\";\nimport { setSubtreeVisible } from \"../scene/visibility.js\";\n\nfunction applyVisibility(json: any, nodeMap: readonly (SceneNode | undefined)[]): void {\n    const nodes = json.nodes ?? [];\n    for (let i = 0; i < nodes.length; i++) {\n        const vis = nodes[i]?.extensions?.KHR_node_visibility?.visible;\n        const sn = nodeMap[i];\n        if (vis === false && sn) {\n            setSubtreeVisible(sn, false);\n        }\n    }\n}\n\nconst ext: GltfFeature = {\n    id: \"KHR_node_visibility\",\n    async applyAsset(_meshes, _root, ctx) {\n        if (ctx._nodeMap) {\n            applyVisibility(ctx._json, ctx._nodeMap);\n        }\n        return {};\n    },\n};\nexport default ext;\n"],"names":[],"mappings":";AAgBA,SAAS,gBAAgB,MAAW,SAAmD;;AACnF,QAAM,QAAQ,KAAK,SAAS,CAAA;AAC5B,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,UAAM,OAAM,uBAAM,CAAC,MAAP,mBAAU,eAAV,mBAAsB,wBAAtB,mBAA2C;AACvD,UAAM,KAAK,QAAQ,CAAC;AACpB,QAAI,QAAQ,SAAS,IAAI;AACrB,wBAAkB,IAAI,KAAK;AAAA,IAC/B;AAAA,EACJ;AACJ;AAEA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,WAAW,SAAS,OAAO,KAAK;AAClC,QAAI,IAAI,UAAU;AACd,sBAAgB,IAAI,OAAO,IAAI,QAAQ;AAAA,IAC3C;AACA,WAAO,CAAA;AAAA,EACX;AACJ;"}

package/gltf-ext-orm-CT18G_vQ.js

@@ -0,0 +1,33 @@
+async function compositeOrm(mr, occ) {
+  const w = mr.width;
+  const h = mr.height;
+  const c1 = new OffscreenCanvas(w, h);
+  const x1 = c1.getContext("2d");
+  x1.drawImage(mr, 0, 0, w, h);
+  const d1 = x1.getImageData(0, 0, w, h);
+  const c2 = new OffscreenCanvas(w, h);
+  const x2 = c2.getContext("2d");
+  x2.drawImage(occ, 0, 0, w, h);
+  const d2 = x2.getImageData(0, 0, w, h);
+  for (let j = 0; j < d1.data.length; j += 4) {
+    d1.data[j] = d2.data[j];
+  }
+  x1.putImageData(d1, 0, 0);
+  return createImageBitmap(c1);
+}
+const ext = {
+  id: "_orm-composite",
+  async applyMaterial(mat, ctx) {
+    const mr = mat._metallicRoughnessImage;
+    const occ = mat._occlusionImage;
+    if (!mr || !occ || mr === occ) {
+      return null;
+    }
+    const bmp = await compositeOrm(mr, occ);
+    return { ormTexture: ctx._uploadImage(bmp, false) };
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-orm-CT18G_vQ.js.map

package/gltf-ext-orm-CT18G_vQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-orm-CT18G_vQ.js","sources":["../src/loader-gltf/gltf-ext-orm.ts"],"sourcesContent":["/** ORM compositing — packs separate metallic-roughness + occlusion bitmaps\n *  into a single ORM texture (R=occlusion, G=roughness, B=metallic).\n *\n *  Loaded only when the asset has at least one material with both a\n *  metallicRoughnessTexture and a separate occlusionTexture — see the\n *  `needs()` gate in load-gltf.ts. Materials that already ship packed ORM (or\n *  no occlusion at all) take the core's default ORM upload path and never hit\n *  this module. */\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nasync function compositeOrm(mr: ImageBitmap, occ: ImageBitmap): Promise<ImageBitmap> {\n    const w = mr.width;\n    const h = mr.height;\n    const c1 = new OffscreenCanvas(w, h);\n    const x1 = c1.getContext(\"2d\")!;\n    x1.drawImage(mr, 0, 0, w, h);\n    const d1 = x1.getImageData(0, 0, w, h);\n    const c2 = new OffscreenCanvas(w, h);\n    const x2 = c2.getContext(\"2d\")!;\n    x2.drawImage(occ, 0, 0, w, h);\n    const d2 = x2.getImageData(0, 0, w, h);\n    for (let j = 0; j < d1.data.length; j += 4) {\n        d1.data[j] = d2.data[j]!;\n    }\n    x1.putImageData(d1, 0, 0);\n    return createImageBitmap(c1);\n}\n\nconst ext: GltfFeature = {\n    id: \"_orm-composite\",\n    async applyMaterial(mat, ctx) {\n        const mr = mat._metallicRoughnessImage;\n        const occ = mat._occlusionImage;\n        if (!mr || !occ || mr === occ) {\n            return null;\n        }\n        const bmp = await compositeOrm(mr, occ);\n        return { ormTexture: ctx._uploadImage(bmp, false) };\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"AAUA,eAAe,aAAa,IAAiB,KAAwC;AACjF,QAAM,IAAI,GAAG;AACb,QAAM,IAAI,GAAG;AACb,QAAM,KAAK,IAAI,gBAAgB,GAAG,CAAC;AACnC,QAAM,KAAK,GAAG,WAAW,IAAI;AAC7B,KAAG,UAAU,IAAI,GAAG,GAAG,GAAG,CAAC;AAC3B,QAAM,KAAK,GAAG,aAAa,GAAG,GAAG,GAAG,CAAC;AACrC,QAAM,KAAK,IAAI,gBAAgB,GAAG,CAAC;AACnC,QAAM,KAAK,GAAG,WAAW,IAAI;AAC7B,KAAG,UAAU,KAAK,GAAG,GAAG,GAAG,CAAC;AAC5B,QAAM,KAAK,GAAG,aAAa,GAAG,GAAG,GAAG,CAAC;AACrC,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK,QAAQ,KAAK,GAAG;AACxC,OAAG,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC;AAAA,EAC1B;AACA,KAAG,aAAa,IAAI,GAAG,CAAC;AACxB,SAAO,kBAAkB,EAAE;AAC/B;AAEA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,cAAc,KAAK,KAAK;AAC1B,UAAM,KAAK,IAAI;AACf,UAAM,MAAM,IAAI;AAChB,QAAI,CAAC,MAAM,CAAC,OAAO,OAAO,KAAK;AAC3B,aAAO;AAAA,IACX;AACA,UAAM,MAAM,MAAM,aAAa,IAAI,GAAG;AACtC,WAAO,EAAE,YAAY,IAAI,aAAa,KAAK,KAAK,EAAA;AAAA,EACpD;AACJ;"}

package/gltf-ext-quantization-CpZyLDIz.js

@@ -0,0 +1,94 @@
+const BYTE = 5120;
+const UNSIGNED_BYTE = 5121;
+const SHORT = 5122;
+const UNSIGNED_SHORT = 5123;
+const FLOAT = 5126;
+const TYPE_COMPONENTS = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };
+const COMPONENT_BYTES = { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 };
+function align4(n) {
+  return n + 3 & -4;
+}
+function readComponent(view, offset, componentType, normalized) {
+  switch (componentType) {
+    case BYTE: {
+      const c = view.getInt8(offset);
+      return normalized ? Math.max(c / 127, -1) : c;
+    }
+    case UNSIGNED_BYTE: {
+      const c = view.getUint8(offset);
+      return normalized ? c / 255 : c;
+    }
+    case SHORT: {
+      const c = view.getInt16(offset, true);
+      return normalized ? Math.max(c / 32767, -1) : c;
+    }
+    case UNSIGNED_SHORT: {
+      const c = view.getUint16(offset, true);
+      return normalized ? c / 65535 : c;
+    }
+    case FLOAT:
+      return view.getFloat32(offset, true);
+    default:
+      throw new Error(`KHR_mesh_quantization: unsupported componentType ${componentType}`);
+  }
+}
+const feature = {
+  id: "KHR_mesh_quantization",
+  async preParse(json, binChunk) {
+    var _a;
+    const accessors = json.accessors ?? [];
+    const bufferViews = json.bufferViews ?? [];
+    const convert = [];
+    let appended = 0;
+    for (let i = 0; i < accessors.length; i++) {
+      const a = accessors[i];
+      if (a.bufferView === void 0) {
+        continue;
+      }
+      const componentCount = TYPE_COMPONENTS[a.type] ?? 1;
+      const stride = (_a = bufferViews[a.bufferView]) == null ? void 0 : _a.byteStride;
+      const signed = a.componentType === BYTE || a.componentType === SHORT;
+      const stridedFloat = a.componentType === FLOAT && stride !== void 0 && stride !== componentCount * 4;
+      if (signed || a.normalized === true || stridedFloat) {
+        convert.push(i);
+        appended = align4(appended + a.count * componentCount * 4);
+      }
+    }
+    if (convert.length === 0) {
+      return;
+    }
+    const baseLen = align4(binChunk.byteLength);
+    const out = new ArrayBuffer(baseLen + appended);
+    new Uint8Array(out).set(new Uint8Array(binChunk.buffer, binChunk.byteOffset, binChunk.byteLength));
+    const outView = new DataView(out);
+    let cursor = baseLen;
+    for (const i of convert) {
+      const a = accessors[i];
+      const bv = bufferViews[a.bufferView];
+      const componentCount = TYPE_COMPONENTS[a.type] ?? 1;
+      const compBytes = COMPONENT_BYTES[a.componentType];
+      const stride = bv.byteStride ?? componentCount * compBytes;
+      const srcBase = (bv.byteOffset ?? 0) + (a.byteOffset ?? 0);
+      const dstOffset = cursor;
+      for (let v = 0; v < a.count; v++) {
+        for (let c = 0; c < componentCount; c++) {
+          const value = readComponent(binChunk, srcBase + v * stride + c * compBytes, a.componentType, !!a.normalized);
+          outView.setFloat32(dstOffset + (v * componentCount + c) * 4, value, true);
+        }
+      }
+      const byteLength = a.count * componentCount * 4;
+      const newBvIndex = bufferViews.length;
+      bufferViews.push({ buffer: 0, byteOffset: dstOffset, byteLength });
+      a.bufferView = newBvIndex;
+      a.byteOffset = 0;
+      a.componentType = FLOAT;
+      a.normalized = false;
+      cursor = align4(cursor + byteLength);
+    }
+    return outView;
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-ext-quantization-CpZyLDIz.js.map

package/gltf-ext-quantization-CpZyLDIz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-quantization-CpZyLDIz.js","sources":["../src/loader-gltf/gltf-ext-quantization.ts"],"sourcesContent":["/**\n * KHR_mesh_quantization (+ post-meshopt) dequantization feature.\n *\n * Runs as a `preParse` hook, after EXT_meshopt_compression. The core accessor\n * reader (`resolveAccessor`) only understands tightly-packed FLOAT / UBYTE /\n * USHORT / UINT data and ignores `byteStride`; quantized assets store vertex\n * attributes (and meshopt-filtered animation outputs) as normalized or signed\n * integers, sometimes padded by a `byteStride`. This feature rewrites every such\n * accessor into a freshly-appended, tightly-packed FLOAT bufferView so the rest\n * of the loader stays completely unaware of quantization. It is dynamic-imported\n * only when `extensionsUsed` lists KHR_mesh_quantization, so non-quantized scenes\n * pay nothing.\n *\n * Conversion rule (role-agnostic, derived from the accessor alone):\n *   - signed component types (BYTE/SHORT) → FLOAT (core would otherwise throw)\n *   - `normalized` accessors → FLOAT (core would otherwise read raw ints)\n *   - strided FLOAT accessors → tightly-packed FLOAT (core ignores byteStride)\n * Unsigned non-normalized integer accessors (JOINTS_0, indices) are left intact:\n * they are already tight and the skeleton / index paths expect integers.\n */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst BYTE = 5120;\nconst UNSIGNED_BYTE = 5121;\nconst SHORT = 5122;\nconst UNSIGNED_SHORT = 5123;\nconst FLOAT = 5126;\n\nconst TYPE_COMPONENTS: Record<string, number> = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };\nconst COMPONENT_BYTES: Record<number, number> = { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 };\n\ninterface Accessor {\n    bufferView?: number;\n    byteOffset?: number;\n    componentType: number;\n    normalized?: boolean;\n    count: number;\n    type: string;\n}\n\ninterface BufferView {\n    buffer?: number;\n    byteOffset?: number;\n    byteLength: number;\n    byteStride?: number;\n}\n\nfunction align4(n: number): number {\n    return (n + 3) & ~3;\n}\n\n/** Read one component as a float, applying glTF normalization when requested. */\nfunction readComponent(view: DataView, offset: number, componentType: number, normalized: boolean): number {\n    switch (componentType) {\n        case BYTE: {\n            const c = view.getInt8(offset);\n            return normalized ? Math.max(c / 127, -1) : c;\n        }\n        case UNSIGNED_BYTE: {\n            const c = view.getUint8(offset);\n            return normalized ? c / 255 : c;\n        }\n        case SHORT: {\n            const c = view.getInt16(offset, true);\n            return normalized ? Math.max(c / 32767, -1) : c;\n        }\n        case UNSIGNED_SHORT: {\n            const c = view.getUint16(offset, true);\n            return normalized ? c / 65535 : c;\n        }\n        case FLOAT:\n            return view.getFloat32(offset, true);\n        default:\n            throw new Error(`KHR_mesh_quantization: unsupported componentType ${componentType}`);\n    }\n}\n\nconst feature: GltfFeature = {\n    id: \"KHR_mesh_quantization\",\n    async preParse(json, binChunk) {\n        const accessors: Accessor[] = json.accessors ?? [];\n        const bufferViews: BufferView[] = json.bufferViews ?? [];\n\n        // Decide which accessors need rewriting and how many float bytes to append.\n        const convert: number[] = [];\n        let appended = 0;\n        for (let i = 0; i < accessors.length; i++) {\n            const a = accessors[i]!;\n            if (a.bufferView === undefined) {\n                continue;\n            }\n            const componentCount = TYPE_COMPONENTS[a.type] ?? 1;\n            const stride = bufferViews[a.bufferView]?.byteStride;\n            const signed = a.componentType === BYTE || a.componentType === SHORT;\n            const stridedFloat = a.componentType === FLOAT && stride !== undefined && stride !== componentCount * 4;\n            if (signed || a.normalized === true || stridedFloat) {\n                convert.push(i);\n                appended = align4(appended + a.count * componentCount * 4);\n            }\n        }\n\n        if (convert.length === 0) {\n            return;\n        }\n\n        // Build a new buffer: existing data (normalized to offset 0) + appended floats.\n        const baseLen = align4(binChunk.byteLength);\n        const out = new ArrayBuffer(baseLen + appended);\n        new Uint8Array(out).set(new Uint8Array(binChunk.buffer, binChunk.byteOffset, binChunk.byteLength));\n        const outView = new DataView(out);\n\n        let cursor = baseLen;\n        for (const i of convert) {\n            const a = accessors[i]!;\n            const bv = bufferViews[a.bufferView!]!;\n            const componentCount = TYPE_COMPONENTS[a.type] ?? 1;\n            const compBytes = COMPONENT_BYTES[a.componentType]!;\n            const stride = bv.byteStride ?? componentCount * compBytes;\n            // bufferView/accessor byteOffsets are relative to the DataView's own\n            // byteOffset (DataView getters add it back), matching resolveAccessor.\n            const srcBase = (bv.byteOffset ?? 0) + (a.byteOffset ?? 0);\n\n            const dstOffset = cursor;\n            for (let v = 0; v < a.count; v++) {\n                for (let c = 0; c < componentCount; c++) {\n                    const value = readComponent(binChunk, srcBase + v * stride + c * compBytes, a.componentType, !!a.normalized);\n                    outView.setFloat32(dstOffset + (v * componentCount + c) * 4, value, true);\n                }\n            }\n\n            const byteLength = a.count * componentCount * 4;\n            const newBvIndex = bufferViews.length;\n            bufferViews.push({ buffer: 0, byteOffset: dstOffset, byteLength });\n            a.bufferView = newBvIndex;\n            a.byteOffset = 0;\n            a.componentType = FLOAT;\n            a.normalized = false;\n            cursor = align4(cursor + byteLength);\n        }\n\n        return outView;\n    },\n};\n\nexport default feature;\n"],"names":[],"mappings":"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"}

package/gltf-ext-sheen-BgIxUzyZ.js

@@ -0,0 +1,25 @@
+const ext = {
+  id: "KHR_materials_sheen",
+  async applyMaterial(mat, ctx) {
+    var _a, _b;
+    const s = (_b = (_a = mat._rawMatDef) == null ? void 0 : _a.extensions) == null ? void 0 : _b.KHR_materials_sheen;
+    if (!s) {
+      return null;
+    }
+    const tex = await ctx._texture(s.sheenColorTexture, true);
+    return {
+      sheen: {
+        isEnabled: true,
+        color: s.sheenColorFactor ?? [0, 0, 0],
+        roughness: s.sheenRoughnessFactor ?? 0,
+        intensity: 1,
+        texture: tex,
+        albedoScaling: true
+      }
+    };
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-sheen-BgIxUzyZ.js.map

package/gltf-ext-sheen-BgIxUzyZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-sheen-BgIxUzyZ.js","sources":["../src/loader-gltf/gltf-ext-sheen.ts"],"sourcesContent":["/** glTF KHR_materials_sheen extension.\n *  Only the color texture is fetched (sRGB); when the asset packs roughness in\n *  the alpha channel of the same image, the runtime sheen path samples both\n *  from `texture` directly. Distinct sheenRoughnessTexture images are not\n *  currently supported. */\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst ext: GltfFeature = {\n    id: \"KHR_materials_sheen\",\n    async applyMaterial(mat, ctx) {\n        const s = mat._rawMatDef?.extensions?.KHR_materials_sheen;\n        if (!s) {\n            return null;\n        }\n        const tex = await ctx._texture(s.sheenColorTexture, true);\n        return {\n            sheen: {\n                isEnabled: true,\n                color: s.sheenColorFactor ?? [0, 0, 0],\n                roughness: s.sheenRoughnessFactor ?? 0,\n                intensity: 1,\n                texture: tex,\n                albedoScaling: true,\n            },\n        };\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"AAOA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,cAAc,KAAK,KAAK;AAFlC;AAGQ,UAAM,KAAI,eAAI,eAAJ,mBAAgB,eAAhB,mBAA4B;AACtC,QAAI,CAAC,GAAG;AACJ,aAAO;AAAA,IACX;AACA,UAAM,MAAM,MAAM,IAAI,SAAS,EAAE,mBAAmB,IAAI;AACxD,WAAO;AAAA,MACH,OAAO;AAAA,QACH,WAAW;AAAA,QACX,OAAO,EAAE,oBAAoB,CAAC,GAAG,GAAG,CAAC;AAAA,QACrC,WAAW,EAAE,wBAAwB;AAAA,QACrC,WAAW;AAAA,QACX,SAAS;AAAA,QACT,eAAe;AAAA,MAAA;AAAA,IACnB;AAAA,EAER;AACJ;"}

package/gltf-ext-spec-gloss-D0LJLBUM.js

@@ -0,0 +1,24 @@
+const ext = {
+  id: "KHR_materials_pbrSpecularGlossiness",
+  async applyMaterial(mat, ctx) {
+    var _a, _b;
+    const sg = (_b = (_a = mat._rawMatDef) == null ? void 0 : _a.extensions) == null ? void 0 : _b.KHR_materials_pbrSpecularGlossiness;
+    if (!sg) {
+      return null;
+    }
+    const [diffuse, specGloss] = await Promise.all([ctx._texture(sg.diffuseTexture, true), ctx._texture(sg.specularGlossinessTexture, true)]);
+    const sf = sg.specularFactor;
+    const out = { metallicFactor: 0, roughnessFactor: 1 - (sg.glossinessFactor ?? 1), reflectance: sf ? Math.max(sf[0], sf[1], sf[2]) : 1 };
+    if (diffuse) {
+      out.baseColorTexture = diffuse;
+    }
+    if (specGloss) {
+      out.specGlossTexture = specGloss;
+    }
+    return out;
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-spec-gloss-D0LJLBUM.js.map

package/gltf-ext-spec-gloss-D0LJLBUM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-spec-gloss-D0LJLBUM.js","sources":["../src/loader-gltf/gltf-ext-spec-gloss.ts"],"sourcesContent":["/** glTF KHR_materials_pbrSpecularGlossiness extension.\n *\n *  Replaces the metallic-roughness workflow:\n *    - diffuseTexture → baseColorTexture\n *    - specularGlossinessTexture → specGlossTexture (RGB=specular, A=glossiness)\n *\n *  Returned values override the core base-material fields via Object.assign\n *  merge order in the loader.\n *\n *  Note: spec-gloss `diffuseFactor` is currently propagated via the core\n *  `GltfMaterialData.baseColorFactor` (which defaults to [1,1,1,1] for assets\n *  that omit pbrMetallicRoughness). Spec-gloss models in our test corpus all\n *  carry a diffuseTexture, so the factor path is exercised through the\n *  texture itself. Add explicit factor handling here only if a regression\n *  appears.\n */\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport type { PbrMaterialProps } from \"../material/pbr/pbr-material.js\";\n\nconst ext: GltfFeature = {\n    id: \"KHR_materials_pbrSpecularGlossiness\",\n    async applyMaterial(mat, ctx) {\n        const sg = mat._rawMatDef?.extensions?.KHR_materials_pbrSpecularGlossiness;\n        if (!sg) {\n            return null;\n        }\n        const [diffuse, specGloss] = await Promise.all([ctx._texture(sg.diffuseTexture, true), ctx._texture(sg.specularGlossinessTexture, true)]);\n        const sf = sg.specularFactor;\n        const out: Partial<PbrMaterialProps> = { metallicFactor: 0, roughnessFactor: 1 - (sg.glossinessFactor ?? 1), reflectance: sf ? Math.max(sf[0], sf[1], sf[2]) : 1 };\n        if (diffuse) {\n            out.baseColorTexture = diffuse;\n        }\n        if (specGloss) {\n            out.specGlossTexture = specGloss;\n        }\n        return out;\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"AAmBA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,cAAc,KAAK,KAAK;AAFlC;AAGQ,UAAM,MAAK,eAAI,eAAJ,mBAAgB,eAAhB,mBAA4B;AACvC,QAAI,CAAC,IAAI;AACL,aAAO;AAAA,IACX;AACA,UAAM,CAAC,SAAS,SAAS,IAAI,MAAM,QAAQ,IAAI,CAAC,IAAI,SAAS,GAAG,gBAAgB,IAAI,GAAG,IAAI,SAAS,GAAG,2BAA2B,IAAI,CAAC,CAAC;AACxI,UAAM,KAAK,GAAG;AACd,UAAM,MAAiC,EAAE,gBAAgB,GAAG,iBAAiB,KAAK,GAAG,oBAAoB,IAAI,aAAa,KAAK,KAAK,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,EAAA;AAC/J,QAAI,SAAS;AACT,UAAI,mBAAmB;AAAA,IAC3B;AACA,QAAI,WAAW;AACX,UAAI,mBAAmB;AAAA,IAC3B;AACA,WAAO;AAAA,EACX;AACJ;"}

package/gltf-ext-unlit-D2ANui0V.js

@@ -0,0 +1,16 @@
+const ext = {
+  id: "KHR_materials_unlit",
+  async applyMaterial(mat) {
+    var _a, _b;
+    if (!((_b = (_a = mat._rawMatDef) == null ? void 0 : _a.extensions) == null ? void 0 : _b.KHR_materials_unlit)) {
+      return null;
+    }
+    const f = mat._baseColorFactor;
+    const tint = mat._baseColorImage ? [f[0], f[1], f[2]] : void 0;
+    return tint ? { unlit: true, unlitColor: tint } : { unlit: true };
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-unlit-D2ANui0V.js.map

package/gltf-ext-unlit-D2ANui0V.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-unlit-D2ANui0V.js","sources":["../src/loader-gltf/gltf-ext-unlit.ts"],"sourcesContent":["/** glTF KHR_materials_unlit extension.\n *  Flags the material as unlit — the runtime PBR shader outputs the base\n *  color directly without any lighting or tonemap. */\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst ext: GltfFeature = {\n    id: \"KHR_materials_unlit\",\n    async applyMaterial(mat) {\n        if (!mat._rawMatDef?.extensions?.KHR_materials_unlit) {\n            return null;\n        }\n        const f = mat._baseColorFactor;\n        // When a real baseColorTexture is present, its GPU sample contributes\n        // the linear texel and `unlitColor` tints by `baseColorFactor`.  When\n        // there is no texture, the 1×1 fallback already bakes the factor into\n        // its byte value, so leave `unlitColor` at its default [1,1,1].\n        const tint: [number, number, number] | undefined = mat._baseColorImage ? [f[0], f[1], f[2]] : undefined;\n        return tint ? { unlit: true, unlitColor: tint } : { unlit: true };\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"AAKA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,cAAc,KAAK;AAF7B;AAGQ,QAAI,GAAC,eAAI,eAAJ,mBAAgB,eAAhB,mBAA4B,sBAAqB;AAClD,aAAO;AAAA,IACX;AACA,UAAM,IAAI,IAAI;AAKd,UAAM,OAA6C,IAAI,kBAAkB,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI;AAC9F,WAAO,OAAO,EAAE,OAAO,MAAM,YAAY,KAAA,IAAS,EAAE,OAAO,KAAA;AAAA,EAC/D;AACJ;"}

package/gltf-ext-uv-transform-CE_-T1Tr.js

@@ -0,0 +1,38 @@
+import { f as cloneTexture2D } from "./index-C8HOR2sB.js";
+const ext = {
+  id: "KHR_texture_transform",
+  wrapTexture(tex, texInfo) {
+    var _a;
+    const info = texInfo;
+    if (!info) {
+      return tex;
+    }
+    const kt = (_a = info.extensions) == null ? void 0 : _a.KHR_texture_transform;
+    const patch = {};
+    if (kt) {
+      if (kt.scale) {
+        patch.uScale = kt.scale[0];
+        patch.vScale = kt.scale[1];
+      }
+      if (kt.offset) {
+        patch.uOffset = kt.offset[0];
+        patch.vOffset = kt.offset[1];
+      }
+      if (kt.rotation) {
+        patch.uAng = kt.rotation;
+      }
+      if (Object.keys(patch).length) {
+        patch._hasTx = true;
+      }
+    }
+    const tc = (kt == null ? void 0 : kt.texCoord) ?? info.texCoord;
+    if (tc === 1) {
+      patch._texCoord = 1;
+    }
+    return Object.keys(patch).length ? cloneTexture2D(tex, patch) : tex;
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-uv-transform-CE_-T1Tr.js.map

package/gltf-ext-uv-transform-CE_-T1Tr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-uv-transform-CE_-T1Tr.js","sources":["../src/loader-gltf/gltf-ext-uv-transform.ts"],"sourcesContent":["/** Per-textureInfo UV customization: KHR_texture_transform and/or texCoord=1.\n *\n *  - Attaches `uScale/vScale/uOffset/vOffset/uAng` + `_hasTx=true` when the\n *    textureInfo carries a KHR_texture_transform.\n *  - Attaches `_texCoord=1` when the textureInfo (or its transform extension)\n *    selects UV set 1. Spec: KHR_texture_transform.texCoord overrides\n *    textureInfo.texCoord.\n *\n *  Downstream the PBR material detects these fields and compiles a shader\n *  with per-texture `txfUV` wrapping and per-texture UV selection. Identity\n *  (no transform, texCoord=0) returns the base texture unchanged so the\n *  cache reuses the same wrapper.\n *\n *  Lazy-loaded: pulled into bundles whose glTF declares KHR_texture_transform\n *  in `extensionsUsed` OR uses `texCoord:1` on any textureInfo. */\nimport type { Texture2D } from \"../texture/texture-2d.js\";\nimport { cloneTexture2D } from \"../texture/texture-2d.js\";\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\ninterface KtInfo {\n    texCoord?: number;\n    extensions?: {\n        KHR_texture_transform?: {\n            scale?: [number, number];\n            offset?: [number, number];\n            rotation?: number;\n            texCoord?: number;\n        };\n    };\n}\n\nconst ext: GltfFeature = {\n    id: \"KHR_texture_transform\",\n    wrapTexture(tex: Texture2D, texInfo: unknown): Texture2D {\n        const info = texInfo as KtInfo | null | undefined;\n        if (!info) {\n            return tex;\n        }\n        const kt = info.extensions?.KHR_texture_transform;\n        const patch: { uScale?: number; vScale?: number; uOffset?: number; vOffset?: number; uAng?: number; _hasTx?: true; _texCoord?: 0 | 1 } = {};\n        if (kt) {\n            if (kt.scale) {\n                patch.uScale = kt.scale[0];\n                patch.vScale = kt.scale[1];\n            }\n            if (kt.offset) {\n                patch.uOffset = kt.offset[0];\n                patch.vOffset = kt.offset[1];\n            }\n            if (kt.rotation) {\n                patch.uAng = kt.rotation;\n            }\n            if (Object.keys(patch).length) {\n                patch._hasTx = true;\n            }\n        }\n        // Spec: KHR_texture_transform.texCoord overrides textureInfo.texCoord.\n        const tc = kt?.texCoord ?? info.texCoord;\n        if (tc === 1) {\n            patch._texCoord = 1;\n        }\n        return Object.keys(patch).length ? cloneTexture2D(tex, patch) : tex;\n    },\n};\nexport default ext;\n"],"names":[],"mappings":";AA+BA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,YAAY,KAAgB,SAA6B;;AACrD,UAAM,OAAO;AACb,QAAI,CAAC,MAAM;AACP,aAAO;AAAA,IACX;AACA,UAAM,MAAK,UAAK,eAAL,mBAAiB;AAC5B,UAAM,QAAmI,CAAA;AACzI,QAAI,IAAI;AACJ,UAAI,GAAG,OAAO;AACV,cAAM,SAAS,GAAG,MAAM,CAAC;AACzB,cAAM,SAAS,GAAG,MAAM,CAAC;AAAA,MAC7B;AACA,UAAI,GAAG,QAAQ;AACX,cAAM,UAAU,GAAG,OAAO,CAAC;AAC3B,cAAM,UAAU,GAAG,OAAO,CAAC;AAAA,MAC/B;AACA,UAAI,GAAG,UAAU;AACb,cAAM,OAAO,GAAG;AAAA,MACpB;AACA,UAAI,OAAO,KAAK,KAAK,EAAE,QAAQ;AAC3B,cAAM,SAAS;AAAA,MACnB;AAAA,IACJ;AAEA,UAAM,MAAK,yBAAI,aAAY,KAAK;AAChC,QAAI,OAAO,GAAG;AACV,YAAM,YAAY;AAAA,IACtB;AACA,WAAO,OAAO,KAAK,KAAK,EAAE,SAAS,eAAe,KAAK,KAAK,IAAI;AAAA,EACpE;AACJ;"}

package/gltf-feature-animation-pointer-BjpwOOqo.js

@@ -0,0 +1,88 @@
+import { h as setSubtreeVisible, aX as PATH_POINTER } from "./index-C8HOR2sB.js";
+import { _installPointerHandlers } from "./gltf-animation-D7uyTyO3.js";
+const _registry = [
+  // /nodes/{n}/extensions/KHR_node_visibility/visible — scalar (0 = hidden).
+  // The setter cascade handles descendants per the KHR_node_visibility spec
+  // and bumps the module-scoped visibility epoch so the engine invalidates
+  // its cached render bundle.
+  [
+    /^\/nodes\/(\d+)\/extensions\/KHR_node_visibility\/visible$/,
+    (m, ctx) => {
+      const n = ctx.nodes[+m[1]];
+      if (!n) {
+        return null;
+      }
+      return {
+        arity: 1,
+        writer: (out, off) => {
+          setSubtreeVisible(n, out[off] !== 0);
+        }
+      };
+    }
+  ]
+];
+const _warned = /* @__PURE__ */ new Set();
+function resolveAnimationPointer(pointer, ctx) {
+  for (const [rx, make] of _registry) {
+    const m = rx.exec(pointer);
+    if (m) {
+      return make(m, ctx);
+    }
+  }
+  if (!_warned.has(pointer)) {
+    _warned.add(pointer);
+    console.warn(`[babylon-lite] KHR_animation_pointer: no handler for "${pointer}"`);
+  }
+  return null;
+}
+_installPointerHandlers(
+  (ptr, c, nodeMap) => {
+    if (!nodeMap) {
+      return null;
+    }
+    const resolved = resolveAnimationPointer(ptr, { nodes: nodeMap });
+    if (!resolved) {
+      return null;
+    }
+    const ch = {
+      samplerIdx: c.sampler,
+      nodeIdx: -1,
+      path: PATH_POINTER,
+      pointerWriter: resolved.writer,
+      pointerArity: resolved.arity
+    };
+    return ch;
+  },
+  (src, length, normalized) => {
+    const out = new Float32Array(length);
+    if (src instanceof Float32Array) {
+      for (let i = 0; i < length; i++) {
+        out[i] = src[i];
+      }
+    } else if (src instanceof Uint8Array) {
+      const k = normalized ? 1 / 255 : 1;
+      for (let i = 0; i < length; i++) {
+        out[i] = src[i] * k;
+      }
+    } else if (src instanceof Uint16Array) {
+      const k = normalized ? 1 / 65535 : 1;
+      for (let i = 0; i < length; i++) {
+        out[i] = src[i] * k;
+      }
+    } else if (src instanceof Int8Array) {
+      for (let i = 0; i < length; i++) {
+        out[i] = normalized ? Math.max(src[i] / 127, -1) : src[i];
+      }
+    } else if (src instanceof Int16Array) {
+      for (let i = 0; i < length; i++) {
+        out[i] = normalized ? Math.max(src[i] / 32767, -1) : src[i];
+      }
+    }
+    return out;
+  }
+);
+const feature = { id: "KHR_animation_pointer" };
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-animation-pointer-BjpwOOqo.js.map

package/gltf-feature-animation-pointer-BjpwOOqo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-animation-pointer-BjpwOOqo.js","sources":["../src/loader-gltf/animation-pointer.ts","../src/loader-gltf/gltf-feature-animation-pointer.ts"],"sourcesContent":["/** KHR_animation_pointer — JSON-pointer resolver registry.\n *  Handlers are registered incrementally (one per parity scene). Unknown\n *  pointers return null and warn once. */\nimport type { SceneNode } from \"../scene/scene-node.js\";\nimport { setSubtreeVisible } from \"../scene/visibility.js\";\n\nexport interface ResolvedPointer {\n    writer: (output: Float32Array, offset: number) => void;\n    arity: number;\n}\n\nexport interface PointerContext {\n    nodes: readonly (SceneNode | undefined)[];\n}\n\ntype PointerFactory = (match: RegExpExecArray, ctx: PointerContext) => ResolvedPointer | null;\n\nconst _registry: [RegExp, PointerFactory][] = [\n    // /nodes/{n}/extensions/KHR_node_visibility/visible — scalar (0 = hidden).\n    // The setter cascade handles descendants per the KHR_node_visibility spec\n    // and bumps the module-scoped visibility epoch so the engine invalidates\n    // its cached render bundle.\n    [\n        /^\\/nodes\\/(\\d+)\\/extensions\\/KHR_node_visibility\\/visible$/,\n        (m, ctx) => {\n            const n = ctx.nodes[+m[1]!];\n            if (!n) {\n                return null;\n            }\n            return {\n                arity: 1,\n                writer: (out, off) => {\n                    setSubtreeVisible(n, out[off]! !== 0);\n                },\n            };\n        },\n    ],\n];\n\nconst _warned = new Set<string>();\n\nexport function resolveAnimationPointer(pointer: string, ctx: PointerContext): ResolvedPointer | null {\n    for (const [rx, make] of _registry) {\n        const m = rx.exec(pointer);\n        if (m) {\n            return make(m, ctx);\n        }\n    }\n    if (!_warned.has(pointer)) {\n        _warned.add(pointer);\n\n        console.warn(`[babylon-lite] KHR_animation_pointer: no handler for \"${pointer}\"`);\n    }\n    return null;\n}\n","/** KHR_animation_pointer glTF feature.\n *\n *  Registered in load-gltf.ts's feature table gated on\n *  `extensionsUsed.includes(\"KHR_animation_pointer\")`, so any scene that\n *  doesn't declare the extension pays zero bytes for pointer resolution, the\n *  non-Float32 sampler converter, or the visibility cascade helper.\n *\n *  On side-effect import this module installs two callbacks into gltf-animation:\n *   1. A pointer-channel parser (resolves the JSON pointer to a writer fn).\n *   2. A sampler converter that handles the non-Float32/misaligned accessor\n *      cases the fast path in gltf-animation can't express (e.g. the 11-byte\n *      UNSIGNED_BYTE visibility accessor in CubeVisibility.glb). */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport type { AnimationChannel } from \"../animation/types.js\";\nimport { PATH_POINTER } from \"../animation/types.js\";\nimport { resolveAnimationPointer } from \"./animation-pointer.js\";\nimport { _installPointerHandlers } from \"./gltf-animation.js\";\n\n_installPointerHandlers(\n    (ptr, c, nodeMap) => {\n        if (!nodeMap) {\n            return null;\n        }\n        const resolved = resolveAnimationPointer(ptr, { nodes: nodeMap });\n        if (!resolved) {\n            return null;\n        }\n        const ch: AnimationChannel = {\n            samplerIdx: c.sampler,\n            nodeIdx: -1,\n            path: PATH_POINTER,\n            pointerWriter: resolved.writer,\n            pointerArity: resolved.arity,\n        };\n        return ch;\n    },\n    (src, length, normalized) => {\n        // Convert any animation-sampler payload to a standalone Float32Array.\n        // Handles the cases the aligned-Float32 fast path can't express.\n        const out = new Float32Array(length);\n        if (src instanceof Float32Array) {\n            for (let i = 0; i < length; i++) {\n                out[i] = src[i]!;\n            }\n        } else if (src instanceof Uint8Array) {\n            const k = normalized ? 1 / 255 : 1;\n            for (let i = 0; i < length; i++) {\n                out[i] = src[i]! * k;\n            }\n        } else if (src instanceof Uint16Array) {\n            const k = normalized ? 1 / 65535 : 1;\n            for (let i = 0; i < length; i++) {\n                out[i] = src[i]! * k;\n            }\n        } else if (src instanceof Int8Array) {\n            for (let i = 0; i < length; i++) {\n                out[i] = normalized ? Math.max(src[i]! / 127, -1) : src[i]!;\n            }\n        } else if (src instanceof Int16Array) {\n            for (let i = 0; i < length; i++) {\n                out[i] = normalized ? Math.max(src[i]! / 32767, -1) : src[i]!;\n            }\n        }\n        return out;\n    }\n);\n\n// No per-asset hook — this feature only installs the seam at import time.\nconst feature: GltfFeature = { id: \"KHR_animation_pointer\" };\nexport default feature;\n"],"names":[],"mappings":";;AAiBA,MAAM,YAAwC;AAAA;AAAA;AAAA;AAAA;AAAA,EAK1C;AAAA,IACI;AAAA,IACA,CAAC,GAAG,QAAQ;AACR,YAAM,IAAI,IAAI,MAAM,CAAC,EAAE,CAAC,CAAE;AAC1B,UAAI,CAAC,GAAG;AACJ,eAAO;AAAA,MACX;AACA,aAAO;AAAA,QACH,OAAO;AAAA,QACP,QAAQ,CAAC,KAAK,QAAQ;AAClB,4BAAkB,GAAG,IAAI,GAAG,MAAO,CAAC;AAAA,QACxC;AAAA,MAAA;AAAA,IAER;AAAA,EAAA;AAER;AAEA,MAAM,8BAAc,IAAA;AAEb,SAAS,wBAAwB,SAAiB,KAA6C;AAClG,aAAW,CAAC,IAAI,IAAI,KAAK,WAAW;AAChC,UAAM,IAAI,GAAG,KAAK,OAAO;AACzB,QAAI,GAAG;AACH,aAAO,KAAK,GAAG,GAAG;AAAA,IACtB;AAAA,EACJ;AACA,MAAI,CAAC,QAAQ,IAAI,OAAO,GAAG;AACvB,YAAQ,IAAI,OAAO;AAEnB,YAAQ,KAAK,yDAAyD,OAAO,GAAG;AAAA,EACpF;AACA,SAAO;AACX;ACnCA;AAAA,EACI,CAAC,KAAK,GAAG,YAAY;AACjB,QAAI,CAAC,SAAS;AACV,aAAO;AAAA,IACX;AACA,UAAM,WAAW,wBAAwB,KAAK,EAAE,OAAO,SAAS;AAChE,QAAI,CAAC,UAAU;AACX,aAAO;AAAA,IACX;AACA,UAAM,KAAuB;AAAA,MACzB,YAAY,EAAE;AAAA,MACd,SAAS;AAAA,MACT,MAAM;AAAA,MACN,eAAe,SAAS;AAAA,MACxB,cAAc,SAAS;AAAA,IAAA;AAE3B,WAAO;AAAA,EACX;AAAA,EACA,CAAC,KAAK,QAAQ,eAAe;AAGzB,UAAM,MAAM,IAAI,aAAa,MAAM;AACnC,QAAI,eAAe,cAAc;AAC7B,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,YAAI,CAAC,IAAI,IAAI,CAAC;AAAA,MAClB;AAAA,IACJ,WAAW,eAAe,YAAY;AAClC,YAAM,IAAI,aAAa,IAAI,MAAM;AACjC,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,YAAI,CAAC,IAAI,IAAI,CAAC,IAAK;AAAA,MACvB;AAAA,IACJ,WAAW,eAAe,aAAa;AACnC,YAAM,IAAI,aAAa,IAAI,QAAQ;AACnC,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,YAAI,CAAC,IAAI,IAAI,CAAC,IAAK;AAAA,MACvB;AAAA,IACJ,WAAW,eAAe,WAAW;AACjC,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,YAAI,CAAC,IAAI,aAAa,KAAK,IAAI,IAAI,CAAC,IAAK,KAAK,EAAE,IAAI,IAAI,CAAC;AAAA,MAC7D;AAAA,IACJ,WAAW,eAAe,YAAY;AAClC,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,YAAI,CAAC,IAAI,aAAa,KAAK,IAAI,IAAI,CAAC,IAAK,OAAO,EAAE,IAAI,IAAI,CAAC;AAAA,MAC/D;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AACJ;AAGA,MAAM,UAAuB,EAAE,IAAI,wBAAA;"}

package/gltf-feature-animations-CCizegp8.js

@@ -0,0 +1,15 @@
+const feature = {
+  id: "_animations",
+  async applyAsset(meshes, _root, ctx) {
+    const [{ parseAnimationData }, { createAnimationGroups }] = await Promise.all([import("./gltf-animation-D7uyTyO3.js"), import("./index-C8HOR2sB.js").then((n) => n.gh)]);
+    const animData = parseAnimationData(ctx._json, ctx._binChunk, meshes, ctx._parentMap, ctx._worldMatrixCache, ctx._nodeMap);
+    if (!animData) {
+      return {};
+    }
+    return { animationGroups: createAnimationGroups(animData) };
+  }
+};
+export {
+  feature as default
+};
+//# sourceMappingURL=gltf-feature-animations-CCizegp8.js.map

package/gltf-feature-animations-CCizegp8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-animations-CCizegp8.js","sources":["../src/loader-gltf/gltf-feature-animations.ts"],"sourcesContent":["/** glTF animation feature.\n *  Triggered when the asset has any animations. Per-asset hook parses clips,\n *  binds them to the uploaded meshes, and returns AnimationGroups. */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst feature: GltfFeature = {\n    id: \"_animations\",\n    async applyAsset(meshes, _root, ctx) {\n        const [{ parseAnimationData }, { createAnimationGroups }] = await Promise.all([import(\"./gltf-animation.js\"), import(\"../animation/animation-group.js\")]);\n        const animData = parseAnimationData(ctx._json, ctx._binChunk, meshes, ctx._parentMap, ctx._worldMatrixCache, ctx._nodeMap);\n        if (!animData) {\n            return {};\n        }\n        return { animationGroups: createAnimationGroups(animData) };\n    },\n};\nexport default feature;\n"],"names":[],"mappings":"AAMA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,WAAW,QAAQ,OAAO,KAAK;AACjC,UAAM,CAAC,EAAE,mBAAA,GAAsB,EAAE,sBAAA,CAAuB,IAAI,MAAM,QAAQ,IAAI,CAAC,OAAO,8BAAqB,GAAG,OAAO,qBAAiC,EAAA,KAAA,OAAA,EAAA,EAAA,CAAC,CAAC;AACxJ,UAAM,WAAW,mBAAmB,IAAI,OAAO,IAAI,WAAW,QAAQ,IAAI,YAAY,IAAI,mBAAmB,IAAI,QAAQ;AACzH,QAAI,CAAC,UAAU;AACX,aAAO,CAAA;AAAA,IACX;AACA,WAAO,EAAE,iBAAiB,sBAAsB,QAAQ,EAAA;AAAA,EAC5D;AACJ;"}