@babylonjs/lite 0.2.0 → 1.0.0

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":";AAeA,MAAM,sBAAsB,cAAc,UAAU;AACpD,MAAM,qBAAqB,GAAG,mBAAmB,IAAI,IAAI,MAAM,UAAU,EAAE,KAAK,KAAK,EAAE,KAAK,IAAI,CAAC;AAmC1F,SAAS,WAAW,cAA4E,cAAsB,UAAiC;AAC1J,QAAM,YAA6B,CAAA;AACnC,QAAM,YAAsB,CAAA;AAC5B,QAAM,cAAyC,CAAA;AAC/C,aAAW,MAAM,cAAc;AAC3B,UAAM,MAAM,IAAI,GAAG,UAAU;AAC7B,QAAI,CAAC,SAAS,KAAK,CAAC,MAAM,EAAE,UAAU,gBAAgB,GAAG,EAAE,GAAG;AAC1D,eAAS,KAAK,EAAE,OAAO,gBAAgB,GAAG,IAAI,OAAO,aAAa;AAAA,IACtE;AACA,QAAI,CAAC,SAAS,KAAK,CAAC,MAAM,EAAE,UAAU,eAAe,GAAG,EAAE,GAAG;AACzD,eAAS,KAAK,EAAE,OAAO,eAAe,GAAG,IAAI,OAAO,OAAO;AAAA,IAC/D;AAAA,EACJ;AACA,QAAM,YAAsB,CAAC,6DAA6D;AAC1F,QAAM,gBAA0B,CAAC,aAAa,kBAAkB,GAAG;AACnE,MAAI,cAAc;AAClB,aAAW,MAAM,cAAc;AAC3B,UAAM,MAAM,IAAI,GAAG,UAAU;AAC7B,UAAM,cAAc,GAAG;AACvB,UAAM,cAAc;AACpB,UAAM,eAAe;AACrB,UAAM,cAAc;AACpB,UAAM,cAAc,GAAG;AACvB,cAAU,KAAK,EAAE,aAAa,aAAa,cAAc,aAAa,aAAa;AACnF,cAAU;AAAA,MACN,oBAAoB,GAAG;AAAA,MACvB,sBAAsB,WAAW,4BAA4B,GAAG,eAAe,GAAG;AAAA,IAAA;AAEtF,QAAI,GAAG,eAAe,OAAO;AACzB,gBAAU;AAAA,QACN,sBAAsB,WAAW,kBAAkB,GAAG;AAAA,QACtD,sBAAsB,YAAY,mBAAmB,GAAG;AAAA,QACxD,sBAAsB,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iEAcwB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA,iEACrB,GAAG,eAAe,GAAG;AAAA;AAAA;AAAA;AAAA,MAAA;AAK1E,oBAAc;AAAA,QACV,OAAO,GAAG,UAAU,uBAAuB,GAAG,uBAAuB,GAAG,uBAAuB,GAAG,eAAe,GAAG,6BAA6B,GAAG,6BAA6B,GAAG;AAAA,MAAA;AAExL,kBAAY;AAAA,QACR,EAAE,SAAS,aAAa,YAAY,GAAG,UAAU,SAAS,EAAE,YAAY,SAAS,eAAe,KAAA,EAAK;AAAA,QACrG,EAAE,SAAS,cAAc,YAAY,GAAG,UAAU,SAAS,EAAE,MAAM,aAAA,EAAa;AAAA,MAAE;AAAA,IAE1F,OAAO;AACH,gBAAU;AAAA,QACN,sBAAsB,WAAW,kBAAkB,GAAG;AAAA,QACtD,sBAAsB,YAAY,mBAAmB,GAAG;AAAA,QACxD,oBAAoB,GAAG;AAAA;AAAA;AAAA;AAAA,qBAIlB,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA,wDAKgC,GAAG,eAAe,GAAG;AAAA;AAAA,2BAElD,GAAG;AAAA;AAAA,MAAA;AAGlB,oBAAc;AAAA,QACV,OAAO,GAAG,UAAU,uBAAuB,GAAG,uBAAuB,GAAG,uBAAuB,GAAG,eAAe,GAAG,6BAA6B,GAAG,6BAA6B,GAAG;AAAA,MAAA;AAExL,kBAAY;AAAA,QACR,EAAE,SAAS,aAAa,YAAY,GAAG,UAAU,SAAS,EAAE,YAAY,SAAS,eAAe,KAAA,EAAK;AAAA,QACrG,EAAE,SAAS,cAAc,YAAY,GAAG,UAAU,SAAS,EAAE,MAAM,YAAA,EAAY;AAAA,MAAE;AAAA,IAEzF;AACA,cAAU;AAAA,MACN,oBAAoB,GAAG,gBAAgB,GAAG;AAAA,MAC1C,mBAAmB,GAAG,wBAAwB,GAAG,kBAAkB,GAAG,+BAA+B,GAAG;AAAA,IAAA;AAE5G,gBAAY,KAAK;AAAA,MACb,SAAS;AAAA,MACT,YAAY,GAAG,SAAS,GAAG;AAAA,MAC3B,QAAQ,EAAE,MAAM,WAAW,gBAAgB,GAAA;AAAA,IAAG,CACjD;AAAA,EACL;AACA,gBAAc,KAAK,0BAA0B,UAAU,mEAAmE;AAC1H,gBAAc,KAAK,aAAa;AAChC,SAAO;AAAA,IACH;AAAA,IACA,YAAY,UAAU,KAAK,IAAI;AAAA,IAC/B,iBAAiB,oDAAoD,mBAAmB;AAAA,MAAW,cAAc,KAAK,QAAQ,CAAC;AAAA;AAAA,IAC/H,eAAe,UAAU,KAAK,QAAQ;AAAA,IACtC;AAAA,IACA,eAAe,aAAa,SAAS;AAAA,EAAA;AAE7C;"}

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

