@babylonjs/lite 0.1.1 → 1.0.0

package/node-renderable-B5G8WcdH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-renderable-B5G8WcdH.js","sources":["../src/material/node/node-renderable.ts"],"sourcesContent":["/** Node Material — MeshGroupBuilder + Renderable implementation.\n *\n *  Parallel to `standard-renderable.ts`. Each NodeMaterial owns one compile\n *  result (pipeline + BGLs); this builder creates per-mesh GPU resources\n *  (mesh UBO, node UBO, bind groups) and returns a Renderable\n *  that emits draws in the main pass.\n */\n\nimport { F32, U32, U8 } from \"../../engine/typed-arrays.js\";\nimport { TU, BU } from \"../../engine/gpu-flags.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { SceneContext } from \"../../scene/scene.js\";\nimport type { Mesh } from \"../../mesh/mesh.js\";\nimport type { MeshGPU } from \"../../mesh/mesh.js\";\nimport type { MeshGroupBuildResult, Renderable } from \"../../render/renderable.js\";\nimport type { Material } from \"../material.js\";\nimport type { NodeMaterial } from \"./node-material.js\";\nimport { writeNodeUBO } from \"./node-material.js\";\nimport { compileNodePipeline } from \"./node-pipeline.js\";\nimport { NODE_ESM_SHADOW_OUTPUT, NODE_NO_COLOR_OUTPUT } from \"./node-flags.js\";\nimport { writeMeshLightSelection } from \"../../render/lights-ubo.js\";\nimport { MAX_LIGHTS } from \"../../light/types.js\";\nimport { packMat4IntoF32 } from \"../../math/pack-mat4-into-f32.js\";\n\n// Per-engine cached no-op morph target: a 1×1 rgba32float texture + a UBO with\n// count=0 + sensible texWidth/rowsPerBand. Meshes without their own morph\n// targets reuse this so materials that contain a MorphTargetsBlock still work\n// (the WGSL loops over `count` and passes through when zero).\nconst emptyMorphByEngine = new WeakMap<EngineContext, { texture: GPUTexture; weightsBuffer: GPUBuffer }>();\nfunction getEmptyMorph(engine: EngineContext): { texture: GPUTexture; weightsBuffer: GPUBuffer } {\n    const cached = emptyMorphByEngine.get(engine);\n    if (cached) {\n        return cached;\n    }\n    const texture = engine._device.createTexture({\n        label: \"node-morph-empty\",\n        size: [1, 1],\n        format: \"rgba32float\",\n        usage: TU.TEXTURE_BINDING | TU.COPY_DST,\n    });\n    engine._device.queue.writeTexture({ texture }, new F32([0, 0, 0, 0]).buffer, { bytesPerRow: 16 }, { width: 1, height: 1 });\n    const ubo = new ArrayBuffer(32);\n    const u32 = new U32(ubo, 16, 4);\n    u32[0] = 0; // count\n    u32[1] = 1; // texWidth\n    u32[2] = 1; // rowsPerBand\n    const weightsBuffer = engine._device.createBuffer({ label: \"node-morph-empty-ubo\", size: 32, usage: BU.UNIFORM | BU.COPY_DST });\n    engine._device.queue.writeBuffer(weightsBuffer, 0, new U8(ubo));\n    const entry = { texture, weightsBuffer };\n    emptyMorphByEngine.set(engine, entry);\n    return entry;\n}\n\ninterface NodePacket {\n    readonly _mesh: Mesh;\n    readonly _meshUBO: GPUBuffer;\n    readonly _meshBG: GPUBindGroup;\n    readonly _meshScratch: Float32Array;\n    _lastWorldVersion: number;\n    _lastReceivesShadow: number;\n    _lastLightsCount: number;\n}\n\ntype NodeRenderPass = GPURenderPassEncoder | GPURenderBundleEncoder;\n\n/** Build NME renderables for a set of meshes that share a NodeMaterial. */\nexport function buildNodeMeshRenderables(scene: SceneContext, meshes: Mesh[], materialOverride?: Material): MeshGroupBuildResult {\n    const engine = scene.surface.engine;\n    const device = engine._device;\n\n    // All meshes in this group use the same NodeMaterial (scene-core batches by ctor).\n    // We deliberately do NOT re-group by material instance: each renderable loops\n    // packets of the same pipeline. For phase 1 every mesh with an NME material\n    // shares that one material instance.\n    const byMaterial = new Map<NodeMaterial, Mesh[]>();\n    for (const m of meshes) {\n        const mat = (materialOverride ?? m.material) as NodeMaterial;\n        let list = byMaterial.get(mat);\n        if (!list) {\n            list = [];\n            byMaterial.set(mat, list);\n        }\n        list.push(m);\n    }\n\n    const renderables: Renderable[] = [];\n\n    for (const [material, matMeshes] of byMaterial) {\n        const featureFlags = material._renderFeatures?.features ?? 0;\n        const noColorOutput = (featureFlags & NODE_NO_COLOR_OUTPUT) !== 0;\n        const esmShadowOutput = (featureFlags & NODE_ESM_SHADOW_OUTPUT) !== 0;\n        const shadowOutput = noColorOutput || esmShadowOutput;\n        const compile = shadowOutput\n            ? compileNodePipeline(material._state, material._vertexBody, material._fragmentBody, {\n                  _engine: engine,\n                  _format: esmShadowOutput ? \"rgba16float\" : engine.format,\n                  _depthStencilFormat: \"depth32float\",\n                  _depthCompare: \"less-equal\",\n                  _msaaSamples: 1,\n                  _backFaceCulling: material._graph.backFaceCulling,\n                  _noColorOutput: noColorOutput,\n                  _esmShadowOutput: esmShadowOutput,\n                  _esmShadowDepthCode: esmShadowOutput ? material._esmShadowDepthCode : undefined,\n                  _alphaMode: esmShadowOutput ? 0 : undefined,\n                  // The shared fragment body still references env IBL/BRDF samplers\n                  // (e.g. nmeBrdfLUT) even in the no-color shadow-depth variant, so we\n                  // must emit the env decls + BGL entries here too; otherwise WGSL fails\n                  // to resolve those identifiers. _envEmitter is undefined for non-env\n                  // materials (state.usesEnv === false), leaving them unaffected.\n                  _envEmitter: material._envHelpers?.emitEnv,\n              })\n            : material._compile;\n        const meshBGL = compile._meshBGL;\n\n        // Node UBO is per-material (same across all meshes using it).\n        let nodeUBO: GPUBuffer | null = null;\n        if (compile._nodeUboBinding !== null && compile._nodeUboSize > 0) {\n            nodeUBO = device.createBuffer({ label: \"node-ubo\", size: compile._nodeUboSize, usage: BU.UNIFORM | BU.COPY_DST });\n            writeNodeUBO(engine, nodeUBO, material);\n            material._nodeUBO = nodeUBO;\n        }\n\n        const _packMeshWorld = engine._makePackMeshWorld?.(scene as SceneContext) ?? packMat4IntoF32;\n        const packets: NodePacket[] = [];\n        for (const _mesh of matMeshes) {\n            // Mesh UBO layout: world (64B) + receivesShadow (vec4, 16B) + lightCount/indices.\n            const meshUboBytes = 96 + 16 * Math.ceil(MAX_LIGHTS / 4);\n            const _meshUBO = device.createBuffer({ label: \"node-mesh-ubo\", size: (meshUboBytes + 15) & ~15, usage: BU.UNIFORM | BU.COPY_DST });\n            const _meshScratch = new F32(((meshUboBytes + 15) & ~15) / 4);\n            _packMeshWorld(_meshScratch, _mesh.worldMatrix, 0, 0);\n            const recv = _mesh.receiveShadows ? 1 : 0;\n            _meshScratch[16] = recv;\n            if (compile._usesMeshAttributeFlags) {\n                writeAttributeFlags(_mesh, _meshScratch);\n            }\n            writeMeshLightSelection(_mesh, scene.lights, _meshScratch.subarray(4));\n            device.queue.writeBuffer(_meshUBO, 0, _meshScratch);\n\n            const entries: GPUBindGroupEntry[] = [{ binding: 0, resource: { buffer: _meshUBO } }];\n            if (nodeUBO) {\n                entries.push({ binding: compile._nodeUboBinding!, resource: { buffer: nodeUBO } });\n            }\n            for (const tb of compile._textureBindings) {\n                const slot = material._textureSlots.get(tb._name);\n                const tex = slot?.current;\n                if (!tex) {\n                    throw new Error(\n                        `NodeMaterial: texture binding \"${tb._name}\" not set. Provide it via options.textures or material.inputs[\"${tb._name}\"].texture before the first render.`\n                    );\n                }\n                entries.push({ binding: tb._texBinding, resource: tex.view });\n                entries.push({ binding: tb._sampBinding, resource: tex.sampler });\n            }\n            if (compile._morphBindings !== null) {\n                const mt = (_mesh as { morphTargets?: { texture: GPUTexture; weightsBuffer: GPUBuffer } | null }).morphTargets ?? getEmptyMorph(engine);\n                entries.push({ binding: compile._morphBindings._textureBinding, resource: mt.texture.createView() });\n                entries.push({ binding: compile._morphBindings._uboBinding, resource: { buffer: mt.weightsBuffer } });\n            }\n            if (compile._envBindings) {\n                material._envHelpers!.pushEnvBindGroupEntries(scene, compile._envBindings, entries);\n            }\n            for (let si = 0; si < compile._shadowBindings.length; si++) {\n                const sb = compile._shadowBindings[si]!;\n                const sg = material._shadowGenerators[si];\n                if (!sg) {\n                    throw new Error(`NodeMaterial: material requires shadow generator #${si} but none was supplied to parseNodeMaterialFromSnippet({ shadowGenerators }).`);\n                }\n                entries.push({ binding: sb._texBinding, resource: sg._depthTexture.createView() });\n                entries.push({ binding: sb._sampBinding, resource: sg._depthSampler });\n                entries.push({ binding: sb._uboBinding, resource: { buffer: sg._shadowUBO } });\n            }\n            if (compile._esmShadowParamsBinding !== null) {\n                entries.push({\n                    binding: compile._esmShadowParamsBinding,\n                    resource: { buffer: material._esmShadowParamsUBO! },\n                });\n            }\n            const _meshBG = device.createBindGroup({ label: \"node-mesh-bg\", layout: meshBGL, entries });\n\n            packets.push({\n                _mesh,\n                _meshUBO,\n                _meshBG,\n                _meshScratch,\n                _lastWorldVersion: _mesh.worldMatrixVersion,\n                _lastReceivesShadow: recv,\n                _lastLightsCount: scene.lights.length,\n            });\n        }\n\n        // Vertex attribute order (matches compile.state — captured on material).\n        const attrNames = material._vertexAttrNames;\n\n        const updatePacketUBO = (pkt: NodePacket): void => {\n            const recv = pkt._mesh.receiveShadows ? 1 : 0;\n            const worldVersion = pkt._mesh.worldMatrixVersion;\n            const worldChanged = worldVersion !== pkt._lastWorldVersion;\n            const recvChanged = recv !== pkt._lastReceivesShadow;\n            const lightsChanged = scene.lights.length !== pkt._lastLightsCount;\n            if (worldChanged || recvChanged || lightsChanged) {\n                _packMeshWorld(pkt._meshScratch, pkt._mesh.worldMatrix, 0, 0);\n                pkt._meshScratch[16] = recv;\n                if (compile._usesMeshAttributeFlags) {\n                    writeAttributeFlags(pkt._mesh, pkt._meshScratch);\n                }\n                writeMeshLightSelection(pkt._mesh, scene.lights, pkt._meshScratch.subarray(4));\n                device.queue.writeBuffer(pkt._meshUBO, 0, pkt._meshScratch as Float32Array<ArrayBuffer>);\n                pkt._lastWorldVersion = worldVersion;\n                pkt._lastReceivesShadow = recv;\n                pkt._lastLightsCount = scene.lights.length;\n            }\n        };\n\n        const updateNodeUBO = (): void => {\n            if (nodeUBO && material._uboDirty) {\n                material._uboDirty = false;\n                writeNodeUBO(engine, nodeUBO, material);\n            }\n        };\n\n        const drawPacket = (pass: NodeRenderPass, pkt: NodePacket): void => {\n            const g = pkt._mesh._gpu;\n            for (let i = 0; i < attrNames.length; i++) {\n                const buf = getAttrBuffer(engine, g, attrNames[i]!);\n                pass.setVertexBuffer(i, buf);\n            }\n            pass.setIndexBuffer(g.indexBuffer, g.indexFormat);\n            pass.setBindGroup(1, pkt._meshBG);\n            pass.drawIndexed(g.indexCount);\n        };\n\n        const isTransparent = !noColorOutput && !esmShadowOutput && material._needsAlphaBlending;\n\n        if (isTransparent) {\n            // Transparent materials: one renderable per mesh so each gets an\n            // independent _worldCenter for back-to-front distance sorting.\n            for (const pkt of packets) {\n                const wm = pkt._mesh.worldMatrix as unknown as ArrayLike<number>;\n                const cx = pkt._mesh.position?.x ?? wm[12]!;\n                const cy = pkt._mesh.position?.y ?? wm[13]!;\n                const cz = pkt._mesh.position?.z ?? wm[14]!;\n                const sortCenter: [number, number, number] = [cx, cy, cz];\n                const _baseUpdate = (): void => {\n                    updatePacketUBO(pkt);\n                    updateNodeUBO();\n                    // Update world center for sorting.\n                    const m = pkt._mesh.worldMatrix as unknown as ArrayLike<number>;\n                    sortCenter[0] = m[12]!;\n                    sortCenter[1] = m[13]!;\n                    sortCenter[2] = m[14]!;\n                };\n                const _invalidate = (): void => {\n                    pkt._lastWorldVersion = -1;\n                };\n                const update = engine._wrapRenderableForFO?.(_baseUpdate, scene as SceneContext, _invalidate) ?? _baseUpdate;\n                const draw = (pass: NodeRenderPass): number => {\n                    drawPacket(pass, pkt);\n                    return 1;\n                };\n                const rTrans: Renderable = {\n                    order: 200,\n                    isTransparent: true,\n                    mesh: pkt._mesh,\n                    _worldCenter: sortCenter,\n                    bind() {\n                        return { renderable: rTrans, pipeline: compile._pipeline, update, draw };\n                    },\n                };\n                renderables.push(rTrans);\n            }\n        } else {\n            // Opaque: batch all meshes into one renderable for state efficiency.\n            const _baseUpdate = (): void => {\n                for (const pkt of packets) {\n                    updatePacketUBO(pkt);\n                }\n                updateNodeUBO();\n            };\n            const _invalidate = (): void => {\n                for (const pkt of packets) {\n                    pkt._lastWorldVersion = -1;\n                }\n            };\n            const update = engine._wrapRenderableForFO?.(_baseUpdate, scene as SceneContext, _invalidate) ?? _baseUpdate;\n            const draw = (pass: NodeRenderPass): number => {\n                let draws = 0;\n                for (const pkt of packets) {\n                    drawPacket(pass, pkt);\n                    draws++;\n                }\n                return draws;\n            };\n            const rOpaque: Renderable = {\n                order: 100,\n                isTransparent: false,\n                bind() {\n                    return { renderable: rOpaque, pipeline: compile._pipeline, update, draw };\n                },\n            };\n            renderables.push(rOpaque);\n        }\n    }\n\n    const rebuildSingle = (s: SceneContext, mesh: Mesh, override?: Material): Renderable => {\n        return buildNodeMeshRenderables(s, [mesh], override).renderables[0]!;\n    };\n\n    return { renderables, rebuildSingle };\n}\n\n// Per-gpu-object cached zero buffers for attributes that a NodeMaterial's\n// vertex layout declares but the mesh itself doesn't provide (e.g. vertex\n// color on meshes that don't use VERTEXCOLOR). We allocate one zero buffer\n// lazily per gpu object, sized to its position vertex count × stride.\nconst zeroAttrCache = new WeakMap<object, Map<string, GPUBuffer>>();\nfunction getZeroAttrBuffer(engine: EngineContext, gpu: MeshGPU, name: string): GPUBuffer {\n    let cache = zeroAttrCache.get(gpu as unknown as object);\n    if (!cache) {\n        cache = new Map();\n        zeroAttrCache.set(gpu as unknown as object, cache);\n    }\n    const existing = cache.get(name);\n    if (existing) {\n        return existing;\n    }\n    // position buffer size in bytes / 12 (vec3) = vertex count.\n    const vertexCount = gpu.positionBuffer.size / 12;\n    const stride = name === \"uv\" || name === \"uv2\" ? 8 : name === \"normal\" ? 12 : name === \"tangent\" || name === \"color\" ? 16 : 16;\n    const buf = engine._device.createBuffer({ label: `node-zero-${name}`, size: vertexCount * stride, usage: BU.VERTEX | BU.COPY_DST });\n    // Initialize with zeros (buffer starts zeroed when not mappedAtCreation).\n    cache.set(name, buf);\n    return buf;\n}\n\nexport function getAttrBuffer(engine: EngineContext, gpu: MeshGPU, name: string): GPUBuffer {\n    switch (name) {\n        case \"position\":\n            return gpu.positionBuffer;\n        case \"normal\":\n            return gpu.normalBuffer;\n        case \"uv\":\n            return gpu.uvBuffer;\n        case \"uv2\":\n            return gpu.uv2Buffer ?? getZeroAttrBuffer(engine, gpu, \"uv2\");\n        case \"tangent\":\n            return gpu.tangentBuffer ?? getZeroAttrBuffer(engine, gpu, \"tangent\");\n        case \"color\":\n            return gpu.colorBuffer ?? getZeroAttrBuffer(engine, gpu, \"color\");\n        default:\n            throw new Error(`NodeMaterial: unsupported attribute \"${name}\"`);\n    }\n}\n\nexport function writeAttributeFlags(mesh: Mesh, scratch: Float32Array): void {\n    const gpu = mesh._gpu;\n    scratch[17] = gpu.hasUv === false ? 0 : 1;\n    scratch[18] = gpu.hasTangent ? 1 : 0;\n    scratch[19] = gpu.hasColor ? 1 : 0;\n}\n"],"names":[],"mappings":"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"}

