@babylonjs/lite 1.2.0 → 1.3.0

package/{unlit-fragment-BsHrS9XX.js.map → unlit-fragment-DPWDQLxo.js.map}

@@ -1 +1 @@
-{"version":3,"file":"unlit-fragment-BsHrS9XX.js","sources":["../src/material/pbr/fragments/unlit-fragment.ts"],"sourcesContent":["/**\n * Unlit Fragment (KHR_materials_unlit).\n *\n * Replaces the lit-color computation with `baseColor * unlitColor` right\n * before the tonemap/gamma/contrast chain runs.  Depends on the IBL fragment\n * when present so our AI injection runs *after* IBL's, overwriting the IBL\n * color contribution.  The subsequent tonemap/gamma/contrast stages still\n * apply, matching BJS's unlit output under `createDefaultEnvironment`.\n *\n * Zero bytes in bundles for scenes that don't use unlit materials.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR2_HAS_UNLIT } from \"../pbr-flag-bits.js\";\n\nexport function createUnlitFragment(hasIbl: boolean): ShaderFragment {\n    const assign = `color = baseColor * material.unlitColor;`;\n    return {\n        _id: \"unlit\",\n        _dependencies: hasIbl ? [\"ibl\"] : undefined,\n        _uboFields: [\n            { _name: \"unlitColor\", _type: \"vec3<f32>\" },\n            { _name: \"_unlitColorPad\", _type: \"f32\" },\n        ],\n        _fragmentSlots: hasIbl ? { AI: assign } : { NI: assign },\n    };\n}\n\n/** Write the unlit material-UBO slice. */\nexport function writeUnlitUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    if (!material.unlit || !offsets.has(\"unlitColor\")) {\n        return;\n    }\n    const off = offsets.get(\"unlitColor\")! / 4;\n    const tint = material.unlitColor ?? [1, 1, 1];\n    data[off] = tint[0]!;\n    data[off + 1] = tint[1]!;\n    data[off + 2] = tint[2]!;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"unlit\",\n    phase: \"fragment\",\n    detect(mat) {\n        return (mat as PbrMaterialProps).unlit ? { f: 0, f2: PBR2_HAS_UNLIT } : { f: 0, f2: 0 };\n    },\n    frag(ctx) {\n        if (!(ctx._features2 & PBR2_HAS_UNLIT)) {\n            return null;\n        }\n        return createUnlitFragment(ctx._hasIbl);\n    },\n    writeUbo: writeUnlitUBO as PbrExt[\"writeUbo\"],\n};\n"],"names":[],"mappings":";AAiBO,SAAS,oBAAoB,QAAiC;AACjE,QAAM,SAAS;AACf,SAAO;AAAA,IACH,KAAK;AAAA,IACL,eAAe,SAAS,CAAC,KAAK,IAAI;AAAA,IAClC,YAAY;AAAA,MACR,EAAE,OAAO,cAAc,OAAO,YAAA;AAAA,MAC9B,EAAE,OAAO,kBAAkB,OAAO,MAAA;AAAA,IAAM;AAAA,IAE5C,gBAAgB,SAAS,EAAE,IAAI,WAAW,EAAE,IAAI,OAAA;AAAA,EAAO;AAE/D;AAGO,SAAS,cAAc,MAAoB,UAA4B,SAA4C;AACtH,MAAI,CAAC,SAAS,SAAS,CAAC,QAAQ,IAAI,YAAY,GAAG;AAC/C;AAAA,EACJ;AACA,QAAM,MAAM,QAAQ,IAAI,YAAY,IAAK;AACzC,QAAM,OAAO,SAAS,cAAc,CAAC,GAAG,GAAG,CAAC;AAC5C,OAAK,GAAG,IAAI,KAAK,CAAC;AAClB,OAAK,MAAM,CAAC,IAAI,KAAK,CAAC;AACtB,OAAK,MAAM,CAAC,IAAI,KAAK,CAAC;AAC1B;AAEO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,OAAO,KAAK;AACR,WAAQ,IAAyB,QAAQ,EAAE,GAAG,GAAG,IAAI,eAAA,IAAmB,EAAE,GAAG,GAAG,IAAI,EAAA;AAAA,EACxF;AAAA,EACA,KAAK,KAAK;AACN,QAAI,EAAE,IAAI,aAAa,iBAAiB;AACpC,aAAO;AAAA,IACX;AACA,WAAO,oBAAoB,IAAI,OAAO;AAAA,EAC1C;AAAA,EACA,UAAU;AACd;"}
+{"version":3,"file":"unlit-fragment-DPWDQLxo.js","sources":["../src/material/pbr/fragments/unlit-fragment.ts"],"sourcesContent":["/**\n * Unlit Fragment (KHR_materials_unlit).\n *\n * Replaces the lit-color computation with `baseColor * unlitColor` right\n * before the tonemap/gamma/contrast chain runs.  Depends on the IBL fragment\n * when present so our AI injection runs *after* IBL's, overwriting the IBL\n * color contribution.  The subsequent tonemap/gamma/contrast stages still\n * apply, matching BJS's unlit output under `createDefaultEnvironment`.\n *\n * Zero bytes in bundles for scenes that don't use unlit materials.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR2_HAS_UNLIT } from \"../pbr-flag-bits.js\";\n\nexport function createUnlitFragment(hasIbl: boolean): ShaderFragment {\n    const assign = `color = baseColor * material.unlitColor;`;\n    return {\n        _id: \"unlit\",\n        _dependencies: hasIbl ? [\"ibl\"] : undefined,\n        _uboFields: [\n            { _name: \"unlitColor\", _type: \"vec3<f32>\" },\n            { _name: \"_unlitColorPad\", _type: \"f32\" },\n        ],\n        _fragmentSlots: hasIbl ? { AI: assign } : { NI: assign },\n    };\n}\n\n/** Write the unlit material-UBO slice. */\nexport function writeUnlitUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    if (!material.unlit || !offsets.has(\"unlitColor\")) {\n        return;\n    }\n    const off = offsets.get(\"unlitColor\")! / 4;\n    const tint = material.unlitColor ?? [1, 1, 1];\n    data[off] = tint[0]!;\n    data[off + 1] = tint[1]!;\n    data[off + 2] = tint[2]!;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"unlit\",\n    phase: \"fragment\",\n    detect(mat) {\n        return (mat as PbrMaterialProps).unlit ? { f: 0, f2: PBR2_HAS_UNLIT } : { f: 0, f2: 0 };\n    },\n    frag(ctx) {\n        if (!(ctx._features2 & PBR2_HAS_UNLIT)) {\n            return null;\n        }\n        return createUnlitFragment(ctx._hasIbl);\n    },\n    writeUbo: writeUnlitUBO as PbrExt[\"writeUbo\"],\n};\n"],"names":[],"mappings":";AAiBO,SAAS,oBAAoB,QAAiC;AACjE,QAAM,SAAS;AACf,SAAO;AAAA,IACH,KAAK;AAAA,IACL,eAAe,SAAS,CAAC,KAAK,IAAI;AAAA,IAClC,YAAY;AAAA,MACR,EAAE,OAAO,cAAc,OAAO,YAAA;AAAA,MAC9B,EAAE,OAAO,kBAAkB,OAAO,MAAA;AAAA,IAAM;AAAA,IAE5C,gBAAgB,SAAS,EAAE,IAAI,WAAW,EAAE,IAAI,OAAA;AAAA,EAAO;AAE/D;AAGO,SAAS,cAAc,MAAoB,UAA4B,SAA4C;AACtH,MAAI,CAAC,SAAS,SAAS,CAAC,QAAQ,IAAI,YAAY,GAAG;AAC/C;AAAA,EACJ;AACA,QAAM,MAAM,QAAQ,IAAI,YAAY,IAAK;AACzC,QAAM,OAAO,SAAS,cAAc,CAAC,GAAG,GAAG,CAAC;AAC5C,OAAK,GAAG,IAAI,KAAK,CAAC;AAClB,OAAK,MAAM,CAAC,IAAI,KAAK,CAAC;AACtB,OAAK,MAAM,CAAC,IAAI,KAAK,CAAC;AAC1B;AAEO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,OAAO,KAAK;AACR,WAAQ,IAAyB,QAAQ,EAAE,GAAG,GAAG,IAAI,eAAA,IAAmB,EAAE,GAAG,GAAG,IAAI,EAAA;AAAA,EACxF;AAAA,EACA,KAAK,KAAK;AACN,QAAI,EAAE,IAAI,aAAa,iBAAiB;AACpC,aAAO;AAAA,IACX;AACA,WAAO,oBAAoB,IAAI,OAAO;AAAA,EAC1C;AAAA,EACA,UAAU;AACd;"}