@@ -1,4 +1,4 @@
-import { Z as HAS_BUMP_TEXTURE } from "./index-B7Qhw0xL.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() {
@@ -35,4 +35,4 @@ export {
   bumpStdExt,
   createNormalMapFragment
 };
-//# sourceMappingURL=normal-map-fragment-DradEMl-.js.map
+//# sourceMappingURL=normal-map-fragment-CQSxhjCy.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"normal-map-fragment-DradEMl-.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonjs/lite",
-  "version": "0.2.0",
+  "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": "54465",
-    "sourceVersion": "605adb9a7dc4eba301d7d998e10c1c76c0d996ea"
+    "azureBuildId": "54704",
+    "sourceVersion": "a56d95c4709f0ccdb2aa992304f3343a9e23fde3"
   }
 }

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

@@ -1,4 +1,4 @@
-import { g as createFreeCamera } from "./index-B7Qhw0xL.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-CgV4bWc0.js.map
+//# sourceMappingURL=parse-camera-pBRT_6i5.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-camera-CgV4bWc0.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-geometry-view-NiZY_juX.js

@@ -0,0 +1,491 @@
+import { c1 as _registerPbrExt, c2 as PBR2_GEOMETRY_OUTPUT, G as GeometryTextureType, V as PBR_HAS_ALPHA_BLEND, c3 as PBR_HAS_ENV, c4 as _computePbrMaterialFeatures, b as writeMeshLightSelection, at as _computeMeshFeatures, a as F32, p as packMat4IntoF32, av as createUniformBuffer, c5 as collectPbrBoundTextures, ax as acquireTexture, ay as releaseTexture, z as getSceneBindGroupLayout, x as targetSignatureKey, bI as REVERSE_DEPTH_COMPARE, c6 as PBR_HAS_NORMAL_MAP, c7 as MSH_HAS_TANGENTS, aM as PBR2_HAS_UV2, c8 as MSH_HAS_UV2, c9 as MSH_HAS_VERTEX_COLOR, aD as MSH_HAS_THIN_INSTANCES, aB as MSH_HAS_INSTANCE_COLOR, ca as PBR_HAS_DOUBLE_SIDED, O as createMaterialView } from "./index-CLElg2Bo.js";
+import { c as createPbrMeshBindGroup, _ as _writeMaterialData } from "./pbr-renderable-DzUF2QIk.js";
+const STAGE_FRAGMENT = 2;
+const STAGE_VERTEX = 1;
+function needsGpUbo(attachments) {
+  for (const t of attachments) {
+    if (t === GeometryTextureType.NORMALIZED_VIEW_DEPTH || t === GeometryTextureType.LINEAR_VELOCITY) {
+      return true;
+    }
+  }
+  return false;
+}
+function needsVelocity(attachments) {
+  return attachments.includes(GeometryTextureType.LINEAR_VELOCITY);
+}
+function needsLocalPos(attachments) {
+  return attachments.includes(GeometryTextureType.LOCAL_POSITION);
+}
+function createPbrGeometryParamsFragment(needsParamsUbo, needsVelocityVaryings, needsLocalPosVarying) {
+  const bindings = needsParamsUbo ? [{ _name: "gp", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_FRAGMENT | STAGE_VERTEX }] : [];
+  const helpers = needsParamsUbo ? `struct gpUniforms { previousViewProjection: mat4x4<f32>, cameraNearFar: vec4<f32>, };` : "";
+  const varyings = [];
+  if (needsVelocityVaryings) {
+    varyings.push({ _name: "vCurrentClip", _type: "vec4<f32>" }, { _name: "vPreviousClip", _type: "vec4<f32>" });
+  }
+  if (needsLocalPosVarying) {
+    varyings.push({ _name: "vLocalPos", _type: "vec3<f32>" });
+  }
+  const vbParts = [];
+  if (needsVelocityVaryings) {
+    vbParts.push(`out.vCurrentClip = scene.viewProjection * vec4<f32>(out.worldPos, 1.0);`);
+    vbParts.push(`out.vPreviousClip = gp.previousViewProjection * vec4<f32>(out.worldPos, 1.0);`);
+  }
+  if (needsLocalPosVarying) {
+    vbParts.push(`out.vLocalPos = position;`);
+  }
+  const slots = vbParts.length > 0 ? { VB: vbParts.join("\n") } : {};
+  return {
+    _id: "pbr-geometry-params",
+    _bindings: bindings,
+    _helperFunctions: helpers,
+    _vertexHelperFunctions: helpers,
+    _varyings: varyings,
+    _vertexSlots: slots
+  };
+}
+let _pbrGeomExtRegistered = false;
+function _ensurePbrGeometryExt(getAttachments) {
+  if (_pbrGeomExtRegistered) {
+    return;
+  }
+  _pbrGeomExtRegistered = true;
+  const ext = {
+    id: "pbr-geometry-params",
+    // Fragment-phase so bind entry is appended after all other PBR exts.
+    phase: "fragment",
+    frag(ctx) {
+      if ((ctx._features2 & PBR2_GEOMETRY_OUTPUT) === 0) {
+        return null;
+      }
+      const att = getAttachments() ?? [];
+      const wantsGp = needsGpUbo(att);
+      const wantsVelocity = needsVelocity(att);
+      const wantsLocalPos = needsLocalPos(att);
+      if (!wantsGp && !wantsVelocity && !wantsLocalPos) {
+        return null;
+      }
+      return createPbrGeometryParamsFragment(wantsGp, wantsVelocity, wantsLocalPos);
+    },
+    bind(ctx, entries, b) {
+      if ((ctx._features2 & PBR2_GEOMETRY_OUTPUT) === 0) {
+        return b;
+      }
+      const view = ctx._material;
+      if (view._gpUBO) {
+        entries.push({ binding: b++, resource: { buffer: view._gpUBO } });
+      }
+      return b;
+    }
+  };
+  _registerPbrExt(ext);
+}
+function attachmentExpr(type, wg, hasIbl) {
+  switch (type) {
+    case GeometryTextureType.IRRADIANCE:
+      return hasIbl ? `vec4<f32>(directDiffuse + finalIrradiance, ${wg})` : `vec4<f32>(directDiffuse, ${wg})`;
+    case GeometryTextureType.WORLD_POSITION:
+      return `vec4<f32>(input.worldPos, ${wg})`;
+    case GeometryTextureType.LOCAL_POSITION:
+      return `vec4<f32>(input.vLocalPos, ${wg})`;
+    case GeometryTextureType.REFLECTIVITY:
+      return `vec4<f32>(colorF0, 1.0 - roughness) * ${wg}`;
+    case GeometryTextureType.VIEW_DEPTH:
+      return `vec4<f32>((scene.view * vec4<f32>(input.worldPos, 1.0)).z, 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.NORMALIZED_VIEW_DEPTH:
+      return `vec4<f32>(((scene.view * vec4<f32>(input.worldPos, 1.0)).z - gp.cameraNearFar.x) / (gp.cameraNearFar.y - gp.cameraNearFar.x), 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.SCREENSPACE_DEPTH:
+      return `vec4<f32>(input.clipPos.z, 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.VIEW_NORMAL:
+      return `vec4<f32>(normalize((scene.view * vec4<f32>(N, 0.0)).xyz), ${wg})`;
+    case GeometryTextureType.WORLD_NORMAL:
+      return `vec4<f32>(N * 0.5 + vec3<f32>(0.5), ${wg})`;
+    case GeometryTextureType.ALBEDO:
+      return `vec4<f32>(surfaceAlbedo, ${wg})`;
+    case GeometryTextureType.LINEAR_VELOCITY: {
+      const cur = `(input.vCurrentClip.xy / input.vCurrentClip.w)`;
+      const prev = `(input.vPreviousClip.xy / input.vPreviousClip.w)`;
+      return `vec4<f32>(0.5 * (${prev} - ${cur}), 0.0, ${wg})`;
+    }
+  }
+}
+function composePbrGeometryShader(composePbr, features, features2, meshFeatures, sceneFeatures, lightMode, singleLightType, esmShadowDepthCode, vbStrides, vbKey, attachments, emitColor) {
+  const geomFeatures = features & ~PBR_HAS_ALPHA_BLEND;
+  const geomFeatures2 = features2 | PBR2_GEOMETRY_OUTPUT;
+  const base = composePbr(
+    geomFeatures,
+    geomFeatures2,
+    meshFeatures,
+    sceneFeatures,
+    lightMode,
+    singleLightType,
+    esmShadowDepthCode,
+    vbStrides,
+    `${vbKey}:geom:${attachments.join(",")}:${emitColor ? "c" : ""}`
+  );
+  const hasIbl = (sceneFeatures & PBR_HAS_ENV) !== 0;
+  const fragmentSignatureFrom = "-> @location(0) vec4<f32>";
+  const fragmentSignatureTo = "-> FragmentOutput";
+  if (!base._fragmentWGSL.includes(fragmentSignatureFrom)) {
+    throw new Error("composePbrGeometryShader: PBR fragment signature mismatch — _noColorOutput/_esmShadowOutput should be off");
+  }
+  let frag = base._fragmentWGSL.replace(fragmentSignatureFrom, fragmentSignatureTo);
+  const colorSlot = attachments.length;
+  const extraColorLine = emitColor ? `
+@location(${colorSlot}) color: vec4<f32>,` : "";
+  const outputStruct = `struct FragmentOutput {
+${attachments.map((_, i) => `@location(${i}) f${i}: vec4<f32>,`).join("\n")}${extraColorLine}
+};
+`;
+  frag = frag.replace("@fragment fn main", `${outputStruct}@fragment fn main`);
+  const wg = `select(0.0, 1.0, alpha > 0.4)`;
+  const writes = attachments.map((type, i) => `out.f${i} = ${attachmentExpr(type, wg, hasIbl)};`).join("\n");
+  const extraColorWrite = emitColor ? `
+out.color = vec4<f32>(color, alpha * material.materialAlpha);` : "";
+  const replacement = `var out: FragmentOutput;
+${writes}${extraColorWrite}
+return out;`;
+  const returnPattern = "return vec4<f32>(color,alpha*material.materialAlpha);";
+  if (!frag.includes(returnPattern)) {
+    throw new Error("composePbrGeometryShader: alpha-block return statement not found — template changed?");
+  }
+  frag = frag.replace(returnPattern, replacement);
+  return { ...base, _fragmentWGSL: frag };
+}
+const pbrGeometryGroupBuilder = (async () => {
+  throw new Error("pbr-geometry view does not support scene group building");
+});
+pbrGeometryGroupBuilder._rebuildSingle = (scene, mesh, materialOverride) => {
+  const view = materialOverride ?? mesh.material;
+  return buildPbrGeometryRenderable(scene, mesh, view);
+};
+pbrGeometryGroupBuilder._materialFamily = "pbr";
+function _variantKey(meshFeatures, lightMode, singleLightType) {
+  return `${meshFeatures}:${lightMode}:${singleLightType}`;
+}
+function buildPbrGeometryRenderable(scene, mesh, view) {
+  var _a, _b;
+  const engine = scene.surface.engine;
+  const device = engine._device;
+  const ctx = scene._pbrGeomContext;
+  if (!ctx) {
+    throw new Error("buildPbrGeometryRenderable: scene has no PBR context. Ensure regular PBR meshes have been built before recording the geometry task.");
+  }
+  const source = view.source;
+  if (!source._renderFeatures) {
+    source._renderFeatures = _computePbrMaterialFeatures(source);
+  }
+  const lr = writeMeshLightSelection(mesh, scene.lights);
+  const lightCount = lr > 0 ? 1 : -lr;
+  const hasSomeShadows = ctx._shadowLights.length > 0;
+  const receiveShadows = mesh.receiveShadows && hasSomeShadows;
+  const lightMode = lightCount === 0 ? 0 : lightCount === 1 && !receiveShadows ? 1 : 2;
+  const singleLightType = lightMode === 1 ? _getPackedSingleLightType(scene.lights, lr - 1) : "";
+  const meshFeatures = _computeMeshFeatures(mesh, receiveShadows);
+  const variantKey = _variantKey(meshFeatures, lightMode, singleLightType);
+  const res = _ensureViewResources(view, engine, ctx, meshFeatures, lightMode, singleLightType, variantKey);
+  const features = res._features;
+  const features2 = res._features2;
+  const composed = res._composed;
+  const meshUboData = new F32(composed._meshUboSpec._totalBytes / 4);
+  const _packMeshWorld = ((_a = engine._makePackMeshWorld) == null ? void 0 : _a.call(engine, scene)) ?? packMat4IntoF32;
+  _packMeshWorld(meshUboData, mesh.worldMatrix, 0, 0);
+  writeMeshLightSelection(mesh, scene.lights, meshUboData);
+  const meshUBO = createUniformBuffer(engine, meshUboData);
+  const materialSpec = composed._materialUboSpec;
+  const matInitData = new F32(materialSpec._totalBytes / 4);
+  _writePbrMaterialData(matInitData, source, materialSpec);
+  const materialUBO = createUniformBuffer(engine, matInitData);
+  const prev = _setActivePbrGeometryAttachments(view._geometryAttachments);
+  let materialBindGroupStatic;
+  try {
+    materialBindGroupStatic = createPbrMeshBindGroup(engine, _wrapBindings(res), composed, meshUBO, materialUBO, view, ctx._envTextures, mesh);
+  } finally {
+    _setActivePbrGeometryAttachments(prev);
+  }
+  let shadowBindGroup = null;
+  if (receiveShadows && res._shadowBGL) {
+    const entries = [];
+    let b = 0;
+    for (const sl of ctx._shadowLights) {
+      const sg = sl.gen;
+      entries.push({ binding: b++, resource: sg._depthTexture.createView() });
+      entries.push({ binding: b++, resource: sg._depthSampler });
+      entries.push({ binding: b++, resource: { buffer: sg._shadowUBO } });
+    }
+    shadowBindGroup = device.createBindGroup({ layout: res._shadowBGL, entries });
+  }
+  const boundTextures = collectPbrBoundTextures(source);
+  for (const t of boundTextures) {
+    acquireTexture(t);
+  }
+  const prevDisposables = scene._meshDisposables.get(mesh) ?? [];
+  scene._meshDisposables.set(mesh, [
+    ...prevDisposables,
+    () => {
+      meshUBO.destroy();
+      materialUBO.destroy();
+    },
+    () => {
+      for (const t of boundTextures) {
+        releaseTexture(t);
+      }
+    }
+  ]);
+  const hasNormalMap = (features & PBR_HAS_NORMAL_MAP) !== 0 && (meshFeatures & MSH_HAS_TANGENTS) !== 0;
+  const hasUV2 = (features2 & PBR2_HAS_UV2) !== 0 && (meshFeatures & MSH_HAS_UV2) !== 0;
+  const hasVertexColor = (meshFeatures & MSH_HAS_VERTEX_COLOR) !== 0;
+  const hasTI = (meshFeatures & MSH_HAS_THIN_INSTANCES) !== 0;
+  const hasTIColor = (meshFeatures & MSH_HAS_INSTANCE_COLOR) !== 0;
+  const syncThinInstanceBuffers = ctx._syncThinInstanceBuffers;
+  const isAlphaBlend = res._alphaBlend;
+  const sortCenter = [mesh.worldMatrix[12], mesh.worldMatrix[13], mesh.worldMatrix[14]];
+  let _lastWorldVersion = mesh.worldMatrixVersion;
+  let _lastLightsCount = scene.lights.length;
+  let _lastUboVersion = source._uboVersion;
+  const matScratch = new F32(materialSpec._totalBytes / 4);
+  const _baseUpdate = () => {
+    if (mesh.worldMatrixVersion !== _lastWorldVersion || scene.lights.length !== _lastLightsCount) {
+      sortCenter[0] = mesh.worldMatrix[12];
+      sortCenter[1] = mesh.worldMatrix[13];
+      sortCenter[2] = mesh.worldMatrix[14];
+      _packMeshWorld(meshUboData, mesh.worldMatrix, 0, 0);
+      writeMeshLightSelection(mesh, scene.lights, meshUboData);
+      device.queue.writeBuffer(meshUBO, 0, meshUboData);
+      _lastWorldVersion = mesh.worldMatrixVersion;
+      _lastLightsCount = scene.lights.length;
+    }
+    if (source._uboVersion !== _lastUboVersion) {
+      _lastUboVersion = source._uboVersion;
+      matScratch.fill(0);
+      _writePbrMaterialData(matScratch, source, materialSpec);
+      device.queue.writeBuffer(materialUBO, 0, matScratch.buffer, 0, matScratch.byteLength);
+    }
+  };
+  const _invalidate = () => {
+    _lastWorldVersion = -1;
+  };
+  const update = ((_b = engine._wrapRenderableForFO) == null ? void 0 : _b.call(engine, _baseUpdate, scene, _invalidate)) ?? _baseUpdate;
+  const draw = (pass) => {
+    var _a2, _b2, _c, _d, _e, _f;
+    if (mesh.visible === false) {
+      return 0;
+    }
+    const gpu = mesh._gpu;
+    pass.setBindGroup(1, materialBindGroupStatic);
+    if (shadowBindGroup) {
+      pass.setBindGroup(2, shadowBindGroup);
+    }
+    let slot = 0;
+    const vb = gpu._vbLayout;
+    pass.setVertexBuffer(slot++, gpu.positionBuffer, (_a2 = vb == null ? void 0 : vb._p) == null ? void 0 : _a2._offset);
+    pass.setVertexBuffer(slot++, gpu.normalBuffer, (_b2 = vb == null ? void 0 : vb._n) == null ? void 0 : _b2._offset);
+    if (hasNormalMap && gpu.tangentBuffer) {
+      pass.setVertexBuffer(slot++, gpu.tangentBuffer, (_c = vb == null ? void 0 : vb._t) == null ? void 0 : _c._offset);
+    }
+    pass.setVertexBuffer(slot++, gpu.uvBuffer, (_d = vb == null ? void 0 : vb._u) == null ? void 0 : _d._offset);
+    if (hasUV2 && gpu.uv2Buffer) {
+      pass.setVertexBuffer(slot++, gpu.uv2Buffer, (_e = vb == null ? void 0 : vb._u2) == null ? void 0 : _e._offset);
+    }
+    if (hasVertexColor && gpu.colorBuffer) {
+      pass.setVertexBuffer(slot++, gpu.colorBuffer, (_f = vb == null ? void 0 : vb._c) == null ? void 0 : _f._offset);
+    }
+    const skin = mesh.skeleton ?? mesh.vat;
+    if (skin) {
+      pass.setVertexBuffer(slot++, skin.jointsBuffer);
+      pass.setVertexBuffer(slot++, skin.weightsBuffer);
+      if (skin.joints1Buffer && skin.weights1Buffer) {
+        pass.setVertexBuffer(slot++, skin.joints1Buffer);
+        pass.setVertexBuffer(slot++, skin.weights1Buffer);
+      }
+    }
+    const ti = hasTI ? mesh.thinInstances : null;
+    if (ti && syncThinInstanceBuffers) {
+      slot = syncThinInstanceBuffers(engine, ti, pass, slot, hasTIColor);
+    }
+    pass.setIndexBuffer(gpu.indexBuffer, gpu.indexFormat);
+    if (ti && ti.count > 0) {
+      pass.drawIndexed(gpu.indexCount, ti.count);
+    } else {
+      pass.drawIndexed(gpu.indexCount);
+    }
+    return 1;
+  };
+  const r = {
+    order: mesh.renderOrder ?? (isAlphaBlend ? 200 : 100),
+    isTransparent: isAlphaBlend,
+    mesh,
+    bind(eng, sig) {
+      return {
+        renderable: r,
+        pipeline: _getOrCreateGeometryPipeline(eng, sig, view, res),
+        update,
+        draw
+      };
+    }
+  };
+  r._worldCenter = sortCenter;
+  return r;
+}
+function _ensureViewResources(view, engine, ctx, meshFeatures, lightMode, singleLightType, variantKey) {
+  var _a, _b;
+  let cache = view._geometry;
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    Object.defineProperty(view, "_geometry", { value: cache, enumerable: false, configurable: true });
+  }
+  const cached = cache.get(variantKey);
+  if (cached) {
+    return cached;
+  }
+  _ensurePbrGeometryExt(() => view._geometryAttachments);
+  const features = view._renderFeatures.features;
+  const features2 = view._renderFeatures.features2 ?? 0;
+  const sceneFeatures = ctx._sceneFeatures;
+  const source = view.source;
+  const vbLayout = source._vbLayout;
+  const vbKey = "";
+  const prev = _setActivePbrGeometryAttachments(view._geometryAttachments);
+  let composed;
+  try {
+    composed = composePbrGeometryShader(
+      ctx._composePbr,
+      features,
+      features2,
+      meshFeatures,
+      sceneFeatures,
+      lightMode,
+      singleLightType,
+      "",
+      vbLayout,
+      vbKey,
+      view._geometryAttachments,
+      view._emitColor
+    );
+  } finally {
+    _setActivePbrGeometryAttachments(prev);
+  }
+  const device = engine._device;
+  const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);
+  const shadowBGL = composed._shadowBGLDescriptor ? device.createBindGroupLayout(composed._shadowBGLDescriptor) : null;
+  const sceneBGL = ((_a = engine._getSceneBGL) == null ? void 0 : _a.call(engine)) ?? _getSceneBindGroupLayoutLocal(engine);
+  const bgls = shadowBGL ? [sceneBGL, meshBGL, shadowBGL] : [sceneBGL, meshBGL];
+  const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: bgls });
+  const vertModule = device.createShaderModule({ code: composed._vertexWGSL });
+  const fragModule = device.createShaderModule({ code: composed._fragmentWGSL });
+  const sourceFeatures = ((_b = source._renderFeatures) == null ? void 0 : _b.features) ?? 0;
+  const alphaBlend = (sourceFeatures & PBR_HAS_ALPHA_BLEND) !== 0;
+  const res = {
+    _composed: composed,
+    _features: features,
+    _features2: features2,
+    _meshFeatures: meshFeatures,
+    _sceneFeatures: sceneFeatures,
+    _meshBGL: meshBGL,
+    _shadowBGL: shadowBGL,
+    _pipelineLayout: pipelineLayout,
+    _vertModule: vertModule,
+    _fragModule: fragModule,
+    _pipelines: /* @__PURE__ */ new Map(),
+    _alphaBlend: alphaBlend
+  };
+  cache.set(variantKey, res);
+  return res;
+}
+function _wrapBindings(res) {
+  return {
+    _features: res._features,
+    _features2: res._features2,
+    _meshFeatures: res._meshFeatures,
+    _meshBGL: res._meshBGL,
+    _shadowBGL: res._shadowBGL,
+    _composed: res._composed,
+    _pipelines: res._pipelines
+  };
+}
+function _getSceneBindGroupLayoutLocal(engine, _composed) {
+  return getSceneBindGroupLayout(engine);
+}
+function _getOrCreateGeometryPipeline(engine, sig, view, res) {
+  var _a;
+  const key = targetSignatureKey(sig);
+  const cached = res._pipelines.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const formats = sig._colorFormats ?? (sig._colorFormat ? [sig._colorFormat] : []);
+  if (formats.length === 0) {
+    throw new Error("pbr-geometry: render target has no color attachments");
+  }
+  const alphaBlend = res._alphaBlend;
+  const blendState = alphaBlend ? {
+    color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+    alpha: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" }
+  } : void 0;
+  const colorTargets = formats.map((fmt) => blendState ? { format: fmt, blend: blendState } : { format: fmt });
+  const sourceFeatures = ((_a = view.source._renderFeatures) == null ? void 0 : _a.features) ?? 0;
+  const hasDoubleSided = (sourceFeatures & PBR_HAS_DOUBLE_SIDED) !== 0;
+  const cullMode = hasDoubleSided ? "none" : view._reverseCulling ? "front" : "back";
+  const pipeline = device.createRenderPipeline({
+    layout: res._pipelineLayout,
+    vertex: { module: res._vertModule, entryPoint: "main", buffers: res._composed._vertexBufferLayouts },
+    fragment: { module: res._fragModule, entryPoint: "main", targets: colorTargets },
+    depthStencil: sig._depthStencilFormat ? {
+      format: sig._depthStencilFormat,
+      depthCompare: sig._depthCompare ?? REVERSE_DEPTH_COMPARE,
+      // Disable depth-write for alpha-blended meshes so background
+      // depth survives partially-transparent pixels. Matches the
+      // Standard geometry-renderable behaviour.
+      depthWriteEnabled: !alphaBlend
+    } : void 0,
+    multisample: { count: sig._sampleCount },
+    primitive: { topology: "triangle-list", cullMode, frontFace: "ccw" }
+  });
+  res._pipelines.set(key, pipeline);
+  return pipeline;
+}
+function _getPackedSingleLightType(lights, packedIndex) {
+  let packed = 0;
+  for (const light of lights) {
+    if (!light._writeLightUbo) {
+      continue;
+    }
+    if (packed === packedIndex) {
+      const t = light.lightType;
+      return t === "hemispheric" || t === "directional" || t === "spot" ? t : "point";
+    }
+    packed++;
+  }
+  return "point";
+}
+function _writePbrMaterialData(data, mat, spec) {
+  _writeMaterialData(data, mat, spec);
+}
+let _activeAttachments;
+function _setActivePbrGeometryAttachments(att) {
+  const prev = _activeAttachments;
+  _activeAttachments = att;
+  return prev;
+}
+function createPbrGeometryMaterialView(source, config) {
+  var _a, _b;
+  _ensurePbrGeometryExt(() => _activeAttachments);
+  const baseFeatures = ((_a = source._renderFeatures) == null ? void 0 : _a.features) ?? 0;
+  const baseFeatures2 = ((_b = source._renderFeatures) == null ? void 0 : _b.features2) ?? 0;
+  const view = createMaterialView(source, {
+    features: baseFeatures & ~PBR_HAS_ALPHA_BLEND,
+    features2: baseFeatures2 | PBR2_GEOMETRY_OUTPUT
+  });
+  Object.defineProperty(view, "_geometryAttachments", { value: config.attachments, enumerable: false });
+  Object.defineProperty(view, "_emitColor", { value: config.emitColor, enumerable: false });
+  Object.defineProperty(view, "_gpUBO", { value: config.gpUBO ?? null, enumerable: false });
+  Object.defineProperty(view, "_reverseCulling", { value: config.reverseCulling ?? false, enumerable: false });
+  Object.defineProperty(view, "_buildGroup", { value: pbrGeometryGroupBuilder, enumerable: false });
+  return view;
+}
+export {
+  _setActivePbrGeometryAttachments,
+  createPbrGeometryMaterialView
+};
+//# sourceMappingURL=pbr-geometry-view-NiZY_juX.js.map