package/{node-shadow-DKrcqmNg.js → node-shadow-CVIUlNf0.js}

@@ -1,4 +1,4 @@
-import { M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+import { M as MAX_LIGHTS, S as SS } from "./index-CLElg2Bo.js";
 const SHADOW_FACTORS_TYPE = `array<f32, ${MAX_LIGHTS}>`;
 const SHADOW_FACTORS_ONE = `${SHADOW_FACTORS_TYPE}(${new Array(MAX_LIGHTS).fill("1.0").join(", ")})`;
 function emitShadow(shadowLights, startBinding, varyings) {
@@ -64,8 +64,8 @@ function emitShadow(shadowLights, startBinding, varyings) {
         `_sf[${sl.lightIndex}] = computeShadowPCF${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.y, shadowInfo${suf}.shadowsInfo.z);`
       );
       _bglEntries.push(
-        { binding: _texBinding, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth", viewDimension: "2d" } },
-        { binding: _sampBinding, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "comparison" } }
+        { binding: _texBinding, visibility: SS.FRAGMENT, texture: { sampleType: "depth", viewDimension: "2d" } },
+        { binding: _sampBinding, visibility: SS.FRAGMENT, sampler: { type: "comparison" } }
       );
     } else {
       wgslDecls.push(
@@ -89,8 +89,8 @@ fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f
         `_sf[${sl.lightIndex}] = computeShadowESM${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.z, shadowInfo${suf}.shadowsInfo.w);`
       );
       _bglEntries.push(
-        { binding: _texBinding, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "2d" } },
-        { binding: _sampBinding, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } }
+        { binding: _texBinding, visibility: SS.FRAGMENT, texture: { sampleType: "float", viewDimension: "2d" } },
+        { binding: _sampBinding, visibility: SS.FRAGMENT, sampler: { type: "filtering" } }
       );
     }
     vertLines.push(
@@ -99,7 +99,7 @@ fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f
     );
     _bglEntries.push({
       binding: _uboBinding,
-      visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+      visibility: SS.VERTEX | SS.FRAGMENT,
       buffer: { type: "uniform", minBindingSize: 96 }
     });
   }