package/gltf-animation-BjnXkop6.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-animation-BjnXkop6.js","sources":["../src/loader-gltf/gltf-animation.ts"],"sourcesContent":["/**\n *  Lazy-loaded animation/skin parsing for glTF.\n *  Dynamically imported by load-gltf.ts only when a glTF contains animations or skins.\n *\n *  This module is pointer-feature agnostic: KHR_animation_pointer (and the\n *  non-Float32 sampler conversion that CubeVisibility-style assets need) are\n *  installed via the registration seam below, so scenes that don't declare\n *  the extension pay zero bytes for it.\n */\nimport { F32 } from \"../engine/typed-arrays.js\";\nimport type { Mat4 } from \"../math/types.js\";\nimport type { Mesh } from \"../mesh/mesh.js\";\nimport type { GltfAnimationData, AnimationClip, AnimationSampler, AnimationChannel, NodeRest, SkeletonBinding, MorphBinding, AnimatedNodeTarget } from \"../animation/types.js\";\nimport { INTERP_LINEAR, INTERP_STEP, INTERP_CUBICSPLINE, PATH_TRANSLATION, PATH_ROTATION, PATH_SCALE, PATH_WEIGHTS } from \"../animation/types.js\";\nimport { mat4Identity } from \"../math/mat4-identity.js\";\nimport { mat4Invert } from \"../math/mat4-invert.js\";\nimport { mat4MultiplyInto } from \"../math/mat4-multiply-into.js\";\nimport type { Mat4Storage } from \"../math/types.js\";\nimport { resolveAccessor, computeNodeWorldMatrix, findParent } from \"./gltf-parser.js\";\nimport { getLoaderTmpAnim } from \"./_loader-scratch.js\";\nimport type { SceneNode } from \"../scene/scene-node.js\";\n\n/** Registration seam for KHR_animation_pointer. The pointer feature module\n *  calls `_installPointerHandlers` on side-effect import; if never called,\n *  pointer channels are skipped and non-Float32 samplers fall back to the\n *  aliasing fast path (which throws on misaligned/short accessors). */\nexport type PointerChannelParser = (ptr: string, channel: any, nodeMap: readonly (SceneNode | undefined)[] | undefined) => AnimationChannel | null;\nexport type SamplerConverter = (src: ArrayBufferView, length: number, normalized: boolean) => Float32Array;\nlet _parsePointerChannel: PointerChannelParser | null = null;\nlet _convertSampler: SamplerConverter | null = null;\nexport function _installPointerHandlers(parser: PointerChannelParser, converter: SamplerConverter): void {\n    _parsePointerChannel = parser;\n    _convertSampler = converter;\n}\n\n/** Convert sampler input/output to Float32Array. Default: reinterpret existing\n *  Float32 accessor as Float32Array (legacy behaviour; fast but requires\n *  aligned Float32 data). KHR_animation_pointer installs a converter that\n *  additionally handles non-Float32 / normalized accessors. */\nfunction toSamplerFloat32(src: ArrayBufferView, length: number, normalized: boolean): Float32Array {\n    if (_convertSampler) {\n        return _convertSampler(src, length, normalized);\n    }\n    return new F32(src.buffer, src.byteOffset, length);\n}\n\n/** Parsed skin/skeleton data. */\nexport interface GltfSkinData {\n    /** Node indices of joints in this skin. */\n    jointNodes: number[];\n    /** Inverse bind matrices — one 4×4 per joint (column-major Float32Array). */\n    inverseBindMatrices: Float32Array;\n    /** World matrices of each joint at rest pose. */\n    jointWorldMatrices: Mat4[];\n    /** World matrix of the mesh node that owns this skin. */\n    meshWorldMatrix: Mat4;\n}\n\n// ─── Skin / Skeleton Extraction ─────────────────────────────────────\n\n/** Resolve a skin's inverse-bind matrices, filling with identities when absent. */\nfunction resolveIBMs(json: any, binChunk: DataView, skin: any): Float32Array {\n    const jointCount = skin.joints.length;\n    if (skin.inverseBindMatrices !== undefined) {\n        const ibmData = resolveAccessor(json, binChunk, skin.inverseBindMatrices);\n        return new F32(ibmData._data.buffer, ibmData._data.byteOffset, jointCount * 16);\n    }\n    const out = new F32(jointCount * 16);\n    for (let i = 0; i < jointCount; i++) {\n        const o = i * 16;\n        out[o] = out[o + 5] = out[o + 10] = out[o + 15] = 1;\n    }\n    return out;\n}\n\nexport function extractSkin(\n    json: any,\n    binChunk: DataView,\n    skinIdx: number,\n    meshWorldMatrix: Mat4,\n    parentMap: Map<number, number>,\n    worldMatrixCache: Map<number, Mat4>\n): GltfSkinData {\n    const skin = json.skins[skinIdx];\n    const jointNodes: number[] = skin.joints;\n    const inverseBindMatrices = resolveIBMs(json, binChunk, skin);\n    const jointWorldMatrices: Mat4[] = jointNodes.map((nodeIdx) => computeNodeWorldMatrix(json, nodeIdx, parentMap, worldMatrixCache));\n    return { jointNodes, inverseBindMatrices, jointWorldMatrices, meshWorldMatrix };\n}\n\n/** Compute rest-pose bone texture data. Each bone gets 4 vec4 (one 4×4 matrix).\n *  Formula: boneMatrix[i] = inverse(meshWorld) * jointWorld[i] * IBM[i]\n *  At rest pose this simplifies to identity for each bone. */\nexport function computeBoneTextureData(skin: GltfSkinData): Float32Array {\n    const numBones = skin.jointNodes.length;\n    const data = new F32(numBones * 16);\n    const invMeshWorld = mat4Invert(skin.meshWorldMatrix) ?? mat4Identity();\n    const tmp = getLoaderTmpAnim() as unknown as Mat4Storage;\n    for (let i = 0; i < numBones; i++) {\n        mat4MultiplyInto(tmp, 0, invMeshWorld as unknown as Mat4Storage, 0, skin.jointWorldMatrices[i]! as unknown as Mat4Storage, 0);\n        mat4MultiplyInto(data, i * 16, tmp, 0, skin.inverseBindMatrices, i * 16);\n    }\n    return data;\n}\n\n// ─── Animation Parsing ──────────────────────────────────────────────\n\nconst INTERP_MAP: Record<string, 0 | 1 | 2> = {\n    LINEAR: INTERP_LINEAR,\n    STEP: INTERP_STEP,\n    CUBICSPLINE: INTERP_CUBICSPLINE,\n};\n\nconst PATH_MAP: Record<string, 0 | 1 | 2 | 3> = {\n    translation: PATH_TRANSLATION,\n    rotation: PATH_ROTATION,\n    scale: PATH_SCALE,\n    weights: PATH_WEIGHTS,\n};\n\n/**\n * Parse glTF animation data: clips, node hierarchy, and skeleton bindings.\n * Returns null if no animations, or no drivable state at all (no skeletons,\n * no morphs, no pointer channels).\n *\n * `nodeMap` (optional) maps glTF node index → SceneNode. It's required to\n * resolve KHR_animation_pointer targets that write to node properties.\n */\nexport function parseAnimationData(\n    json: any,\n    binChunk: DataView,\n    meshes: Mesh[],\n    parentMap: Map<number, number>,\n    worldMatrixCache: Map<number, Mat4>,\n    nodeMap?: readonly (SceneNode | undefined)[]\n): GltfAnimationData | null {\n    if (!json.animations || json.animations.length === 0) {\n        return null;\n    }\n\n    let pointerChannelCount = 0;\n\n    // Parse animation clips\n    const clips: AnimationClip[] = [];\n    for (const anim of json.animations) {\n        const samplers: AnimationSampler[] = [];\n        for (const s of anim.samplers) {\n            const inputAcc = resolveAccessor(json, binChunk, s.input);\n            const outputAcc = resolveAccessor(json, binChunk, s.output);\n            const inNorm = json.accessors[s.input]?.normalized === true;\n            const outNorm = json.accessors[s.output]?.normalized === true;\n            samplers.push({\n                input: toSamplerFloat32(inputAcc._data, inputAcc._count, inNorm),\n                output: toSamplerFloat32(outputAcc._data, outputAcc._count * outputAcc._componentCount, outNorm),\n                interpolation: INTERP_MAP[s.interpolation ?? \"LINEAR\"] ?? INTERP_LINEAR,\n            });\n        }\n\n        const channels: AnimationChannel[] = [];\n        for (const c of anim.channels) {\n            // KHR_animation_pointer: delegated to the registered pointer parser\n            // (installed by gltf-feature-animation-pointer on side-effect import).\n            const ptr = c.target?.extensions?.KHR_animation_pointer?.pointer;\n            if (ptr) {\n                if (!_parsePointerChannel) {\n                    continue;\n                }\n                const ch = _parsePointerChannel(ptr, c, nodeMap);\n                if (ch) {\n                    channels.push(ch);\n                    pointerChannelCount++;\n                }\n                continue;\n            }\n            if (c.target.node === undefined) {\n                continue;\n            }\n            const path = PATH_MAP[c.target.path];\n            if (path === undefined) {\n                continue;\n            }\n            channels.push({ samplerIdx: c.sampler, nodeIdx: c.target.node, path });\n        }\n\n        let duration = 0;\n        for (const s of samplers) {\n            if (s.input.length > 0) {\n                const last = s.input[s.input.length - 1]!;\n                if (last > duration) {\n                    duration = last;\n                }\n            }\n        }\n\n        clips.push({ name: anim.name ?? \"\", channels, samplers, duration });\n    }\n\n    // Build node hierarchy (rest-pose TRS + parent indices)\n    const nodeCount = json.nodes?.length ?? 0;\n    const nodes: NodeRest[] = [];\n    for (let i = 0; i < nodeCount; i++) {\n        const n = json.nodes[i];\n        const t = n.translation ?? [0, 0, 0];\n        const r = n.rotation ?? [0, 0, 0, 1];\n        const s = n.scale ?? [1, 1, 1];\n        nodes.push({\n            parentIdx: findParent(parentMap, i),\n            _matrix: n.matrix as Mat4 | undefined,\n            tx: t[0],\n            ty: t[1],\n            tz: t[2],\n            rx: r[0],\n            ry: r[1],\n            rz: r[2],\n            rw: r[3],\n            sx: s[0],\n            sy: s[1],\n            sz: s[2],\n        });\n    }\n\n    // Build skeleton bindings (connect skin data to GPU bone textures)\n    // First, build node→gpuMesh mapping by replaying extraction order\n    const nodeToMeshIndices = new Map<number, number[]>();\n    let gpuIdx = 0;\n    for (let ni = 0; ni < nodeCount; ni++) {\n        const node = json.nodes[ni];\n        if (node.mesh === undefined) {\n            continue;\n        }\n        const mesh = json.meshes[node.mesh];\n        const indices: number[] = [];\n        for (let p = 0; p < mesh.primitives.length; p++) {\n            indices.push(gpuIdx++);\n        }\n        nodeToMeshIndices.set(ni, indices);\n    }\n\n    const skeletons: SkeletonBinding[] = [];\n    for (let nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) {\n        const node = json.nodes[nodeIdx];\n        if (node.skin === undefined || !json.skins) {\n            continue;\n        }\n\n        const meshIndices = nodeToMeshIndices.get(nodeIdx);\n        if (!meshIndices) {\n            continue;\n        }\n\n        const skin = json.skins[node.skin];\n        const jointNodes: number[] = skin.joints;\n        const inverseBindMatrices = resolveIBMs(json, binChunk, skin);\n\n        const meshWorldMatrix = computeNodeWorldMatrix(json, nodeIdx, parentMap, worldMatrixCache);\n        const invMeshWorld = mat4Invert(meshWorldMatrix) ?? mat4Identity();\n\n        // Create a binding for EACH mesh primitive of this skinned node\n        for (const mi of meshIndices) {\n            const mesh = meshes[mi];\n            const skeleton = mesh?.skeleton;\n            if (!skeleton) {\n                continue;\n            }\n            skeletons.push({\n                jointNodes,\n                inverseBindMatrices,\n                invMeshWorld,\n                boneTexture: skeleton.boneTexture,\n                boneCount: jointNodes.length,\n                boneMatrices: skeleton.boneMatrices,\n                runtimeSkeleton: skeleton,\n            });\n        }\n    }\n\n    // Build morph bindings (connect morph-target meshes to GPU weight buffers)\n    const morphBindings: MorphBinding[] = [];\n    for (let nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) {\n        const node = json.nodes[nodeIdx];\n        if (node.mesh === undefined) {\n            continue;\n        }\n        const gltfMesh = json.meshes[node.mesh];\n        if (!gltfMesh.primitives?.[0]?.targets?.length) {\n            continue;\n        }\n\n        const meshIndices = nodeToMeshIndices.get(nodeIdx);\n        if (!meshIndices) {\n            continue;\n        }\n\n        for (const mi of meshIndices) {\n            const mesh = meshes[mi];\n            const morphTargets = mesh?.morphTargets;\n            if (!morphTargets) {\n                continue;\n            }\n            morphBindings.push({\n                nodeIdx,\n                weightsBuffer: morphTargets.weightsBuffer,\n                weights: morphTargets.weights,\n                targetCount: morphTargets.count,\n                runtimeMorphTargets: morphTargets,\n            });\n        }\n    }\n\n    // Build the node-TRS writeback inputs. `nodeTargets` exposes each glTF node's\n    // live scene node (via the structural AnimatedNodeTarget view) so the controller\n    // can push evaluated local TRS back onto the scene graph, moving non-skinned\n    // node-animated meshes and their descendants. `excludedNodeIndices` lists nodes\n    // that MUST NOT be written: skin joints (driven by the skeleton path) plus\n    // skinned-mesh nodes and all their ancestors — their bone matrices bake an\n    // `invMeshWorld` captured at load, so moving them at runtime would\n    // double-transform the skinned vertices.\n    const nodeTargets: readonly (AnimatedNodeTarget | undefined)[] = (nodeMap as readonly (AnimatedNodeTarget | undefined)[] | undefined) ?? [];\n    const excludedNodeIndices = new Set<number>();\n    for (const skin of json.skins ?? []) {\n        for (const ji of skin.joints ?? []) {\n            excludedNodeIndices.add(ji);\n        }\n    }\n    for (let ni = 0; ni < nodeCount; ni++) {\n        if (json.nodes[ni]?.skin === undefined) {\n            continue;\n        }\n        let p = ni;\n        while (p >= 0 && !excludedNodeIndices.has(p)) {\n            excludedNodeIndices.add(p);\n            p = findParent(parentMap, p);\n        }\n    }\n\n    if (\n        clips.length === 0 ||\n        (skeletons.length === 0 && morphBindings.length === 0 && pointerChannelCount === 0 && !hasWritableNodeChannel(clips, nodeTargets, excludedNodeIndices))\n    ) {\n        return null;\n    }\n    return { clips, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices };\n}\n\n/** True if any clip animates a non-excluded node that has a live scene target —\n *  i.e. there is at least one plain node-TRS channel the controller can write\n *  back. Lets purely-skinned/morph/pointer assets short-circuit unchanged. */\nfunction hasWritableNodeChannel(clips: readonly AnimationClip[], nodeTargets: readonly (AnimatedNodeTarget | undefined)[], excludedNodeIndices: ReadonlySet<number>): boolean {\n    for (const clip of clips) {\n        for (const ch of clip.channels) {\n            if (\n                (ch.path === PATH_TRANSLATION || ch.path === PATH_ROTATION || ch.path === PATH_SCALE) &&\n                ch.nodeIdx >= 0 &&\n                !excludedNodeIndices.has(ch.nodeIdx) &&\n                nodeTargets[ch.nodeIdx]\n            ) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\n"],"names":[],"mappings":"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"}

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