@@ -119,4 +119,4 @@ fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f
 export {
   emitShadow
 };
-//# sourceMappingURL=node-shadow-DKrcqmNg.js.map
+//# sourceMappingURL=node-shadow-CVIUlNf0.js.map

package/node-shadow-CVIUlNf0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-shadow-CVIUlNf0.js","sources":["../src/material/node/node-shadow.ts"],"sourcesContent":["/** Node Material — shadow emission (dynamically imported).\n *\n *  This module is imported ONLY when `parseNodeMaterialFromSnippet` receives\n *  `shadowGenerators`. Scenes without shadows never bundle it, keeping the\n *  shadow WGSL (PCF/ESM helper fns + binding wiring) off the critical path.\n *\n *  Emits three things per shadow light (texture + sampler + shadowInfo UBO)\n *  plus the vertex-stage varying computations and the fragment-stage\n *  `nme_computeShadowFactors(input)` dispatcher consumed by the LightBlock.\n */\n\nimport { SS } from \"../../engine/gpu-flags.js\";\nimport { MAX_LIGHTS } from \"../../light/types.js\";\nimport type { Varying } from \"../../shader/fragment-types.js\";\n\nconst SHADOW_FACTORS_TYPE = `array<f32, ${MAX_LIGHTS}>`;\nconst SHADOW_FACTORS_ONE = `${SHADOW_FACTORS_TYPE}(${new Array(MAX_LIGHTS).fill(\"1.0\").join(\", \")})`;\n\n/** @internal */\nexport interface ShadowBinding {\n    /** @internal */\n    readonly _lightIndex: number;\n    /** @internal */\n    readonly _texBinding: number;\n    /** @internal */\n    readonly _sampBinding: number;\n    /** @internal */\n    readonly _uboBinding: number;\n    /** @internal */\n    readonly _shadowType: \"esm\" | \"pcf\";\n}\n\nexport interface ShadowEmit {\n    /** @internal One per shadow-casting light (3 binding slots each). */\n    readonly _bindings: readonly ShadowBinding[];\n    /** @internal Module-scope WGSL: struct + binding decls + compute fns. */\n    readonly _wgslDecls: string;\n    /** @internal `nme_computeShadowFactors(input) -> array<f32, MAX_LIGHTS>` called from light blocks. */\n    readonly _fragmentHelper: string;\n    /** @internal Injected into vs_main body: populates vPosFromLight_i + vDepthMetric_i varyings. */\n    readonly _vertexInject: string;\n    /** @internal GPU BGL entries for group 1 (append to meshBglEntries). */\n    readonly _bglEntries: readonly GPUBindGroupLayoutEntry[];\n    /** @internal Total bindings consumed (= shadowLights.length * 3). */\n    readonly _bindingCount: number;\n}\n\n/** Emit shadow WGSL + bindings for a NodeMaterial.\n *  Mutates `varyings` (pushes vPosFromLight_i + vDepthMetric_i per light) so\n *  buildVertexOut picks them up.\n */\nexport function emitShadow(shadowLights: readonly { lightIndex: number; shadowType: \"esm\" | \"pcf\" }[], startBinding: number, varyings: Varying[]): ShadowEmit {\n    const _bindings: ShadowBinding[] = [];\n    const wgslDecls: string[] = [];\n    const _bglEntries: GPUBindGroupLayoutEntry[] = [];\n    for (const sl of shadowLights) {\n        const suf = `_${sl.lightIndex}`;\n        if (!varyings.some((v) => v._name === `vPosFromLight${suf}`)) {\n            varyings.push({ _name: `vPosFromLight${suf}`, _type: \"vec4<f32>\" });\n        }\n        if (!varyings.some((v) => v._name === `vDepthMetric${suf}`)) {\n            varyings.push({ _name: `vDepthMetric${suf}`, _type: \"f32\" });\n        }\n    }\n    const vertLines: string[] = [`let _shadowWp4 = meshU.world * vec4<f32>(in.position, 1.0);`];\n    const dispatchLines: string[] = [`var _sf = ${SHADOW_FACTORS_ONE};`];\n    let nextBinding = startBinding;\n    for (const sl of shadowLights) {\n        const suf = `_${sl.lightIndex}`;\n        const _lightIndex = sl.lightIndex;\n        const _texBinding = nextBinding++;\n        const _sampBinding = nextBinding++;\n        const _uboBinding = nextBinding++;\n        const _shadowType = sl.shadowType;\n        _bindings.push({ _lightIndex, _texBinding, _sampBinding, _uboBinding, _shadowType });\n        wgslDecls.push(\n            `struct shadowInfo${suf}Uniforms { lightMatrix: mat4x4<f32>, depthValues: vec4<f32>, shadowsInfo: vec4<f32> };`,\n            `@group(1) @binding(${_uboBinding}) var<uniform> shadowInfo${suf}: shadowInfo${suf}Uniforms;`\n        );\n        if (sl.shadowType === \"pcf\") {\n            wgslDecls.push(\n                `@group(1) @binding(${_texBinding}) var shadowTex${suf}: texture_depth_2d;`,\n                `@group(1) @binding(${_sampBinding}) var shadowComp${suf}: sampler_comparison;`,\n                `fn computeShadowPCF${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, mapSz: f32, invMapSz: f32) -> f32 {\n    let clipSpace = posFromLight.xyz / posFromLight.w;\n    let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\n    if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\n    let depthRef = clamp(clipSpace.z, 0.0, 1.0);\n    var tc = uv * mapSz + 0.5;\n    let st = fract(tc);\n    let base = (floor(tc) - 0.5) * invMapSz;\n    let uvw0 = 4.0 - 3.0 * st;\n    let uvw1 = vec2<f32>(7.0);\n    let uvw2 = 1.0 + 3.0 * st;\n    let u = vec3<f32>((3.0 - 2.0 * st.x) / uvw0.x - 2.0, (3.0 + st.x) / uvw1.x, st.x / uvw2.x + 2.0) * invMapSz;\n    let v = vec3<f32>((3.0 - 2.0 * st.y) / uvw0.y - 2.0, (3.0 + st.y) / uvw1.y, st.y / uvw2.y + 2.0) * invMapSz;\n    var sh = 0.0;\n    sh += uvw0.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[0]), depthRef);\n    sh += uvw1.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[0]), depthRef);\n    sh += uvw2.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[0]), depthRef);\n    sh += uvw0.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[1]), depthRef);\n    sh += uvw1.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[1]), depthRef);\n    sh += uvw2.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[1]), depthRef);\n    sh += uvw0.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[2]), depthRef);\n    sh += uvw1.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[2]), depthRef);\n    sh += uvw2.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[2]), depthRef);\n    sh /= 144.0;\n    return mix(darkness, 1.0, sh);\n}`\n            );\n            dispatchLines.push(\n                `_sf[${sl.lightIndex}] = computeShadowPCF${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.y, shadowInfo${suf}.shadowsInfo.z);`\n            );\n            _bglEntries.push(\n                { binding: _texBinding, visibility: SS.FRAGMENT, texture: { sampleType: \"depth\", viewDimension: \"2d\" } },\n                { binding: _sampBinding, visibility: SS.FRAGMENT, sampler: { type: \"comparison\" } }\n            );\n        } else {\n            wgslDecls.push(\n                `@group(1) @binding(${_texBinding}) var shadowTex${suf}: texture_2d<f32>;`,\n                `@group(1) @binding(${_sampBinding}) var shadowSamp${suf}: sampler;`,\n                `fn computeFallOff${suf}(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {\n    let mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));\n    return mix(value, 1.0, mask);\n}\nfn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, depthScale: f32, frustumEdgeFalloff: f32) -> f32 {\n    let clipSpace = posFromLight.xyz / posFromLight.w;\n    let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\n    if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\n    let shadowPixelDepth = clamp(depthMetric, 0.0, 1.0);\n    let shadowMapSample = textureSampleLevel(shadowTex${suf}, shadowSamp${suf}, uv, 0.0).x;\n    let esm = 1.0 - clamp(exp(min(87.0, depthScale * shadowPixelDepth)) * shadowMapSample, 0.0, 1.0 - darkness);\n    return computeFallOff${suf}(esm, clipSpace.xy, frustumEdgeFalloff);\n}`\n            );\n            dispatchLines.push(\n                `_sf[${sl.lightIndex}] = computeShadowESM${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.z, shadowInfo${suf}.shadowsInfo.w);`\n            );\n            _bglEntries.push(\n                { binding: _texBinding, visibility: SS.FRAGMENT, texture: { sampleType: \"float\", viewDimension: \"2d\" } },\n                { binding: _sampBinding, visibility: SS.FRAGMENT, sampler: { type: \"filtering\" } }\n            );\n        }\n        vertLines.push(\n            `out.vPosFromLight${suf} = shadowInfo${suf}.lightMatrix * _shadowWp4;`,\n            `out.vDepthMetric${suf} = (out.vPosFromLight${suf}.z + shadowInfo${suf}.depthValues.x) / shadowInfo${suf}.depthValues.y;`\n        );\n        _bglEntries.push({\n            binding: _uboBinding,\n            visibility: SS.VERTEX | SS.FRAGMENT,\n            buffer: { type: \"uniform\", minBindingSize: 96 },\n        });\n    }\n    dispatchLines.push(`for (var _i = 0u; _i < ${MAX_LIGHTS}u; _i++) { _sf[_i] = mix(1.0, _sf[_i], meshU.receivesShadow.x); }`);\n    dispatchLines.push(`return _sf;`);\n    return {\n        _bindings,\n        _wgslDecls: wgslDecls.join(\"\\n\"),\n        _fragmentHelper: `fn nme_computeShadowFactors(input: VertexOut) -> ${SHADOW_FACTORS_TYPE} {\\n    ${dispatchLines.join(\"\\n    \")}\\n}`,\n        _vertexInject: vertLines.join(\"\\n    \"),\n        _bglEntries,\n        _bindingCount: shadowLights.length * 3,\n    };\n}\n"],"names":[],"mappings":"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"}