@@ -1,88 +0,0 @@
-import { be as setSubtreeVisible, a as F32, e as U8, j as U16, bW as I8, bX as I16, bY as PATH_POINTER } from "./index-BgY3QEzL.js";
-import { _installPointerHandlers } from "./gltf-animation-BjnXkop6.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 F32(length);
-    if (src instanceof F32) {
-      for (let i = 0; i < length; i++) {
-        out[i] = src[i];
-      }
-    } else if (src instanceof U8) {
-      const k = normalized ? 1 / 255 : 1;
-      for (let i = 0; i < length; i++) {
-        out[i] = src[i] * k;
-      }
-    } else if (src instanceof U16) {
-      const k = normalized ? 1 / 65535 : 1;
-      for (let i = 0; i < length; i++) {
-        out[i] = src[i] * k;
-      }
-    } else if (src instanceof I8) {
-      for (let i = 0; i < length; i++) {
-        out[i] = normalized ? Math.max(src[i] / 127, -1) : src[i];
-      }
-    } else if (src instanceof I16) {
-      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-C40tqOhL.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-feature-animation-pointer-C40tqOhL.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 { F32, U16, I16, U8, I8 } from \"../engine/typed-arrays.js\";\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 F32(length);\n        if (src instanceof F32) {\n            for (let i = 0; i < length; i++) {\n                out[i] = src[i]!;\n            }\n        } else if (src instanceof U8) {\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 U16) {\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 I8) {\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 I16) {\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;AClCA;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,IAAI,MAAM;AAC1B,QAAI,eAAe,KAAK;AACpB,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,YAAI,CAAC,IAAI,IAAI,CAAC;AAAA,MAClB;AAAA,IACJ,WAAW,eAAe,IAAI;AAC1B,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,KAAK;AAC3B,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,IAAI;AAC1B,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,KAAK;AAC3B,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-draco-CljWrsna.js

@@ -1,125 +0,0 @@
-import { e as U8, U as U32, bV as I32, a as F32 } from "./index-BgY3QEzL.js";
-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 U32(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 I32(module.HEAP32.buffer, ptr, totalComponents).slice());
-    } else {
-      attributes.set(name, new F32(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 U8(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-CljWrsna.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-feature-draco-CljWrsna.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 { F32, U32, I32, U8 } from \"../engine/typed-arrays.js\";\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 U32(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 I32(module.HEAP32.buffer, ptr, totalComponents).slice());\n        } else {\n            attributes.set(name, new F32(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 U8(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-meshopt-DItMkOMt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-feature-meshopt-DItMkOMt.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 { U8, DV } from \"../engine/typed-arrays.js\";\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 U8(binChunk.buffer, binChunk.byteOffset + (ext.byteOffset ?? 0), ext.byteLength);\n                const target = new U8(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 U8(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 U8(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 DV(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;ACdA,SAAS,OAAO,GAAmB;AAC/B,SAAQ,IAAI,IAAK;AACrB;AAEA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,SAAS,MAAM,UAAU;;AAC3B,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,GAAG,SAAS,QAAQ,SAAS,cAAc,IAAI,cAAc,IAAI,IAAI,UAAU;AAClG,cAAM,SAAS,IAAI,GAAG,IAAI,QAAQ,IAAI,UAAU;AAChD,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,GAAG,SAAS,OAAO,MAAM,SAAS,cAAc,GAAG,cAAc,IAAI,SAAS,cAAc,GAAG,cAAc,KAAK,GAAG,UAAU,CAAC;AAAA,MAChJ;AACA,mBAAa,CAAC,IAAI;AAClB,iBAAW,CAAC,IAAI;AAChB,cAAQ,OAAO,QAAQ,MAAM,MAAM;AAAA,IACvC;AAGA,UAAM,SAAS,IAAI,GAAG,KAAK;AAC3B,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,GAAG,OAAO,MAAM;AAAA,EAC/B;AACJ;"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-feature-skeleton-Deh2UBAn.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-interleave-OBqmlu-h.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-interleave-OBqmlu-h.js","sources":["../src/loader-gltf/gltf-interleave.ts"],"sourcesContent":["/**\n * Interleaved (strided) glTF vertex-buffer support — dynamically imported.\n *\n * The engine renders interleaved attributes genuinely: the raw strided\n * bufferView slice is uploaded ONCE as a shared GPU buffer and bound to each\n * attribute at its byte offset with the pipeline's vertex `arrayStride` set to\n * the bufferView byteStride. The loader never rewrites the asset.\n *\n * This whole module is loaded via `await import()` only when an asset actually\n * contains an interleaved bufferView, so non-interleaved scenes pay ZERO bundle\n * cost. The tight CPU copy of position/normal/uv (for AABB, picking, CSG, …) is\n * de-strided LAZILY — only on first CPU read via `installLazyCpu` — so scenes\n * that only render never materialize it.\n */\n\nimport { F32, U32, U16, U8, DV } from \"../engine/typed-arrays.js\";\nimport { BU } from \"../engine/gpu-flags.js\";\nimport type { Mat4 } from \"../math/types.js\";\nimport type { Aabb } from \"../math/aabb.js\";\nimport { computeAabb } from \"../math/compute-aabb.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { Mesh, MeshGPU } from \"../mesh/mesh.js\";\nimport { initMeshTransform } from \"../mesh/mesh.js\";\nimport type { PbrMaterialProps } from \"../material/pbr/pbr-material.js\";\nimport { createMappedBuffer } from \"../resource/gpu-buffers.js\";\nimport { resolveAccessor, TYPE_SIZES } from \"./gltf-parser.js\";\nimport type { GltfMeshData } from \"./load-gltf.js\";\n\nconst FLOAT = 5126;\nconst UNSIGNED_SHORT = 5123;\nconst UNSIGNED_INT = 5125;\nconst UNSIGNED_BYTE = 5121;\n\nconst COMP_BYTES: Record<number, number> = { [UNSIGNED_BYTE]: 1, [UNSIGNED_SHORT]: 2, [UNSIGNED_INT]: 4, [FLOAT]: 4 };\n\nfunction createSequentialIndices(vertexCount: number): Uint16Array | Uint32Array {\n    const indices = vertexCount > 0xffff ? new U32(vertexCount) : new U16(vertexCount);\n    for (let i = 0; i < vertexCount; i++) {\n        indices[i] = i;\n    }\n    return indices;\n}\n\n/** Interleave descriptor for one attribute sourced from a strided bufferView.\n *  The raw slice is shared across attributes of the same bufferView; the\n *  pipeline uses `_stride` as arrayStride and binds at `_offset`. */\nexport interface AccessorInterleave {\n    /** @internal glTF bufferView index — shared-buffer key (same view → one GPU buffer). */\n    _bufferView: number;\n    /** @internal Interleave byte stride (bufferView.byteStride) → pipeline arrayStride. */\n    _stride: number;\n    /** @internal Attribute byte offset within the bufferView → setVertexBuffer bind offset. */\n    _offset: number;\n    /** @internal glTF component type (FLOAT, UNSIGNED_SHORT, …). */\n    _componentType: number;\n    /** @internal Components per vertex. */\n    _componentCount: number;\n    /** @internal Vertex count. */\n    _count: number;\n    /** @internal Raw bufferView bytes (shared across attributes). Retained after GPU upload\n     *  so the CPU copy can be de-strided lazily on demand. */\n    _slice?: Uint8Array;\n}\n\n/** Per-attribute interleave sources for a primitive (keys mirror MeshVbLayout). */\nexport interface GltfVb {\n    /** @internal */\n    _p?: AccessorInterleave;\n    /** @internal */\n    _n?: AccessorInterleave;\n    /** @internal */\n    _t?: AccessorInterleave;\n    /** @internal */\n    _u?: AccessorInterleave;\n    /** @internal */\n    _u2?: AccessorInterleave;\n    /** @internal */\n    _c?: AccessorInterleave;\n}\n\n/** True if accessor `idx`'s bufferView is interleaved (byteStride present and\n *  larger than the attribute's tightly-packed element size). */\nexport function accessorIsStrided(json: any, idx: number): boolean {\n    const a = json.accessors[idx];\n    const bv = json.bufferViews[a.bufferView];\n    const stride: number | undefined = bv.byteStride;\n    if (stride === undefined) {\n        return false;\n    }\n    const elemBytes = (TYPE_SIZES[a.type] ?? 1) * (COMP_BYTES[a.componentType] ?? 4);\n    return stride !== elemBytes;\n}\n\n/** Resolve a strided accessor into an {@link AccessorInterleave} descriptor. */\nfunction resolveStrided(json: any, binChunk: DataView, accessorIdx: number): AccessorInterleave {\n    const accessor = json.accessors[accessorIdx];\n    const bufferView = json.bufferViews[accessor.bufferView];\n    const ab = binChunk.buffer as ArrayBuffer;\n    return {\n        _bufferView: accessor.bufferView,\n        _stride: bufferView.byteStride,\n        _offset: accessor.byteOffset ?? 0,\n        _componentType: accessor.componentType,\n        _componentCount: TYPE_SIZES[accessor.type] ?? 1,\n        _count: accessor.count,\n        _slice: new U8(ab, binChunk.byteOffset + (bufferView.byteOffset ?? 0), bufferView.byteLength),\n    };\n}\n\n/** De-stride an interleaved attribute into a tight Float32Array, reading raw\n *  component values (no normalization) so the result matches what a tight\n *  accessor view would have produced. */\nfunction destrideToTight(il: AccessorInterleave): Float32Array {\n    const dv = new DV(il._slice!.buffer, il._slice!.byteOffset, il._slice!.byteLength);\n    const cb = COMP_BYTES[il._componentType] ?? 4;\n    const ct = il._componentType;\n    const cc = il._componentCount;\n    const out = new F32(il._count * cc);\n    for (let v = 0; v < il._count; v++) {\n        const rowBase = il._offset + v * il._stride;\n        for (let c = 0; c < cc; c++) {\n            const off = rowBase + c * cb;\n            out[v * cc + c] =\n                ct === FLOAT ? dv.getFloat32(off, true) : ct === UNSIGNED_SHORT ? dv.getUint16(off, true) : ct === UNSIGNED_INT ? dv.getUint32(off, true) : dv.getUint8(off);\n        }\n    }\n    return out;\n}\n\n/** Build a mesh-data partial for a primitive, but ONLY if it actually sources\n *  ≥1 attribute from an interleaved (strided) bufferView. Returns `undefined`\n *  for fully-tight primitives so the caller falls back to its tight path.\n *\n *  Strided POSITION/NORMAL/TEXCOORD_0 attributes keep their raw slice in `_vb`\n *  (for genuine GPU interleaving) and leave the tight CPU field `null` — the\n *  de-strided copy is materialized lazily on first CPU read (see\n *  {@link installLazyCpu}). Strided TANGENT/TEXCOORD_1/COLOR are eagerly\n *  de-strided (they feed device-lost recovery), but no current asset interleaves\n *  them. Tight attributes resolve exactly like the core loader. */\nexport function buildInterleavedPartial(json: any, binChunk: DataView, primitive: any, worldMatrix: Mat4, nodeIdx: number): Omit<GltfMeshData, \"_material\"> | undefined {\n    const attrs = primitive.attributes;\n\n    // Per-primitive gate: bail (→ tight path) unless a vertex attribute is strided.\n    let anyStrided = false;\n    for (const name in attrs) {\n        if (accessorIsStrided(json, attrs[name])) {\n            anyStrided = true;\n            break;\n        }\n    }\n    if (!anyStrided) {\n        return undefined;\n    }\n\n    const vb: GltfVb = {};\n    let vertexCount = 0;\n\n    // Resolve one attribute. Returns the interleave descriptor (when the source is\n    // strided) and/or a tight CPU array. `eager` de-strides strided sources up-front\n    // (TANGENT/UV2/COLOR feed device-lost recovery); lazy ones leave `_tight` null and\n    // are de-strided on demand. The caller assigns `vb.<attr>` with a STATIC property\n    // name (never a computed `vb[key]`) — a computed write would stay an unmangled\n    // literal while every reader uses the mangled static name, corrupting the object\n    // across the dynamic-import chunk boundary.\n    const resolveOne = (name: string, eager: boolean): { _tight: Float32Array | null; _il?: AccessorInterleave; _count: number } => {\n        const idx = attrs[name];\n        if (idx === undefined) {\n            return { _tight: null, _count: 0 };\n        }\n        if (accessorIsStrided(json, idx)) {\n            const il = resolveStrided(json, binChunk, idx);\n            return { _tight: eager ? destrideToTight(il) : null, _il: il, _count: il._count };\n        }\n        const av = resolveAccessor(json, binChunk, idx);\n        return { _tight: av._data as Float32Array, _count: av._count };\n    };\n\n    const pos = resolveOne(\"POSITION\", false);\n    vb._p = pos._il;\n    vertexCount = pos._count;\n    const nrm = resolveOne(\"NORMAL\", false);\n    vb._n = nrm._il;\n    const uv = resolveOne(\"TEXCOORD_0\", false);\n    vb._u = uv._il;\n    const tan = resolveOne(\"TANGENT\", true);\n    vb._t = tan._il;\n    const uv2 = resolveOne(\"TEXCOORD_1\", true);\n    vb._u2 = uv2._il;\n    const col = resolveOne(\"COLOR_0\", true);\n    vb._c = col._il;\n\n    const positions = pos._tight;\n    let normals = nrm._tight;\n    let uvs = uv._tight;\n    const tangents = tan._tight;\n    const uv2s = uv2._tight;\n    const colors = col._tight;\n\n    // Absent (not merely strided) NORMAL/UV need a tight zero-filled buffer so the\n    // GPU has a bindable vertex buffer — matches the core loader's tight path.\n    if (!normals && !vb._n) {\n        normals = new F32(vertexCount * 3);\n    }\n    if (!uvs && !vb._u) {\n        uvs = new F32(vertexCount * 2);\n    }\n\n    const idxData = primitive.indices !== undefined ? resolveAccessor(json, binChunk, primitive.indices) : null;\n    const indices = idxData\n        ? idxData._data instanceof U32\n            ? new U32(idxData._data)\n            : idxData._data instanceof U8\n              ? Uint16Array.from(idxData._data)\n              : new U16(idxData._data.buffer, idxData._data.byteOffset, idxData._count)\n        : createSequentialIndices(vertexCount);\n\n    return {\n        _positions: positions,\n        _normals: normals,\n        _tangents: tangents,\n        _uvs: uvs,\n        _uv2s: uv2s,\n        _colors: colors,\n        _indices: indices,\n        _vertexCount: vertexCount,\n        _indexCount: indices.length,\n        _worldMatrix: worldMatrix,\n        _vb: vb,\n        _nodeIndex: nodeIdx,\n        _primitive: primitive,\n    };\n}\n\n/** Build the GPU geometry for an interleaved mesh: one shared buffer per\n *  bufferView for strided attributes (bound at offset with arrayStride), tight\n *  attributes get their own buffer — byte-identical to non-interleaved meshes.\n *  The raw `_slice` is intentionally retained on `_vb` so the CPU copy can be\n *  de-strided lazily later (see {@link installLazyCpu}). */\nfunction buildInterleavedGpu(engine: EngineContext, m: GltfMeshData): MeshGPU {\n    const vbsrc = m._vb!;\n    const shared = new Map<number, GPUBuffer>();\n    const vbuf = (a: AccessorInterleave | undefined, tight: Float32Array | null): GPUBuffer | null => {\n        if (!a) {\n            return tight ? createMappedBuffer(engine, tight, BU.VERTEX) : null;\n        }\n        let b = shared.get(a._bufferView);\n        if (!b) {\n            shared.set(a._bufferView, (b = createMappedBuffer(engine, a._slice!, BU.VERTEX)));\n        }\n        return b;\n    };\n    return {\n        positionBuffer: vbuf(vbsrc._p, m._positions)!,\n        normalBuffer: vbuf(vbsrc._n, m._normals)!,\n        tangentBuffer: m._tangents ? vbuf(vbsrc._t, m._tangents) : null,\n        uvBuffer: vbuf(vbsrc._u, m._uvs)!,\n        uv2Buffer: m._uv2s ? vbuf(vbsrc._u2, m._uv2s) : null,\n        colorBuffer: m._colors ? vbuf(vbsrc._c, m._colors) : null,\n        indexBuffer: createMappedBuffer(engine, m._indices, BU.INDEX),\n        indexCount: m._indexCount,\n        indexFormat: (m._indices instanceof U32 ? \"uint32\" : \"uint16\") as GPUIndexFormat,\n        _vbLayout: vbsrc,\n        _vbKey: `vb${vbsrc._p?._stride ?? 0}.${vbsrc._n?._stride ?? 0}.${vbsrc._t?._stride ?? 0}.${vbsrc._u?._stride ?? 0}`,\n    };\n}\n\n/** Build a complete engine mesh from interleaved glTF mesh-data. Owns ALL\n *  interleave-specific work (GPU upload, AABB fold, lazy CPU install, device-lost\n *  retention) so the core loader's tight path stays byte-identical to the\n *  non-interleaved engine — keeping interleave bytes out of every glTF scene that\n *  doesn't use it. */\nexport function buildInterleavedMesh(engine: EngineContext, m: GltfMeshData, index: number, material: PbrMaterialProps): Mesh {\n    const gpu = buildInterleavedGpu(engine, m);\n\n    // AABB: fold strided positions straight from the slice; tight positions normally.\n    const [boundMin, boundMax] = m._vb!._p ? computeAabbStrided(m._vb!._p, m._worldMatrix) : computeAabb(m._positions!, m._worldMatrix);\n\n    const mesh = {\n        name: `gltf_mesh_${index}`,\n        material,\n        receiveShadows: false,\n        boundMin,\n        boundMax,\n        skeleton: null,\n        morphTargets: null,\n        _gpu: gpu,\n    } as unknown as Mesh;\n    initMeshTransform(mesh);\n\n    // Lazy CPU geometry: the de-strided tight copy is built only on first read.\n    installLazyCpu(mesh, m);\n    mesh._cpuIndices = m._indices instanceof U32 ? m._indices : new U32(m._indices);\n    engine._dlr?.m(mesh, m._uv2s, m._tangents, m._colors, m._indices, gpu.indexFormat);\n\n    return mesh as Mesh;\n}\n\n/** Fold an AABB directly over an interleaved (strided) FLOAT vec3 position\n *  source — no tight copy is materialized. Mirrors {@link computeAabb}'s\n *  world-transform handling. All current interleaved assets use FLOAT positions. */\nexport function computeAabbStrided(il: AccessorInterleave, world?: Mat4): Aabb {\n    const dv = new DV(il._slice!.buffer, il._slice!.byteOffset, il._slice!.byteLength);\n    let minX = Infinity,\n        minY = Infinity,\n        minZ = Infinity;\n    let maxX = -Infinity,\n        maxY = -Infinity,\n        maxZ = -Infinity;\n    for (let v = 0; v < il._count; v++) {\n        const base = il._offset + v * il._stride;\n        const lx = dv.getFloat32(base, true);\n        const ly = dv.getFloat32(base + 4, true);\n        const lz = dv.getFloat32(base + 8, true);\n        let x = lx,\n            y = ly,\n            z = lz;\n        if (world) {\n            x = world[0]! * lx + world[4]! * ly + world[8]! * lz + world[12]!;\n            y = world[1]! * lx + world[5]! * ly + world[9]! * lz + world[13]!;\n            z = world[2]! * lx + world[6]! * ly + world[10]! * lz + world[14]!;\n        }\n        if (x < minX) {\n            minX = x;\n        }\n        if (x > maxX) {\n            maxX = x;\n        }\n        if (y < minY) {\n            minY = y;\n        }\n        if (y > maxY) {\n            maxY = y;\n        }\n        if (z < minZ) {\n            minZ = z;\n        }\n        if (z > maxZ) {\n            maxZ = z;\n        }\n    }\n    return [\n        [minX, minY, minZ],\n        [maxX, maxY, maxZ],\n    ];\n}\n\n/** Install lazy CPU-geometry accessors on an interleaved mesh. Each of\n *  `_cpuPositions/_cpuNormals/_cpuUvs` that comes from a strided source is\n *  defined as a getter that de-strides a tight copy on first access and caches\n *  it; tight attributes are assigned directly. A mesh that is never picked /\n *  CSG'd / navigated never materializes the de-strided arrays.\n *\n *  The property names are written as STATIC literals (not a computed key) so the\n *  minifier mangles them identically to the static reads in the picking /\n *  device-lost code — a computed `defineProperty(mesh, key)` would leave the name\n *  an unmangled literal and mismatch those reads across the chunk boundary. */\nexport function installLazyCpu(mesh: any, m: GltfMeshData): void {\n    const vb = m._vb!;\n    if (vb._p) {\n        Object.defineProperty(mesh, \"_cpuPositions\", lazyCpuDesc(vb._p));\n    } else if (m._positions) {\n        mesh._cpuPositions = m._positions;\n    }\n    if (vb._n) {\n        Object.defineProperty(mesh, \"_cpuNormals\", lazyCpuDesc(vb._n));\n    } else if (m._normals) {\n        mesh._cpuNormals = m._normals;\n    }\n    if (vb._u) {\n        Object.defineProperty(mesh, \"_cpuUvs\", lazyCpuDesc(vb._u));\n    } else if (m._uvs) {\n        mesh._cpuUvs = m._uvs;\n    }\n}\n\n/** Build a caching lazy-getter descriptor that de-strides `il` on first read. */\nfunction lazyCpuDesc(il: AccessorInterleave): PropertyDescriptor {\n    let cached: Float32Array | undefined;\n    return {\n        configurable: true,\n        enumerable: true,\n        get(): Float32Array {\n            return (cached ??= destrideToTight(il));\n        },\n        set(v: Float32Array): void {\n            cached = v;\n        },\n    };\n}\n"],"names":[],"mappings":"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"}