package/{normal-map-fragment-DpsIXrJf.js → normal-map-fragment-CQSxhjCy.js}

@@ -1,5 +1,5 @@
-import { ac as HAS_BUMP_TEXTURE } from "./index-C8HOR2sB.js";
-import { W as WGSL_PERTURB_NORMAL } from "./wgsl-helpers-DyzNzCeE.js";
+import { ad as HAS_BUMP_TEXTURE } from "./index-CLElg2Bo.js";
+import { W as WGSL_PERTURB_NORMAL } from "./wgsl-helpers-D8sl1VVA.js";
 const STAGE_FRAGMENT = 2;
 function createNormalMapFragment() {
   return {
@@ -35,4 +35,4 @@ export {
   bumpStdExt,
   createNormalMapFragment
 };
-//# sourceMappingURL=normal-map-fragment-DpsIXrJf.js.map
+//# sourceMappingURL=normal-map-fragment-CQSxhjCy.js.map

package/{normal-map-fragment-DpsIXrJf.js.map → normal-map-fragment-CQSxhjCy.js.map}

@@ -1 +1 @@
-{"version":3,"file":"normal-map-fragment-DpsIXrJf.js","sources":["../src/material/standard/fragments/normal-map-fragment.ts"],"sourcesContent":["/**\n * Normal Map Fragment (Cotangent Frame)\n *\n * Shared cotangent-frame bump mapping for Standard materials.\n * Uses screen-space derivatives to construct the TBN frame without\n * requiring explicit tangent vertex attributes.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { StandardMaterialProps } from \"../standard-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { StdExt } from \"../standard-flags.js\";\nimport { HAS_BUMP_TEXTURE } from \"../standard-flags.js\";\nimport { WGSL_PERTURB_NORMAL } from \"../../../shader/wgsl-helpers.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\n/**\n * Create a bump/normal map fragment for Standard material.\n * @param bumpLevel - The bump level (1.0 = default). bumpScale = 1/bumpLevel.\n */\nexport function createNormalMapFragment(): ShaderFragment {\n    return {\n        _id: \"normal-map\",\n\n        _bindings: [\n            { _name: \"bT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"bS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n\n        _helperFunctions: WGSL_PERTURB_NORMAL,\n\n        _fragmentSlots: {\n            AC: `normalW = perturbNormal(input.vn, input.vp, input.vu, mat.bs);`,\n        },\n    };\n}\n\nexport const bumpStdExt: StdExt = {\n    _id: \"normal-map\",\n    _phase: \"mesh\",\n    _feature: HAS_BUMP_TEXTURE,\n    _frag: createNormalMapFragment,\n    _bind(mat: StandardMaterialProps, entries: GPUBindGroupEntry[], b: number): number {\n        const tex = mat.bumpTexture!;\n        entries.push({ binding: b++, resource: tex.texture.createView() });\n        entries.push({ binding: b++, resource: tex.sampler });\n        return b;\n    },\n    _textures(mat: StandardMaterialProps, out: Texture2D[]): void {\n        if (mat.bumpTexture) {\n            out.push(mat.bumpTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";;AAeA,MAAM,iBAAiB;AAMhB,SAAS,0BAA0C;AACtD,SAAO;AAAA,IACH,KAAK;AAAA,IAEL,WAAW;AAAA,MACP,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,aAAa,eAAA;AAAA,MAC1F,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,eAAA;AAAA,IAAe;AAAA,IAGrG,kBAAkB;AAAA,IAElB,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,aAAqB;AAAA,EAC9B,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM,KAA4B,SAA8B,GAAmB;AAC/E,UAAM,MAAM,IAAI;AAChB,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,QAAQ,WAAA,GAAc;AACjE,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,SAAS;AACpD,WAAO;AAAA,EACX;AAAA,EACA,UAAU,KAA4B,KAAwB;AAC1D,QAAI,IAAI,aAAa;AACjB,UAAI,KAAK,IAAI,WAAW;AAAA,IAC5B;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"normal-map-fragment-CQSxhjCy.js","sources":["../src/material/standard/fragments/normal-map-fragment.ts"],"sourcesContent":["/**\n * Normal Map Fragment (Cotangent Frame)\n *\n * Shared cotangent-frame bump mapping for Standard materials.\n * Uses screen-space derivatives to construct the TBN frame without\n * requiring explicit tangent vertex attributes.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { StandardMaterialProps } from \"../standard-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { StdExt } from \"../standard-flags.js\";\nimport { HAS_BUMP_TEXTURE } from \"../standard-flags.js\";\nimport { WGSL_PERTURB_NORMAL } from \"../../../shader/wgsl-helpers.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\n/**\n * Create a bump/normal map fragment for Standard material.\n * @param bumpLevel - The bump level (1.0 = default). bumpScale = 1/bumpLevel.\n */\nexport function createNormalMapFragment(): ShaderFragment {\n    return {\n        _id: \"normal-map\",\n\n        _bindings: [\n            { _name: \"bT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"bS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n\n        _helperFunctions: WGSL_PERTURB_NORMAL,\n\n        _fragmentSlots: {\n            AC: `normalW = perturbNormal(input.vn, input.vp, input.vu, mat.bs);`,\n        },\n    };\n}\n\nexport const bumpStdExt: StdExt = {\n    _id: \"normal-map\",\n    _phase: \"mesh\",\n    _feature: HAS_BUMP_TEXTURE,\n    _frag: createNormalMapFragment,\n    _bind(mat: StandardMaterialProps, entries: GPUBindGroupEntry[], b: number): number {\n        const tex = mat.bumpTexture!;\n        entries.push({ binding: b++, resource: tex.texture.createView() });\n        entries.push({ binding: b++, resource: tex.sampler });\n        return b;\n    },\n    _textures(mat: StandardMaterialProps, out: Texture2D[]): void {\n        if (mat.bumpTexture) {\n            out.push(mat.bumpTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";;AAeA,MAAM,iBAAiB;AAMhB,SAAS,0BAA0C;AACtD,SAAO;AAAA,IACH,KAAK;AAAA,IAEL,WAAW;AAAA,MACP,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,aAAa,eAAA;AAAA,MAC1F,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,eAAA;AAAA,IAAe;AAAA,IAGrG,kBAAkB;AAAA,IAElB,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,aAAqB;AAAA,EAC9B,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM,KAA4B,SAA8B,GAAmB;AAC/E,UAAM,MAAM,IAAI;AAChB,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,QAAQ,WAAA,GAAc;AACjE,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,SAAS;AACpD,WAAO;AAAA,EACX;AAAA,EACA,UAAU,KAA4B,KAAwB;AAC1D,QAAI,IAAI,aAAa;AACjB,UAAI,KAAK,IAAI,WAAW;AAAA,IAC5B;AAAA,EACJ;AACJ;"}

package/pack-mat4-with-offset-BqB8Jqo7.js

@@ -0,0 +1,37 @@
+function packMat4IntoF32WithOffset(view, mat, offsetFloats, srcOffsetFloats, offsetX, offsetY, offsetZ) {
+  const src = mat;
+  const s = srcOffsetFloats;
+  const o = offsetFloats;
+  view[o + 0] = src[s + 0];
+  view[o + 1] = src[s + 1];
+  view[o + 2] = src[s + 2];
+  view[o + 3] = src[s + 3];
+  view[o + 4] = src[s + 4];
+  view[o + 5] = src[s + 5];
+  view[o + 6] = src[s + 6];
+  view[o + 7] = src[s + 7];
+  view[o + 8] = src[s + 8];
+  view[o + 9] = src[s + 9];
+  view[o + 10] = src[s + 10];
+  view[o + 11] = src[s + 11];
+  view[o + 12] = src[s + 12] - offsetX;
+  view[o + 13] = src[s + 13] - offsetY;
+  view[o + 14] = src[s + 14] - offsetZ;
+  view[o + 15] = src[s + 15];
+}
+function makePackMeshWorld(scene) {
+  return (view, mat, offsetFloats, srcOffsetFloats) => {
+    const cam = scene.camera;
+    if (!cam) {
+      packMat4IntoF32WithOffset(view, mat, offsetFloats, srcOffsetFloats, 0, 0, 0);
+      return;
+    }
+    const w = cam.worldMatrix;
+    packMat4IntoF32WithOffset(view, mat, offsetFloats, srcOffsetFloats, w[12], w[13], w[14]);
+  };
+}
+export {
+  makePackMeshWorld,
+  packMat4IntoF32WithOffset
+};
+//# sourceMappingURL=pack-mat4-with-offset-BqB8Jqo7.js.map

package/pack-mat4-with-offset-BqB8Jqo7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-mat4-with-offset-BqB8Jqo7.js","sources":["../src/large-world/pack-mat4-with-offset.ts"],"sourcesContent":["/** LWR-only mesh-world UBO packer.\n *\n *  Bundled ONLY in LWR-on bundles (dynamic-imported by `createEngine` inside\n *  `if (useFloatingOrigin)`). Non-LWR scenes never reference this module —\n *  their mesh-world uploads go through the precision-only\n *  `math/pack-mat4-into-f32.ts` instead.\n *\n *  Offset = active camera's world position, read live from the camera at\n *  each pack. There is no scene-side mirror state. The camera's\n *  `worldMatrixVersion` drives mesh-UBO re-uploads via `wrapRenderableForFO`\n *  in `floating-origin.ts`. */\n\nimport type { Mat4 } from \"../math/types.js\";\nimport type { Mat4Storage } from \"../math/types.js\";\nimport type { SceneContext } from \"../scene/scene-core.js\";\n\n/** @internal Mesh-world packer with floating-origin offset subtraction.\n *  Same 16-element layout as `packMat4IntoF32` but subtracts the offset\n *  from the translation column `[12..14]` in JS-number (F64) precision\n *  BEFORE the implicit F32 store at the typed-array assignment. For an\n *  F64-backed mat the `large - large = small` step is computed at full\n *  F64 precision; a single F32 store rounds the small remainder with\n *  ample headroom. That's the whole precision-recovery trick.\n *\n *  Takes `offsetX/Y/Z` as three scalars rather than a `[number, number, number]`\n *  tuple to avoid any per-pack array allocation. */\nexport function packMat4IntoF32WithOffset(\n    view: Float32Array,\n    mat: Mat4 | Float32Array | Float64Array,\n    offsetFloats: number,\n    srcOffsetFloats: number,\n    offsetX: number,\n    offsetY: number,\n    offsetZ: number\n): void {\n    const src = mat as Mat4 as unknown as Mat4Storage;\n    const s = srcOffsetFloats;\n    const o = offsetFloats;\n    view[o + 0] = src[s + 0]!;\n    view[o + 1] = src[s + 1]!;\n    view[o + 2] = src[s + 2]!;\n    view[o + 3] = src[s + 3]!;\n    view[o + 4] = src[s + 4]!;\n    view[o + 5] = src[s + 5]!;\n    view[o + 6] = src[s + 6]!;\n    view[o + 7] = src[s + 7]!;\n    view[o + 8] = src[s + 8]!;\n    view[o + 9] = src[s + 9]!;\n    view[o + 10] = src[s + 10]!;\n    view[o + 11] = src[s + 11]!;\n    view[o + 12] = src[s + 12]! - offsetX;\n    view[o + 13] = src[s + 13]! - offsetY;\n    view[o + 14] = src[s + 14]! - offsetZ;\n    view[o + 15] = src[s + 15]!;\n}\n\n/** @internal Factory: bind a scene's camera into a closure that packs\n *  mesh-world matrices with the live offset (camera world position)\n *  subtracted. Engine sets `engine._makePackMeshWorld = makePackMeshWorld`\n *  only when `useFloatingOrigin: true`. Renderables call the factory once\n *  at construction to resolve their packer; the per-frame hot path then\n *  derives offset from `scene.camera.worldMatrix` at each pack — zero\n *  allocation, no mirror-state to keep in sync. */\nexport function makePackMeshWorld(scene: SceneContext): (view: Float32Array, mat: Mat4 | Float32Array | Float64Array, offsetFloats: number, srcOffsetFloats: number) => void {\n    return (view: Float32Array, mat: Mat4 | Float32Array | Float64Array, offsetFloats: number, srcOffsetFloats: number): void => {\n        const cam = scene.camera;\n        if (!cam) {\n            packMat4IntoF32WithOffset(view, mat, offsetFloats, srcOffsetFloats, 0, 0, 0);\n            return;\n        }\n        const w = cam.worldMatrix;\n        packMat4IntoF32WithOffset(view, mat, offsetFloats, srcOffsetFloats, w[12]!, w[13]!, w[14]!);\n    };\n}\n"],"names":[],"mappings":"AA0BO,SAAS,0BACZ,MACA,KACA,cACA,iBACA,SACA,SACA,SACI;AACJ,QAAM,MAAM;AACZ,QAAM,IAAI;AACV,QAAM,IAAI;AACV,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;AACvB,OAAK,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE;AACzB,OAAK,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE;AACzB,OAAK,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAK;AAC9B,OAAK,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAK;AAC9B,OAAK,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAK;AAC9B,OAAK,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE;AAC7B;AASO,SAAS,kBAAkB,OAA2I;AACzK,SAAO,CAAC,MAAoB,KAAyC,cAAsB,oBAAkC;AACzH,UAAM,MAAM,MAAM;AAClB,QAAI,CAAC,KAAK;AACN,gCAA0B,MAAM,KAAK,cAAc,iBAAiB,GAAG,GAAG,CAAC;AAC3E;AAAA,IACJ;AACA,UAAM,IAAI,IAAI;AACd,8BAA0B,MAAM,KAAK,cAAc,iBAAiB,EAAE,EAAE,GAAI,EAAE,EAAE,GAAI,EAAE,EAAE,CAAE;AAAA,EAC9F;AACJ;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonjs/lite",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",
@@ -12,15 +12,8 @@
     }
   },
   "sideEffects": false,
-  "dependencies": {
-    "draco3d": "^1.5.7",
-    "manifold-3d": "3.4.0",
-    "@recast-navigation/core": "0.43.0",
-    "@recast-navigation/generators": "0.43.0",
-    "@recast-navigation/wasm": "0.43.0"
-  },
   "babylonLiteRelease": {
-    "azureBuildId": "54367",
-    "sourceVersion": "f7e408a79bc357a33b26776f1509b046d2ed8597"
+    "azureBuildId": "54704",
+    "sourceVersion": "a56d95c4709f0ccdb2aa992304f3343a9e23fde3"
   }
 }

package/{parse-camera-DM3oJJeT.js → parse-camera-pBRT_6i5.js}

@@ -1,4 +1,4 @@
-import { C as createFreeCamera } from "./index-C8HOR2sB.js";
+import { l as createFreeCamera } from "./index-CLElg2Bo.js";
 function parseBabylonCamera(cd) {
   var _a, _b;
   const p = cd.position;
@@ -20,4 +20,4 @@ function parseBabylonCamera(cd) {
 export {
   parseBabylonCamera
 };
-//# sourceMappingURL=parse-camera-DM3oJJeT.js.map
+//# sourceMappingURL=parse-camera-pBRT_6i5.js.map

package/{parse-camera-DM3oJJeT.js.map → parse-camera-pBRT_6i5.js.map}

@@ -1 +1 @@
-{"version":3,"file":"parse-camera-DM3oJJeT.js","sources":["../src/loader-babylon/parse-camera.ts"],"sourcesContent":["/** Parse a FreeCamera from .babylon camera data. Dynamically imported by load-babylon.ts. */\nimport { createFreeCamera } from \"../camera/free-camera.js\";\nimport type { FreeCamera } from \"../camera/free-camera.js\";\n\nexport function parseBabylonCamera(cd: { position: number[]; rotation?: number[]; fov?: number; minZ?: number; maxZ?: number }): FreeCamera {\n    const p = cd.position;\n    const pitch = cd.rotation?.[0] ?? 0;\n    const yaw = cd.rotation?.[1] ?? 0;\n    const cp = Math.cos(pitch);\n    const cam = createFreeCamera({ x: p[0]!, y: p[1]!, z: p[2]! }, { x: p[0]! + cp * Math.sin(yaw), y: p[1]! - Math.sin(pitch), z: p[2]! + cp * Math.cos(yaw) });\n    if (cd.fov != null) {\n        cam.fov = cd.fov;\n    }\n    if (cd.minZ != null) {\n        cam.nearPlane = cd.minZ;\n    }\n    if (cd.maxZ != null) {\n        cam.farPlane = cd.maxZ;\n    }\n    return cam;\n}\n"],"names":[],"mappings":";AAIO,SAAS,mBAAmB,IAAyG;;AACxI,QAAM,IAAI,GAAG;AACb,QAAM,UAAQ,QAAG,aAAH,mBAAc,OAAM;AAClC,QAAM,QAAM,QAAG,aAAH,mBAAc,OAAM;AAChC,QAAM,KAAK,KAAK,IAAI,KAAK;AACzB,QAAM,MAAM,iBAAiB,EAAE,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,EAAA,GAAM,EAAE,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG;AAC3J,MAAI,GAAG,OAAO,MAAM;AAChB,QAAI,MAAM,GAAG;AAAA,EACjB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,YAAY,GAAG;AAAA,EACvB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,WAAW,GAAG;AAAA,EACtB;AACA,SAAO;AACX;"}
+{"version":3,"file":"parse-camera-pBRT_6i5.js","sources":["../src/loader-babylon/parse-camera.ts"],"sourcesContent":["/** Parse a FreeCamera from .babylon camera data. Dynamically imported by load-babylon.ts. */\nimport { createFreeCamera } from \"../camera/free-camera.js\";\nimport type { FreeCamera } from \"../camera/free-camera.js\";\n\nexport function parseBabylonCamera(cd: { position: number[]; rotation?: number[]; fov?: number; minZ?: number; maxZ?: number }): FreeCamera {\n    const p = cd.position;\n    const pitch = cd.rotation?.[0] ?? 0;\n    const yaw = cd.rotation?.[1] ?? 0;\n    const cp = Math.cos(pitch);\n    const cam = createFreeCamera({ x: p[0]!, y: p[1]!, z: p[2]! }, { x: p[0]! + cp * Math.sin(yaw), y: p[1]! - Math.sin(pitch), z: p[2]! + cp * Math.cos(yaw) });\n    if (cd.fov != null) {\n        cam.fov = cd.fov;\n    }\n    if (cd.minZ != null) {\n        cam.nearPlane = cd.minZ;\n    }\n    if (cd.maxZ != null) {\n        cam.farPlane = cd.maxZ;\n    }\n    return cam;\n}\n"],"names":[],"mappings":";AAIO,SAAS,mBAAmB,IAAyG;;AACxI,QAAM,IAAI,GAAG;AACb,QAAM,UAAQ,QAAG,aAAH,mBAAc,OAAM;AAClC,QAAM,QAAM,QAAG,aAAH,mBAAc,OAAM;AAChC,QAAM,KAAK,KAAK,IAAI,KAAK;AACzB,QAAM,MAAM,iBAAiB,EAAE,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,EAAA,GAAM,EAAE,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG;AAC3J,MAAI,GAAG,OAAO,MAAM;AAChB,QAAI,MAAM,GAAG;AAAA,EACjB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,YAAY,GAAG;AAAA,EACvB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,WAAW,GAAG;AAAA,EACtB;AACA,SAAO;AACX;"}

package/pbr-fog-wgsl-BqdCid6r.js

@@ -0,0 +1,8 @@
+import { a as WGSL_FOG } from "./wgsl-helpers-D8sl1VVA.js";
+const PBR_FOG_HELPER = WGSL_FOG;
+const PBR_FOG_BLOCK = `if(scene.vFogInfos.x>0.0){var fogFactor=calcFogFactor((scene.view*vec4<f32>(input.worldPos,1.0)).xyz);fogFactor=pow(fogFactor,2.2);color=mix(pow(scene.vFogColor.rgb,vec3<f32>(2.2)),color,fogFactor);}`;
+export {
+  PBR_FOG_BLOCK,
+  PBR_FOG_HELPER
+};
+//# sourceMappingURL=pbr-fog-wgsl-BqdCid6r.js.map

package/pbr-fog-wgsl-BqdCid6r.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-fog-wgsl-BqdCid6r.js","sources":["../src/material/pbr/pbr-fog-wgsl.ts"],"sourcesContent":["/**\n * PBR fog receiver WGSL — the `calcFogFactor` helper plus the fog blend block.\n *\n * Dynamically imported by `pbr-renderable` ONLY when `scene.fog` is set, then threaded into the\n * PBR template as plain strings (the same pattern the ACES tonemap uses). This keeps every byte of\n * fog WGSL out of the bundles of PBR scenes that don't use fog — a static `import` of the helper\n * into `pbr-template` would defeat tree-shaking and inflate every PBR scene (see GUIDANCE §4c′).\n *\n * Parity notes (matches Babylon.js `pbr.fragment` exactly):\n *  - Fog is mixed into the LINEAR HDR colour BEFORE the tonemap / image-processing chain\n *    (BJS runs `fogFragment` before `pbrBlockImageProcessing`).\n *  - The fog FACTOR is linearised: `fog = toLinearSpace(fog)` = `pow(fog, 2.2)` (default approx sRGB).\n *  - The fog COLOUR is linearised too: BJS binds `vFogColor` with `linearSpace = true` for PBR\n *    (`BindFogParameters`), whereas the Standard material binds it raw. Lite stores one raw\n *    `vFogColor` in the scene UBO (correct for Standard, which has no trailing gamma), so the PBR\n *    path linearises it here with `pow(.., 2.2)`; after Lite's trailing gamma encode the fully\n *    fogged result returns to the authored fog colour (matching the background), exactly like BJS.\n *  - The runtime `vFogInfos.x > 0.0` guard lets `fogMode` toggle none/linear/exp/exp2 at runtime.\n */\n\nimport { WGSL_FOG } from \"../../shader/wgsl-helpers.js\";\n\n/** `calcFogFactor` + `E_FOG` helper WGSL (reads `scene.vFogInfos`). */\nexport const PBR_FOG_HELPER = WGSL_FOG;\n\n/** Fog blend, emitted just before the PBR tonemap block (operates on the linear HDR `color`). */\nexport const PBR_FOG_BLOCK = `if(scene.vFogInfos.x>0.0){var fogFactor=calcFogFactor((scene.view*vec4<f32>(input.worldPos,1.0)).xyz);fogFactor=pow(fogFactor,2.2);color=mix(pow(scene.vFogColor.rgb,vec3<f32>(2.2)),color,fogFactor);}`;\n"],"names":[],"mappings":";AAuBO,MAAM,iBAAiB;AAGvB,MAAM,gBAAgB;"}