@babylonjs/lite 1.2.0 → 1.3.0

package/{std-ambient-fragment-P8dHZ4An.js → std-ambient-fragment-BXl-88sn.js}

@@ -1,4 +1,4 @@
-import { aj as HAS_AMBIENT_TEXTURE, ak as AMBIENT_USES_UV2 } from "./index-BgY3QEzL.js";
+import { ai as HAS_AMBIENT_TEXTURE, aj as AMBIENT_USES_UV2 } from "./index-C2sM8ERH.js";
 const STAGE_FRAGMENT = 2;
 function createStdAmbientFragment(usesUV2) {
   const uv = usesUV2 ? "input.vv" : "input.vu";
@@ -34,4 +34,4 @@ export {
   createStdAmbientFragment,
   stdAmbientExt
 };
-//# sourceMappingURL=std-ambient-fragment-P8dHZ4An.js.map
+//# sourceMappingURL=std-ambient-fragment-BXl-88sn.js.map

package/{std-ambient-fragment-P8dHZ4An.js.map → std-ambient-fragment-BXl-88sn.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-ambient-fragment-P8dHZ4An.js","sources":["../src/material/standard/fragments/std-ambient-fragment.ts"],"sourcesContent":["/** Standard Ambient Texture Fragment — multiplies final diffuse by ambient occlusion texture. */\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_AMBIENT_TEXTURE, AMBIENT_USES_UV2 } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdAmbientFragment(usesUV2: boolean): ShaderFragment {\n    const uv = usesUV2 ? \"input.vv\" : \"input.vu\";\n    return {\n        _id: \"std-ambient\",\n        _bindings: [\n            { _name: \"aT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"aS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AD: `baseAmbientColor = textureSample(aT, aS, ${uv}).rgb * mat.ambTexLvl;`,\n        },\n    };\n}\n\nexport const stdAmbientExt: StdExt = {\n    _id: \"std-ambient\",\n    _phase: \"mesh\",\n    _feature: HAS_AMBIENT_TEXTURE,\n    _frag: (features) => createStdAmbientFragment((features & AMBIENT_USES_UV2) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.ambientTexture!;\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.ambientTexture) {\n            out.push(mat.ambientTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,yBAAyB,SAAkC;AACvE,QAAM,KAAK,UAAU,aAAa;AAClC,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI,4CAA4C,EAAE;AAAA,IAAA;AAAA,EACtD;AAER;AAEO,MAAM,gBAAwB;AAAA,EACjC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,0BAA0B,WAAW,sBAAsB,CAAC;AAAA,EACjF,MAAM,KAAK,SAAS,GAAG;AACnB,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,gBAAgB;AACpB,UAAI,KAAK,IAAI,cAAc;AAAA,IAC/B;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"std-ambient-fragment-BXl-88sn.js","sources":["../src/material/standard/fragments/std-ambient-fragment.ts"],"sourcesContent":["/** Standard Ambient Texture Fragment — multiplies final diffuse by ambient occlusion texture. */\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_AMBIENT_TEXTURE, AMBIENT_USES_UV2 } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdAmbientFragment(usesUV2: boolean): ShaderFragment {\n    const uv = usesUV2 ? \"input.vv\" : \"input.vu\";\n    return {\n        _id: \"std-ambient\",\n        _bindings: [\n            { _name: \"aT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"aS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AD: `baseAmbientColor = textureSample(aT, aS, ${uv}).rgb * mat.ambTexLvl;`,\n        },\n    };\n}\n\nexport const stdAmbientExt: StdExt = {\n    _id: \"std-ambient\",\n    _phase: \"mesh\",\n    _feature: HAS_AMBIENT_TEXTURE,\n    _frag: (features) => createStdAmbientFragment((features & AMBIENT_USES_UV2) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.ambientTexture!;\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.ambientTexture) {\n            out.push(mat.ambientTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,yBAAyB,SAAkC;AACvE,QAAM,KAAK,UAAU,aAAa;AAClC,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI,4CAA4C,EAAE;AAAA,IAAA;AAAA,EACtD;AAER;AAEO,MAAM,gBAAwB;AAAA,EACjC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,0BAA0B,WAAW,sBAAsB,CAAC;AAAA,EACjF,MAAM,KAAK,SAAS,GAAG;AACnB,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,gBAAgB;AACpB,UAAI,KAAK,IAAI,cAAc;AAAA,IAC/B;AAAA,EACJ;AACJ;"}

package/{std-cube-reflection-fragment-CF03MuQt.js → std-cube-reflection-fragment-Dn34WuMa.js}

@@ -1,4 +1,4 @@
-import { as as HAS_CUBE_REFLECTION } from "./index-BgY3QEzL.js";
+import { ar as HAS_CUBE_REFLECTION } from "./index-C2sM8ERH.js";
 function createStdCubeReflectionFragment() {
   return {
     _id: "std-cube-reflection",
@@ -28,4 +28,4 @@ export {
   createStdCubeReflectionFragment,
   stdCubeReflectionExt
 };
-//# sourceMappingURL=std-cube-reflection-fragment-CF03MuQt.js.map
+//# sourceMappingURL=std-cube-reflection-fragment-Dn34WuMa.js.map

package/{std-cube-reflection-fragment-CF03MuQt.js.map → std-cube-reflection-fragment-Dn34WuMa.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-cube-reflection-fragment-CF03MuQt.js","sources":["../src/material/standard/fragments/std-cube-reflection-fragment.ts"],"sourcesContent":["/** Cube reflection fragment — dynamically imported for scenes with cube reflection textures. */\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { StdExt } from \"../standard-flags.js\";\nimport { HAS_CUBE_REFLECTION } from \"../standard-flags.js\";\n\nexport function createStdCubeReflectionFragment(): ShaderFragment {\n    return {\n        _id: \"std-cube-reflection\",\n        _bindings: [\n            { _name: \"cRT\", _type: { _kind: \"texture\", _textureType: \"texture_cube<f32>\" }, _visibility: 0x2 },\n            { _name: \"cRS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: 0x2 },\n        ],\n        _fragmentSlots: {\n            AD: `{let v=normalize(input.vp-scene.vEyePosition.xyz);reflectionColor=textureSample(cRT,cRS,reflect(v,normalW)).rgb*mat.rLvl;}`,\n        },\n    };\n}\n\nexport const stdCubeReflectionExt: StdExt = {\n    _id: \"std-cube-reflection\",\n    _phase: \"mesh\",\n    _feature: HAS_CUBE_REFLECTION,\n    _frag: createStdCubeReflectionFragment,\n    _bind(mat, entries, b) {\n        const cube = mat.reflectionCubeTexture!;\n        entries.push({ binding: b++, resource: cube.view });\n        entries.push({ binding: b++, resource: cube.sampler });\n        return b;\n    },\n    // Cube textures are tracked separately; no Texture2D[] contribution.\n};\n"],"names":[],"mappings":";AAKO,SAAS,kCAAkD;AAC9D,SAAO;AAAA,IACH,KAAK;AAAA,IACL,WAAW;AAAA,MACP,EAAE,OAAO,OAAO,OAAO,EAAE,OAAO,WAAW,cAAc,oBAAA,GAAuB,aAAa,EAAA;AAAA,MAC7F,EAAE,OAAO,OAAO,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,EAAA;AAAA,IAAI;AAAA,IAE3F,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,uBAA+B;AAAA,EACxC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM,KAAK,SAAS,GAAG;AACnB,UAAM,OAAO,IAAI;AACjB,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,KAAK,MAAM;AAClD,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,KAAK,SAAS;AACrD,WAAO;AAAA,EACX;AAAA;AAEJ;"}
+{"version":3,"file":"std-cube-reflection-fragment-Dn34WuMa.js","sources":["../src/material/standard/fragments/std-cube-reflection-fragment.ts"],"sourcesContent":["/** Cube reflection fragment — dynamically imported for scenes with cube reflection textures. */\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { StdExt } from \"../standard-flags.js\";\nimport { HAS_CUBE_REFLECTION } from \"../standard-flags.js\";\n\nexport function createStdCubeReflectionFragment(): ShaderFragment {\n    return {\n        _id: \"std-cube-reflection\",\n        _bindings: [\n            { _name: \"cRT\", _type: { _kind: \"texture\", _textureType: \"texture_cube<f32>\" }, _visibility: 0x2 },\n            { _name: \"cRS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: 0x2 },\n        ],\n        _fragmentSlots: {\n            AD: `{let v=normalize(input.vp-scene.vEyePosition.xyz);reflectionColor=textureSample(cRT,cRS,reflect(v,normalW)).rgb*mat.rLvl;}`,\n        },\n    };\n}\n\nexport const stdCubeReflectionExt: StdExt = {\n    _id: \"std-cube-reflection\",\n    _phase: \"mesh\",\n    _feature: HAS_CUBE_REFLECTION,\n    _frag: createStdCubeReflectionFragment,\n    _bind(mat, entries, b) {\n        const cube = mat.reflectionCubeTexture!;\n        entries.push({ binding: b++, resource: cube.view });\n        entries.push({ binding: b++, resource: cube.sampler });\n        return b;\n    },\n    // Cube textures are tracked separately; no Texture2D[] contribution.\n};\n"],"names":[],"mappings":";AAKO,SAAS,kCAAkD;AAC9D,SAAO;AAAA,IACH,KAAK;AAAA,IACL,WAAW;AAAA,MACP,EAAE,OAAO,OAAO,OAAO,EAAE,OAAO,WAAW,cAAc,oBAAA,GAAuB,aAAa,EAAA;AAAA,MAC7F,EAAE,OAAO,OAAO,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,EAAA;AAAA,IAAI;AAAA,IAE3F,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,uBAA+B;AAAA,EACxC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM,KAAK,SAAS,GAAG;AACnB,UAAM,OAAO,IAAI;AACjB,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,KAAK,MAAM;AAClD,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,KAAK,SAAS;AACrD,WAAO;AAAA,EACX;AAAA;AAEJ;"}

package/{std-emissive-fragment-P8yJGclx.js → std-emissive-fragment-CK7TwRAt.js}

@@ -1,4 +1,4 @@
-import { af as HAS_EMISSIVE_TEXTURE, ag as HAS_DEPTH_EMISSIVE_TEXTURE } from "./index-BgY3QEzL.js";
+import { ae as HAS_EMISSIVE_TEXTURE, af as HAS_DEPTH_EMISSIVE_TEXTURE } from "./index-C2sM8ERH.js";
 const STAGE_FRAGMENT = 2;
 function createStdEmissiveFragment(depthTexture) {
   return {
@@ -37,4 +37,4 @@ export {
   createStdEmissiveFragment,
   stdEmissiveExt
 };
-//# sourceMappingURL=std-emissive-fragment-P8yJGclx.js.map
+//# sourceMappingURL=std-emissive-fragment-CK7TwRAt.js.map

package/{std-emissive-fragment-P8yJGclx.js.map → std-emissive-fragment-CK7TwRAt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-emissive-fragment-P8yJGclx.js","sources":["../src/material/standard/fragments/std-emissive-fragment.ts"],"sourcesContent":["/** Standard Emissive Texture Fragment — multiplies emissive contribution by texture sample. */\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_DEPTH_EMISSIVE_TEXTURE, HAS_EMISSIVE_TEXTURE } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdEmissiveFragment(depthTexture: boolean): ShaderFragment {\n    return {\n        _id: \"std-emissive\",\n        _bindings: [\n            {\n                _name: \"eT\",\n                _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\", _sampleType: depthTexture ? \"unfilterable-float\" : undefined },\n                _visibility: STAGE_FRAGMENT,\n            },\n            { _name: \"eS\", _type: { _kind: \"sampler\", _samplerType: depthTexture ? \"sampler_non_filtering\" : \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AT: `emissiveContrib = mat.ec + textureSample(eT, eS, input.vu).rgb * mat.tl;`,\n        },\n    };\n}\n\nexport const stdEmissiveExt: StdExt = {\n    _id: \"std-emissive\",\n    _phase: \"mesh\",\n    _feature: HAS_EMISSIVE_TEXTURE,\n    _frag: (features) => createStdEmissiveFragment((features & HAS_DEPTH_EMISSIVE_TEXTURE) !== 0),\n    _bind(mat: StandardMaterialProps, entries: GPUBindGroupEntry[], b: number): number {\n        const tex = mat.emissiveTexture!;\n        entries.push({ binding: b++, resource: tex.view });\n        entries.push({ binding: b++, resource: tex.sampler });\n        return b;\n    },\n    _textures(mat: StandardMaterialProps, out: Texture2D[]): void {\n        if (mat.emissiveTexture) {\n            out.push(mat.emissiveTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,0BAA0B,cAAuC;AAC7E,SAAO;AAAA,IACH,KAAK;AAAA,IACL,WAAW;AAAA,MACP;AAAA,QACI,OAAO;AAAA,QACP,OAAO,EAAE,OAAO,WAAW,cAAc,mBAAmB,aAAa,eAAe,uBAAuB,OAAA;AAAA,QAC/G,aAAa;AAAA,MAAA;AAAA,MAEjB,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,eAAe,0BAA0B,UAAA,GAAa,aAAa,eAAA;AAAA,IAAe;AAAA,IAE9I,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,iBAAyB;AAAA,EAClC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,2BAA2B,WAAW,gCAAgC,CAAC;AAAA,EAC5F,MAAM,KAA4B,SAA8B,GAAmB;AAC/E,UAAM,MAAM,IAAI;AAChB,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,MAAM;AACjD,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,SAAS;AACpD,WAAO;AAAA,EACX;AAAA,EACA,UAAU,KAA4B,KAAwB;AAC1D,QAAI,IAAI,iBAAiB;AACrB,UAAI,KAAK,IAAI,eAAe;AAAA,IAChC;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"std-emissive-fragment-CK7TwRAt.js","sources":["../src/material/standard/fragments/std-emissive-fragment.ts"],"sourcesContent":["/** Standard Emissive Texture Fragment — multiplies emissive contribution by texture sample. */\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_DEPTH_EMISSIVE_TEXTURE, HAS_EMISSIVE_TEXTURE } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdEmissiveFragment(depthTexture: boolean): ShaderFragment {\n    return {\n        _id: \"std-emissive\",\n        _bindings: [\n            {\n                _name: \"eT\",\n                _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\", _sampleType: depthTexture ? \"unfilterable-float\" : undefined },\n                _visibility: STAGE_FRAGMENT,\n            },\n            { _name: \"eS\", _type: { _kind: \"sampler\", _samplerType: depthTexture ? \"sampler_non_filtering\" : \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AT: `emissiveContrib = mat.ec + textureSample(eT, eS, input.vu).rgb * mat.tl;`,\n        },\n    };\n}\n\nexport const stdEmissiveExt: StdExt = {\n    _id: \"std-emissive\",\n    _phase: \"mesh\",\n    _feature: HAS_EMISSIVE_TEXTURE,\n    _frag: (features) => createStdEmissiveFragment((features & HAS_DEPTH_EMISSIVE_TEXTURE) !== 0),\n    _bind(mat: StandardMaterialProps, entries: GPUBindGroupEntry[], b: number): number {\n        const tex = mat.emissiveTexture!;\n        entries.push({ binding: b++, resource: tex.view });\n        entries.push({ binding: b++, resource: tex.sampler });\n        return b;\n    },\n    _textures(mat: StandardMaterialProps, out: Texture2D[]): void {\n        if (mat.emissiveTexture) {\n            out.push(mat.emissiveTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,0BAA0B,cAAuC;AAC7E,SAAO;AAAA,IACH,KAAK;AAAA,IACL,WAAW;AAAA,MACP;AAAA,QACI,OAAO;AAAA,QACP,OAAO,EAAE,OAAO,WAAW,cAAc,mBAAmB,aAAa,eAAe,uBAAuB,OAAA;AAAA,QAC/G,aAAa;AAAA,MAAA;AAAA,MAEjB,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,eAAe,0BAA0B,UAAA,GAAa,aAAa,eAAA;AAAA,IAAe;AAAA,IAE9I,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,iBAAyB;AAAA,EAClC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,2BAA2B,WAAW,gCAAgC,CAAC;AAAA,EAC5F,MAAM,KAA4B,SAA8B,GAAmB;AAC/E,UAAM,MAAM,IAAI;AAChB,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,MAAM;AACjD,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,SAAS;AACpD,WAAO;AAAA,EACX;AAAA,EACA,UAAU,KAA4B,KAAwB;AAC1D,QAAI,IAAI,iBAAiB;AACrB,UAAI,KAAK,IAAI,eAAe;AAAA,IAChC;AAAA,EACJ;AACJ;"}

package/{std-lightmap-fragment-CymEG79z.js → std-lightmap-fragment-BSeS8K-4.js}

@@ -1,4 +1,4 @@
-import { al as HAS_LIGHTMAP_TEXTURE, am as LIGHTMAP_FLIP_V, an as LIGHTMAP_SHADOWMAP, ao as LIGHTMAP_USES_UV2 } from "./index-BgY3QEzL.js";
+import { ak as HAS_LIGHTMAP_TEXTURE, al as LIGHTMAP_FLIP_V, am as LIGHTMAP_SHADOWMAP, an as LIGHTMAP_USES_UV2 } from "./index-C2sM8ERH.js";
 const STAGE_FRAGMENT = 2;
 function createStdLightmapFragment(usesUV2, shadowmap, flipV) {
   const baseUv = usesUV2 ? "input.vv" : "input.vu";
@@ -37,4 +37,4 @@ export {
   createStdLightmapFragment,
   stdLightmapExt
 };
-//# sourceMappingURL=std-lightmap-fragment-CymEG79z.js.map
+//# sourceMappingURL=std-lightmap-fragment-BSeS8K-4.js.map

package/{std-lightmap-fragment-CymEG79z.js.map → std-lightmap-fragment-BSeS8K-4.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-lightmap-fragment-CymEG79z.js","sources":["../src/material/standard/fragments/std-lightmap-fragment.ts"],"sourcesContent":["/** Standard Lightmap Fragment — blends a lightmap into the final color.\n *  Additive (default): `color += lightmap * level`.\n *  Shadowmap (`useLightmapAsShadowmap`): `color *= lightmap * level`.\n *  Matches BJS default.fragment.fx lightmap apply (raw sRGB sample, no gamma decode). */\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_LIGHTMAP_TEXTURE, LIGHTMAP_USES_UV2, LIGHTMAP_SHADOWMAP, LIGHTMAP_FLIP_V } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdLightmapFragment(usesUV2: boolean, shadowmap: boolean, flipV: boolean): ShaderFragment {\n    const baseUv = usesUV2 ? \"input.vv\" : \"input.vu\";\n    const uv = flipV ? `vec2<f32>(${baseUv}.x, 1.0 - ${baseUv}.y)` : baseUv;\n    const lm = `textureSample(lT, lS, ${uv}).rgb * mat.lmLvl`;\n    const apply = shadowmap ? `color.rgb * (${lm})` : `color.rgb + ${lm}`;\n    return {\n        _id: \"std-lightmap\",\n        _bindings: [\n            { _name: \"lT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"lS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            BC: `color = vec4<f32>(${apply}, color.a);`,\n        },\n    };\n}\n\nexport const stdLightmapExt: StdExt = {\n    _id: \"std-lightmap\",\n    _phase: \"mesh\",\n    _feature: HAS_LIGHTMAP_TEXTURE,\n    _frag: (features) => createStdLightmapFragment((features & LIGHTMAP_USES_UV2) !== 0, (features & LIGHTMAP_SHADOWMAP) !== 0, (features & LIGHTMAP_FLIP_V) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.lightmapTexture!;\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.lightmapTexture) {\n            out.push(mat.lightmapTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAUA,MAAM,iBAAiB;AAEhB,SAAS,0BAA0B,SAAkB,WAAoB,OAAgC;AAC5G,QAAM,SAAS,UAAU,aAAa;AACtC,QAAM,KAAK,QAAQ,aAAa,MAAM,aAAa,MAAM,QAAQ;AACjE,QAAM,KAAK,yBAAyB,EAAE;AACtC,QAAM,QAAQ,YAAY,gBAAgB,EAAE,MAAM,eAAe,EAAE;AACnE,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI,qBAAqB,KAAK;AAAA,IAAA;AAAA,EAClC;AAER;AAEO,MAAM,iBAAyB;AAAA,EAClC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,2BAA2B,WAAW,uBAAuB,IAAI,WAAW,wBAAwB,IAAI,WAAW,qBAAqB,CAAC;AAAA,EAC9J,MAAM,KAAK,SAAS,GAAG;AACnB,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,iBAAiB;AACrB,UAAI,KAAK,IAAI,eAAe;AAAA,IAChC;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"std-lightmap-fragment-BSeS8K-4.js","sources":["../src/material/standard/fragments/std-lightmap-fragment.ts"],"sourcesContent":["/** Standard Lightmap Fragment — blends a lightmap into the final color.\n *  Additive (default): `color += lightmap * level`.\n *  Shadowmap (`useLightmapAsShadowmap`): `color *= lightmap * level`.\n *  Matches BJS default.fragment.fx lightmap apply (raw sRGB sample, no gamma decode). */\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_LIGHTMAP_TEXTURE, LIGHTMAP_USES_UV2, LIGHTMAP_SHADOWMAP, LIGHTMAP_FLIP_V } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdLightmapFragment(usesUV2: boolean, shadowmap: boolean, flipV: boolean): ShaderFragment {\n    const baseUv = usesUV2 ? \"input.vv\" : \"input.vu\";\n    const uv = flipV ? `vec2<f32>(${baseUv}.x, 1.0 - ${baseUv}.y)` : baseUv;\n    const lm = `textureSample(lT, lS, ${uv}).rgb * mat.lmLvl`;\n    const apply = shadowmap ? `color.rgb * (${lm})` : `color.rgb + ${lm}`;\n    return {\n        _id: \"std-lightmap\",\n        _bindings: [\n            { _name: \"lT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"lS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            BC: `color = vec4<f32>(${apply}, color.a);`,\n        },\n    };\n}\n\nexport const stdLightmapExt: StdExt = {\n    _id: \"std-lightmap\",\n    _phase: \"mesh\",\n    _feature: HAS_LIGHTMAP_TEXTURE,\n    _frag: (features) => createStdLightmapFragment((features & LIGHTMAP_USES_UV2) !== 0, (features & LIGHTMAP_SHADOWMAP) !== 0, (features & LIGHTMAP_FLIP_V) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.lightmapTexture!;\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.lightmapTexture) {\n            out.push(mat.lightmapTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAUA,MAAM,iBAAiB;AAEhB,SAAS,0BAA0B,SAAkB,WAAoB,OAAgC;AAC5G,QAAM,SAAS,UAAU,aAAa;AACtC,QAAM,KAAK,QAAQ,aAAa,MAAM,aAAa,MAAM,QAAQ;AACjE,QAAM,KAAK,yBAAyB,EAAE;AACtC,QAAM,QAAQ,YAAY,gBAAgB,EAAE,MAAM,eAAe,EAAE;AACnE,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI,qBAAqB,KAAK;AAAA,IAAA;AAAA,EAClC;AAER;AAEO,MAAM,iBAAyB;AAAA,EAClC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,2BAA2B,WAAW,uBAAuB,IAAI,WAAW,wBAAwB,IAAI,WAAW,qBAAqB,CAAC;AAAA,EAC9J,MAAM,KAAK,SAAS,GAAG;AACnB,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,iBAAiB;AACrB,UAAI,KAAK,IAAI,eAAe;AAAA,IAChC;AAAA,EACJ;AACJ;"}

package/{std-opacity-fragment-DLa1zV06.js → std-opacity-fragment-DnLaWH9w.js}

@@ -1,4 +1,4 @@
-import { ap as HAS_OPACITY_TEXTURE, aq as OPACITY_FROM_RGB } from "./index-BgY3QEzL.js";
+import { ao as HAS_OPACITY_TEXTURE, ap as OPACITY_FROM_RGB } from "./index-C2sM8ERH.js";
 const STAGE_FRAGMENT = 2;
 function createStdOpacityFragment(fromRGB) {
   const opacityCalc = fromRGB ? `{ let opSample = textureSample(oT, oS, input.vu); alpha *= dot(opSample.rgb, vec3<f32>(0.3, 0.59, 0.11)) * mat.opLvl; }` : `alpha *= textureSample(oT, oS, input.vu).a * mat.opLvl;`;
@@ -34,4 +34,4 @@ export {
   createStdOpacityFragment,
   stdOpacityExt
 };
-//# sourceMappingURL=std-opacity-fragment-DLa1zV06.js.map
+//# sourceMappingURL=std-opacity-fragment-DnLaWH9w.js.map

package/{std-opacity-fragment-DLa1zV06.js.map → std-opacity-fragment-DnLaWH9w.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-opacity-fragment-DLa1zV06.js","sources":["../src/material/standard/fragments/std-opacity-fragment.ts"],"sourcesContent":["/** Standard Opacity Texture Fragment — modulates alpha by opacity texture. */\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_OPACITY_TEXTURE, OPACITY_FROM_RGB } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdOpacityFragment(fromRGB: boolean): ShaderFragment {\n    const opacityCalc = fromRGB\n        ? `{ let opSample = textureSample(oT, oS, input.vu); alpha *= dot(opSample.rgb, vec3<f32>(0.3, 0.59, 0.11)) * mat.opLvl; }`\n        : `alpha *= textureSample(oT, oS, input.vu).a * mat.opLvl;`;\n    return {\n        _id: \"std-opacity\",\n        _bindings: [\n            { _name: \"oT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"oS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AT: opacityCalc,\n        },\n    };\n}\n\nexport const stdOpacityExt: StdExt = {\n    _id: \"std-opacity\",\n    _phase: \"mesh\",\n    _feature: HAS_OPACITY_TEXTURE,\n    _frag: (features) => createStdOpacityFragment((features & OPACITY_FROM_RGB) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.opacityTexture!;\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.opacityTexture) {\n            out.push(mat.opacityTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,yBAAyB,SAAkC;AACvE,QAAM,cAAc,UACd,4HACA;AACN,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,gBAAwB;AAAA,EACjC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,0BAA0B,WAAW,sBAAsB,CAAC;AAAA,EACjF,MAAM,KAAK,SAAS,GAAG;AACnB,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,gBAAgB;AACpB,UAAI,KAAK,IAAI,cAAc;AAAA,IAC/B;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"std-opacity-fragment-DnLaWH9w.js","sources":["../src/material/standard/fragments/std-opacity-fragment.ts"],"sourcesContent":["/** Standard Opacity Texture Fragment — modulates alpha by opacity texture. */\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_OPACITY_TEXTURE, OPACITY_FROM_RGB } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdOpacityFragment(fromRGB: boolean): ShaderFragment {\n    const opacityCalc = fromRGB\n        ? `{ let opSample = textureSample(oT, oS, input.vu); alpha *= dot(opSample.rgb, vec3<f32>(0.3, 0.59, 0.11)) * mat.opLvl; }`\n        : `alpha *= textureSample(oT, oS, input.vu).a * mat.opLvl;`;\n    return {\n        _id: \"std-opacity\",\n        _bindings: [\n            { _name: \"oT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"oS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AT: opacityCalc,\n        },\n    };\n}\n\nexport const stdOpacityExt: StdExt = {\n    _id: \"std-opacity\",\n    _phase: \"mesh\",\n    _feature: HAS_OPACITY_TEXTURE,\n    _frag: (features) => createStdOpacityFragment((features & OPACITY_FROM_RGB) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.opacityTexture!;\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.opacityTexture) {\n            out.push(mat.opacityTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,yBAAyB,SAAkC;AACvE,QAAM,cAAc,UACd,4HACA;AACN,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,gBAAwB;AAAA,EACjC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,0BAA0B,WAAW,sBAAsB,CAAC;AAAA,EACjF,MAAM,KAAK,SAAS,GAAG;AACnB,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,gBAAgB;AACpB,UAAI,KAAK,IAAI,cAAc;AAAA,IAC/B;AAAA,EACJ;AACJ;"}

package/{std-reflection-fragment-BLySsYos.js → std-reflection-fragment-BToYPemd.js}

@@ -1,4 +1,4 @@
-import { ar as HAS_REFLECTION_TEXTURE } from "./index-BgY3QEzL.js";
+import { aq as HAS_REFLECTION_TEXTURE } from "./index-C2sM8ERH.js";
 const STAGE_FRAGMENT = 2;
 const REFLECTION_HELPERS = `
 fn computeSphericalCoords(worldPos: vec3<f32>, worldNormal: vec3<f32>) -> vec2<f32> {
@@ -54,4 +54,4 @@ export {
   createStdReflectionFragment,
   stdReflectionExt
 };
-//# sourceMappingURL=std-reflection-fragment-BLySsYos.js.map
+//# sourceMappingURL=std-reflection-fragment-BToYPemd.js.map

package/{std-reflection-fragment-BLySsYos.js.map → std-reflection-fragment-BToYPemd.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-reflection-fragment-BLySsYos.js","sources":["../src/material/standard/fragments/std-reflection-fragment.ts"],"sourcesContent":["/** Standard Reflection Texture Fragment — spherical/planar environment reflection. */\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nconst REFLECTION_HELPERS = `\nfn computeSphericalCoords(worldPos: vec3<f32>, worldNormal: vec3<f32>) -> vec2<f32> {\nlet viewDir = normalize((scene.view * vec4<f32>(worldPos, 1.0)).xyz);\nlet viewNormal = normalize((scene.view * vec4<f32>(worldNormal, 0.0)).xyz);\nvar r = reflect(viewDir, viewNormal);\nr.z = r.z - 1.0;\nlet m = 2.0 * length(r);\nreturn vec2<f32>(r.x / m + 0.5, r.y / m + 0.5);\n}\nfn computePlanarCoords(worldPos: vec3<f32>, worldNormal: vec3<f32>) -> vec2<f32> {\nlet viewDir = worldPos - scene.vEyePosition.xyz;\nlet coords = normalize(reflect(viewDir, worldNormal));\nreturn vec2<f32>(coords.x, 1.0 - coords.y);\n}\n`;\n\nexport function createStdReflectionFragment(): ShaderFragment {\n    return {\n        _id: \"std-reflection\",\n        _bindings: [\n            { _name: \"rT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"rS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _helperFunctions: REFLECTION_HELPERS,\n        _fragmentSlots: {\n            AD: `{\nvar reflCoords: vec2<f32>;\nif (mat.rCm < 1.5) { reflCoords = computeSphericalCoords(input.vp, normalW); }\nelse { reflCoords = computePlanarCoords(input.vp, normalW); }\nreflectionColor = textureSample(rT, rS, reflCoords).rgb * mat.rLvl;\n}`,\n        },\n    };\n}\n\nimport type { StandardMaterialProps } from \"../standard-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { StdExt } from \"../standard-flags.js\";\nimport { HAS_REFLECTION_TEXTURE } from \"../standard-flags.js\";\n\nexport const stdReflectionExt: StdExt = {\n    _id: \"std-reflection\",\n    _phase: \"mesh\",\n    _feature: HAS_REFLECTION_TEXTURE,\n    _frag: createStdReflectionFragment,\n    _bind(mat, entries, b) {\n        const tex = mat.reflectionTexture!;\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.reflectionTexture) {\n            out.push(mat.reflectionTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAGA,MAAM,iBAAiB;AAEvB,MAAM,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBpB,SAAS,8BAA8C;AAC1D,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,kBAAkB;AAAA,IAClB,gBAAgB;AAAA,MACZ,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AAAA,EAMR;AAER;AAOO,MAAM,mBAA2B;AAAA,EACpC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM,KAAK,SAAS,GAAG;AACnB,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,mBAAmB;AACvB,UAAI,KAAK,IAAI,iBAAiB;AAAA,IAClC;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"std-reflection-fragment-BToYPemd.js","sources":["../src/material/standard/fragments/std-reflection-fragment.ts"],"sourcesContent":["/** Standard Reflection Texture Fragment — spherical/planar environment reflection. */\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nconst REFLECTION_HELPERS = `\nfn computeSphericalCoords(worldPos: vec3<f32>, worldNormal: vec3<f32>) -> vec2<f32> {\nlet viewDir = normalize((scene.view * vec4<f32>(worldPos, 1.0)).xyz);\nlet viewNormal = normalize((scene.view * vec4<f32>(worldNormal, 0.0)).xyz);\nvar r = reflect(viewDir, viewNormal);\nr.z = r.z - 1.0;\nlet m = 2.0 * length(r);\nreturn vec2<f32>(r.x / m + 0.5, r.y / m + 0.5);\n}\nfn computePlanarCoords(worldPos: vec3<f32>, worldNormal: vec3<f32>) -> vec2<f32> {\nlet viewDir = worldPos - scene.vEyePosition.xyz;\nlet coords = normalize(reflect(viewDir, worldNormal));\nreturn vec2<f32>(coords.x, 1.0 - coords.y);\n}\n`;\n\nexport function createStdReflectionFragment(): ShaderFragment {\n    return {\n        _id: \"std-reflection\",\n        _bindings: [\n            { _name: \"rT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"rS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _helperFunctions: REFLECTION_HELPERS,\n        _fragmentSlots: {\n            AD: `{\nvar reflCoords: vec2<f32>;\nif (mat.rCm < 1.5) { reflCoords = computeSphericalCoords(input.vp, normalW); }\nelse { reflCoords = computePlanarCoords(input.vp, normalW); }\nreflectionColor = textureSample(rT, rS, reflCoords).rgb * mat.rLvl;\n}`,\n        },\n    };\n}\n\nimport type { StandardMaterialProps } from \"../standard-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { StdExt } from \"../standard-flags.js\";\nimport { HAS_REFLECTION_TEXTURE } from \"../standard-flags.js\";\n\nexport const stdReflectionExt: StdExt = {\n    _id: \"std-reflection\",\n    _phase: \"mesh\",\n    _feature: HAS_REFLECTION_TEXTURE,\n    _frag: createStdReflectionFragment,\n    _bind(mat, entries, b) {\n        const tex = mat.reflectionTexture!;\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.reflectionTexture) {\n            out.push(mat.reflectionTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAGA,MAAM,iBAAiB;AAEvB,MAAM,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBpB,SAAS,8BAA8C;AAC1D,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,kBAAkB;AAAA,IAClB,gBAAgB;AAAA,MACZ,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AAAA,EAMR;AAER;AAOO,MAAM,mBAA2B;AAAA,EACpC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM,KAAK,SAAS,GAAG;AACnB,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,mBAAmB;AACvB,UAAI,KAAK,IAAI,iBAAiB;AAAA,IAClC;AAAA,EACJ;AACJ;"}

package/{std-shadow-fragment-C_q27Mdi.js → std-shadow-fragment-9b0rFY7F.js}

@@ -1,5 +1,5 @@
 import { c as createShadowFragment } from "./shadow-fragment-core-DHN2G6FI.js";
-import { at as getCsmStdReceiverFactory } from "./index-BgY3QEzL.js";
+import { as as getCsmStdReceiverFactory } from "./index-C2sM8ERH.js";
 function createStdShadowFragment(shadowLights) {
   const csmSlots = shadowLights.filter((sl) => sl.shadowType === "csm");
   if (csmSlots.length > 0) {
@@ -10,4 +10,4 @@ function createStdShadowFragment(shadowLights) {
 export {
   createStdShadowFragment
 };
-//# sourceMappingURL=std-shadow-fragment-C_q27Mdi.js.map
+//# sourceMappingURL=std-shadow-fragment-9b0rFY7F.js.map

package/{std-shadow-fragment-C_q27Mdi.js.map → std-shadow-fragment-9b0rFY7F.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-shadow-fragment-C_q27Mdi.js","sources":["../src/material/standard/fragments/std-shadow-fragment.ts"],"sourcesContent":["/**\n * Standard Shadow Fragment — Per-Light Shadow Support\n *\n * Thin wrapper around the shared shadow-fragment-core for Standard materials.\n * Only bundled when a scene uses shadow-receiving Standard meshes.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport { createShadowFragment } from \"../../../shader/fragments/shadow-fragment-core.js\";\nimport { getCsmStdReceiverFactory } from \"../../../shadow/csm-receiver-registry.js\";\n\nexport type { ShadowLightSlot } from \"../../../shader/fragments/shadow-fragment-core.js\";\nimport type { ShadowLightSlot } from \"../../../shader/fragments/shadow-fragment-core.js\";\n\n/**\n * Create a per-light shadow fragment for Standard materials.\n * Each shadow-casting light gets its own varying, bindings, and sampling code.\n * The shadow factor for each light is stored in shadowFactors[lightIndex].\n *\n * If any slot is a cascaded-shadow (`\"csm\"`) light, the cascaded receiver factory\n * registered by the CSM generator is used (v1: a scene mixing CSM with ESM/PCF\n * receivers on the same mesh is unsupported). Otherwise the plain ESM/PCF core is used.\n */\nexport function createStdShadowFragment(shadowLights: ShadowLightSlot[]): ShaderFragment {\n    const csmSlots = shadowLights.filter((sl) => sl.shadowType === \"csm\");\n    if (csmSlots.length > 0) {\n        return getCsmStdReceiverFactory()!(csmSlots.map((s) => ({ lightIndex: s.lightIndex })));\n    }\n    return createShadowFragment(\"std-shadow\", shadowLights);\n}\n"],"names":[],"mappings":";;AAuBO,SAAS,wBAAwB,cAAiD;AACrF,QAAM,WAAW,aAAa,OAAO,CAAC,OAAO,GAAG,eAAe,KAAK;AACpE,MAAI,SAAS,SAAS,GAAG;AACrB,WAAO,yBAAA,EAA4B,SAAS,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,WAAA,EAAa,CAAC;AAAA,EAC1F;AACA,SAAO,qBAAqB,cAAc,YAAY;AAC1D;"}
+{"version":3,"file":"std-shadow-fragment-9b0rFY7F.js","sources":["../src/material/standard/fragments/std-shadow-fragment.ts"],"sourcesContent":["/**\n * Standard Shadow Fragment — Per-Light Shadow Support\n *\n * Thin wrapper around the shared shadow-fragment-core for Standard materials.\n * Only bundled when a scene uses shadow-receiving Standard meshes.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport { createShadowFragment } from \"../../../shader/fragments/shadow-fragment-core.js\";\nimport { getCsmStdReceiverFactory } from \"../../../shadow/csm-receiver-registry.js\";\n\nexport type { ShadowLightSlot } from \"../../../shader/fragments/shadow-fragment-core.js\";\nimport type { ShadowLightSlot } from \"../../../shader/fragments/shadow-fragment-core.js\";\n\n/**\n * Create a per-light shadow fragment for Standard materials.\n * Each shadow-casting light gets its own varying, bindings, and sampling code.\n * The shadow factor for each light is stored in shadowFactors[lightIndex].\n *\n * If any slot is a cascaded-shadow (`\"csm\"`) light, the cascaded receiver factory\n * registered by the CSM generator is used (v1: a scene mixing CSM with ESM/PCF\n * receivers on the same mesh is unsupported). Otherwise the plain ESM/PCF core is used.\n */\nexport function createStdShadowFragment(shadowLights: ShadowLightSlot[]): ShaderFragment {\n    const csmSlots = shadowLights.filter((sl) => sl.shadowType === \"csm\");\n    if (csmSlots.length > 0) {\n        return getCsmStdReceiverFactory()!(csmSlots.map((s) => ({ lightIndex: s.lightIndex })));\n    }\n    return createShadowFragment(\"std-shadow\", shadowLights);\n}\n"],"names":[],"mappings":";;AAuBO,SAAS,wBAAwB,cAAiD;AACrF,QAAM,WAAW,aAAa,OAAO,CAAC,OAAO,GAAG,eAAe,KAAK;AACpE,MAAI,SAAS,SAAS,GAAG;AACrB,WAAO,yBAAA,EAA4B,SAAS,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,WAAA,EAAa,CAAC;AAAA,EAC1F;AACA,SAAO,qBAAqB,cAAc,YAAY;AAC1D;"}

package/{std-specular-fragment-CaBXyAWY.js → std-specular-fragment-OBO-zxGh.js}

@@ -1,4 +1,4 @@
-import { ah as HAS_SPECULAR_TEXTURE, ai as SPECULAR_USES_UV2 } from "./index-BgY3QEzL.js";
+import { ag as HAS_SPECULAR_TEXTURE, ah as SPECULAR_USES_UV2 } from "./index-C2sM8ERH.js";
 const STAGE_FRAGMENT = 2;
 function createStdSpecularFragment(usesUV2) {
   const uv = usesUV2 ? "input.vv" : "input.vu";
@@ -34,4 +34,4 @@ export {
   createStdSpecularFragment,
   stdSpecularExt
 };
-//# sourceMappingURL=std-specular-fragment-CaBXyAWY.js.map
+//# sourceMappingURL=std-specular-fragment-OBO-zxGh.js.map

package/{std-specular-fragment-CaBXyAWY.js.map → std-specular-fragment-OBO-zxGh.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-specular-fragment-CaBXyAWY.js","sources":["../src/material/standard/fragments/std-specular-fragment.ts"],"sourcesContent":["/** Standard Specular Texture Fragment — replaces specular color with texture sample. */\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_SPECULAR_TEXTURE, SPECULAR_USES_UV2 } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdSpecularFragment(usesUV2: boolean): ShaderFragment {\n    const uv = usesUV2 ? \"input.vv\" : \"input.vu\";\n    return {\n        _id: \"std-specular\",\n        _bindings: [\n            { _name: \"sT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"sS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AT: `specularColor = textureSample(sT, sS, ${uv}).rgb;`,\n        },\n    };\n}\n\nexport const stdSpecularExt: StdExt = {\n    _id: \"std-specular\",\n    _phase: \"mesh\",\n    _feature: HAS_SPECULAR_TEXTURE,\n    _frag: (features) => createStdSpecularFragment((features & SPECULAR_USES_UV2) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.specularTexture!;\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.specularTexture) {\n            out.push(mat.specularTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,0BAA0B,SAAkC;AACxE,QAAM,KAAK,UAAU,aAAa;AAClC,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI,yCAAyC,EAAE;AAAA,IAAA;AAAA,EACnD;AAER;AAEO,MAAM,iBAAyB;AAAA,EAClC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,2BAA2B,WAAW,uBAAuB,CAAC;AAAA,EACnF,MAAM,KAAK,SAAS,GAAG;AACnB,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,iBAAiB;AACrB,UAAI,KAAK,IAAI,eAAe;AAAA,IAChC;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"std-specular-fragment-OBO-zxGh.js","sources":["../src/material/standard/fragments/std-specular-fragment.ts"],"sourcesContent":["/** Standard Specular Texture Fragment — replaces specular color with texture sample. */\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_SPECULAR_TEXTURE, SPECULAR_USES_UV2 } from \"../standard-flags.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nexport function createStdSpecularFragment(usesUV2: boolean): ShaderFragment {\n    const uv = usesUV2 ? \"input.vv\" : \"input.vu\";\n    return {\n        _id: \"std-specular\",\n        _bindings: [\n            { _name: \"sT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"sS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n        _fragmentSlots: {\n            AT: `specularColor = textureSample(sT, sS, ${uv}).rgb;`,\n        },\n    };\n}\n\nexport const stdSpecularExt: StdExt = {\n    _id: \"std-specular\",\n    _phase: \"mesh\",\n    _feature: HAS_SPECULAR_TEXTURE,\n    _frag: (features) => createStdSpecularFragment((features & SPECULAR_USES_UV2) !== 0),\n    _bind(mat, entries, b) {\n        const tex = mat.specularTexture!;\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.specularTexture) {\n            out.push(mat.specularTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";AAOA,MAAM,iBAAiB;AAEhB,SAAS,0BAA0B,SAAkC;AACxE,QAAM,KAAK,UAAU,aAAa;AAClC,SAAO;AAAA,IACH,KAAK;AAAA,IACL,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,IAErG,gBAAgB;AAAA,MACZ,IAAI,yCAAyC,EAAE;AAAA,IAAA;AAAA,EACnD;AAER;AAEO,MAAM,iBAAyB;AAAA,EAClC,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO,CAAC,aAAa,2BAA2B,WAAW,uBAAuB,CAAC;AAAA,EACnF,MAAM,KAAK,SAAS,GAAG;AACnB,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,iBAAiB;AACrB,UAAI,KAAK,IAAI,eAAe;AAAA,IAChC;AAAA,EACJ;AACJ;"}

package/{std-tracking-Bw61Dv98.js → std-tracking-4SHTntWt.js}

@@ -1,4 +1,4 @@
-import { t as trackScalar, o as observableColor3, a as observableVec2 } from "./tracking-primitives-CMBWLxGr.js";
+import { t as trackScalar, o as observableColor3, a as observableVec2 } from "./tracking-primitives-CqIIi7Ej.js";
 function installStdTracking(mat) {
   for (const key of ["alpha", "specularPower", "bumpLevel", "ambientTexLevel", "lightmapLevel", "opacityLevel", "alphaCutOff", "reflectionLevel"]) {
     trackScalar(mat, key);
@@ -12,4 +12,4 @@ function installStdTracking(mat) {
 export {
   installStdTracking
 };
-//# sourceMappingURL=std-tracking-Bw61Dv98.js.map
+//# sourceMappingURL=std-tracking-4SHTntWt.js.map

package/{std-tracking-Bw61Dv98.js.map → std-tracking-4SHTntWt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"std-tracking-Bw61Dv98.js","sources":["../src/material/tracking/std-tracking.ts"],"sourcesContent":["/** Standard material auto-dirty tracking. Dynamically imported by enableMaterialTracking(). */\n\nimport type { StandardMaterialProps } from \"../standard/standard-material.js\";\nimport { trackScalar, observableColor3, observableVec2 } from \"./tracking-primitives.js\";\n\nexport function installStdTracking(mat: StandardMaterialProps): void {\n    for (const key of [\"alpha\", \"specularPower\", \"bumpLevel\", \"ambientTexLevel\", \"lightmapLevel\", \"opacityLevel\", \"alphaCutOff\", \"reflectionLevel\"]) {\n        trackScalar(mat, key);\n    }\n    mat.diffuseColor = observableColor3(mat.diffuseColor[0], mat.diffuseColor[1], mat.diffuseColor[2], mat as any);\n    mat.specularColor = observableColor3(mat.specularColor[0], mat.specularColor[1], mat.specularColor[2], mat as any);\n    mat.emissiveColor = observableColor3(mat.emissiveColor[0], mat.emissiveColor[1], mat.emissiveColor[2], mat as any);\n    mat.ambientColor = observableColor3(mat.ambientColor[0], mat.ambientColor[1], mat.ambientColor[2], mat as any);\n    mat.uvScale = observableVec2(mat.uvScale[0], mat.uvScale[1], mat as any);\n}\n"],"names":[],"mappings":";AAKO,SAAS,mBAAmB,KAAkC;AACjE,aAAW,OAAO,CAAC,SAAS,iBAAiB,aAAa,mBAAmB,iBAAiB,gBAAgB,eAAe,iBAAiB,GAAG;AAC7I,gBAAY,KAAK,GAAG;AAAA,EACxB;AACA,MAAI,eAAe,iBAAiB,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,GAAU;AAC7G,MAAI,gBAAgB,iBAAiB,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,GAAU;AACjH,MAAI,gBAAgB,iBAAiB,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,GAAU;AACjH,MAAI,eAAe,iBAAiB,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,GAAU;AAC7G,MAAI,UAAU,eAAe,IAAI,QAAQ,CAAC,GAAG,IAAI,QAAQ,CAAC,GAAG,GAAU;AAC3E;"}
+{"version":3,"file":"std-tracking-4SHTntWt.js","sources":["../src/material/tracking/std-tracking.ts"],"sourcesContent":["/** Standard material auto-dirty tracking. Dynamically imported by enableMaterialTracking(). */\n\nimport type { StandardMaterialProps } from \"../standard/standard-material.js\";\nimport { trackScalar, observableColor3, observableVec2 } from \"./tracking-primitives.js\";\n\nexport function installStdTracking(mat: StandardMaterialProps): void {\n    for (const key of [\"alpha\", \"specularPower\", \"bumpLevel\", \"ambientTexLevel\", \"lightmapLevel\", \"opacityLevel\", \"alphaCutOff\", \"reflectionLevel\"]) {\n        trackScalar(mat, key);\n    }\n    mat.diffuseColor = observableColor3(mat.diffuseColor[0], mat.diffuseColor[1], mat.diffuseColor[2], mat as any);\n    mat.specularColor = observableColor3(mat.specularColor[0], mat.specularColor[1], mat.specularColor[2], mat as any);\n    mat.emissiveColor = observableColor3(mat.emissiveColor[0], mat.emissiveColor[1], mat.emissiveColor[2], mat as any);\n    mat.ambientColor = observableColor3(mat.ambientColor[0], mat.ambientColor[1], mat.ambientColor[2], mat as any);\n    mat.uvScale = observableVec2(mat.uvScale[0], mat.uvScale[1], mat as any);\n}\n"],"names":[],"mappings":";AAKO,SAAS,mBAAmB,KAAkC;AACjE,aAAW,OAAO,CAAC,SAAS,iBAAiB,aAAa,mBAAmB,iBAAiB,gBAAgB,eAAe,iBAAiB,GAAG;AAC7I,gBAAY,KAAK,GAAG;AAAA,EACxB;AACA,MAAI,eAAe,iBAAiB,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,GAAU;AAC7G,MAAI,gBAAgB,iBAAiB,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,GAAU;AACjH,MAAI,gBAAgB,iBAAiB,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,GAAU;AACjH,MAAI,eAAe,iBAAiB,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,IAAI,aAAa,CAAC,GAAG,GAAU;AAC7G,MAAI,UAAU,eAAe,IAAI,QAAQ,CAAC,GAAG,IAAI,QAAQ,CAAC,GAAG,GAAU;AAC3E;"}

package/{subsurface-fragment-BNQoG9gr.js → subsurface-fragment-D7QRWN_d.js}

@@ -1,4 +1,4 @@
-import { b1 as PBR_HAS_THICKNESS_MAP, b2 as PBR_HAS_SUBSURFACE, b3 as PBR2_HAS_THICKNESS_GLTF_CHANNEL } from "./index-BgY3QEzL.js";
+import { bc as PBR_HAS_THICKNESS_MAP, bd as PBR_HAS_SUBSURFACE, be as PBR2_HAS_THICKNESS_GLTF_CHANNEL } from "./index-C2sM8ERH.js";
 const SS_HELPERS = `
 fn transmittanceBRDF_Burley(tintColor: vec3<f32>, diffusionDistance: vec3<f32>, thickness: f32) -> vec3<f32> {
 let S = 1.0 / max(vec3<f32>(0.000001), diffusionDistance);
@@ -155,4 +155,4 @@ export {
   pbrExt,
   writeSubsurfaceUBO
 };
-//# sourceMappingURL=subsurface-fragment-BNQoG9gr.js.map
+//# sourceMappingURL=subsurface-fragment-D7QRWN_d.js.map

package/{subsurface-fragment-BNQoG9gr.js.map → subsurface-fragment-D7QRWN_d.js.map}

@@ -1 +1 @@
-{"version":3,"file":"subsurface-fragment-BNQoG9gr.js","sources":["../src/material/pbr/fragments/subsurface-fragment.ts"],"sourcesContent":["/**\n * Subsurface Fragment\n *\n * Adds translucency — light passing through thin surfaces.\n * Only bundled when a scene uses PbrMaterialProps.subsurface.\n *\n * Math follows BJS PBRSubSurfaceConfiguration:\n *  - Burley transmittance BRDF: exp-based approximation\n *  - Thickness from texture (.g channel, BJS glTF-style default)\n *  - Direct: wrap-around diffuse scaled by transmittance\n *  - IBL: irradiance reduced by (1 - intensity), transmittance-weighted contribution added\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps, SubSurfaceProps } from \"../pbr-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR_HAS_SUBSURFACE, PBR_HAS_THICKNESS_MAP, PBR2_HAS_THICKNESS_GLTF_CHANNEL } from \"../pbr-flag-bits.js\";\n\nconst SS_HELPERS = `\nfn transmittanceBRDF_Burley(tintColor: vec3<f32>, diffusionDistance: vec3<f32>, thickness: f32) -> vec3<f32> {\nlet S = 1.0 / max(vec3<f32>(0.000001), diffusionDistance);\nlet temp = exp((-0.333333333 * thickness) * S);\nreturn tintColor * 0.25 * (temp * temp * temp + 3.0 * temp);\n}\nfn computeWrappedDiffuseNdotL(NdotL: f32, w: f32) -> f32 {\nlet t = 1.0 + w;\nlet invt2 = 1.0 / (t * t);\nreturn saturate((NdotL + w) * invt2);\n}\n`;\n\n// SV: declare subsurface scope variables\nconst SS_SCOPE_VARS = `var translucencyDirect = vec3<f32>(0.0);\nvar ssTransmittance = vec3<f32>(0.0);\nvar ssIntensity = 0.0;`;\n\n// AT: sample thickness + compute transmittance.\n// Channel: R by default (matches existing non-glTF path); G when the glTF\n// KHR_materials_volume flag is on (spec mandates G channel).\nfunction makeThicknessBlock(hasThicknessMap: boolean, useGltfChannel: boolean): string {\n    const chan = useGltfChannel ? \"g\" : \"r\";\n    const texSample = hasThicknessMap ? `let thicknessSample = textureSample(thicknessTexture_, thicknessSampler_, input.uv).${chan};` : `let thicknessSample = 1.0;`;\n    return `${texSample}\nlet ssThickness = max(material.subsurfaceParams.y + thicknessSample * material.subsurfaceParams.z, 0.000001);\nlet ssTranslucencyColor = material.subsurfaceParams3.rgb;\nlet ssDiffDist = material.subsurfaceParams2.rgb;\nssIntensity = material.subsurfaceParams.x;\nssTransmittance = transmittanceBRDF_Burley(ssTranslucencyColor, ssDiffDist, ssThickness) * ssIntensity;`;\n}\n\n// AD: direct-light translucency lobe (back-facing only, wrap 0.02, 1/PI diffuse BRDF).\n// BJS also scales the front-facing direct diffuse by (1 - ssIntensity); we cannot easily\n// modify `directDiffuse` at compute time, so compensate via `color -= directDiffuse * ssIntensity`\n// in the AI/NI slot below.\nconst SS_DIRECT = `{\nlet NdotLU = dot(N, L);\nif (NdotLU < 0.0) {\nlet wrapNdotL = computeWrappedDiffuseNdotL(abs(NdotLU), 0.02);\ntranslucencyDirect += (1.0 / PI) * wrapNdotL * ssTransmittance * lightAtten * lightColor * material.directIntensity;\n}\n}`;\n\n// AI: subsurface IBL modification (runs after IBL sets `color`).\n// BJS: finalIrradiance *= (1 - ssI);  finalIrradiance += refractionIrradiance;\n// where refractionIrradiance = environmentIrradiance(-N) * transmittance (no albedo by default).\n// AO/occlusion applies to the full finalIrradiance in BJS.\n// Also: scale direct diffuse by (1-ssI) and add translucencyDirect lobe.\nconst SS_IBL_MOD = `{\nlet N_back = -N_env;\nlet envIrrBack = (scene.vSphericalL00.rgb\n  + scene.vSphericalL1_1.rgb * N_back.y + scene.vSphericalL10.rgb * N_back.z + scene.vSphericalL11.rgb * N_back.x\n  + scene.vSphericalL2_2.rgb * (N_back.y * N_back.x) + scene.vSphericalL2_1.rgb * (N_back.y * N_back.z)\n  + scene.vSphericalL20.rgb * (3.0 * N_back.z * N_back.z - 1.0) + scene.vSphericalL21.rgb * (N_back.z * N_back.x)\n  + scene.vSphericalL22.rgb * (N_back.x * N_back.x - N_back.y * N_back.y)) * material.environmentIntensity;\nlet refractionIrradiance = envIrrBack * ssTransmittance;\ncolor -= finalIrradiance * ssIntensity;\ncolor += refractionIrradiance * occlusion;\ncolor -= directDiffuse * ssIntensity;\ncolor += translucencyDirect * occlusion;\n}`;\n\n// NI: no-IBL path — just scale direct diffuse and add translucency lobe.\nconst SS_NO_IBL_MOD = `color -= directDiffuse * ssIntensity;\ncolor += translucencyDirect;`;\n\nconst STAGE_FRAGMENT = 0x2;\n\n/**\n * Create a subsurface translucency fragment.\n * @param hasThicknessMap - Whether the material has a thickness texture.\n * @param hasIbl - Whether the scene has IBL.\n * @param useGltfThicknessChannel - Sample the thickness texture's G channel\n *        (KHR_materials_volume) instead of R (BJS default).\n */\nexport function createSubsurfaceFragment(hasThicknessMap: boolean, hasIbl: boolean, useGltfThicknessChannel: boolean): ShaderFragment {\n    const bindings = hasThicknessMap\n        ? [\n              { _name: \"thicknessTexture_\", _type: { _kind: \"texture\" as const, _textureType: \"texture_2d<f32>\" as const }, _visibility: STAGE_FRAGMENT },\n              { _name: \"thicknessSampler_\", _type: { _kind: \"sampler\" as const, _samplerType: \"sampler\" as const }, _visibility: STAGE_FRAGMENT },\n          ]\n        : [];\n\n    const slots: Partial<Record<string, string>> = {\n        SV: SS_SCOPE_VARS,\n        AT: makeThicknessBlock(hasThicknessMap, useGltfThicknessChannel),\n        AD: SS_DIRECT,\n    };\n    if (hasIbl) {\n        slots.AI = SS_IBL_MOD;\n    } else {\n        slots.NI = SS_NO_IBL_MOD;\n    }\n\n    const deps: string[] = [];\n    if (hasIbl) {\n        deps.push(\"ibl\");\n    }\n\n    return {\n        _id: \"subsurface\",\n        _dependencies: deps.length > 0 ? deps : undefined,\n        _bindings: bindings.length > 0 ? bindings : undefined,\n        _uboFields: [\n            { _name: \"subsurfaceParams\", _type: \"vec4<f32>\" as const },\n            { _name: \"subsurfaceParams2\", _type: \"vec4<f32>\" as const },\n            { _name: \"subsurfaceParams3\", _type: \"vec4<f32>\" as const },\n        ],\n        _helperFunctions: SS_HELPERS,\n        _fragmentSlots: slots,\n    };\n}\n\n/** Write subsurface UBO data. Called from pbr-renderable.ts only when subsurface is active. */\nexport function writeSubsurfaceUBO(data: Float32Array, ss: SubSurfaceProps, offsets: ReadonlyMap<string, number>): void {\n    const trans = ss.translucency!;\n    const thick = ss.thickness;\n\n    const off = offsets.get(\"subsurfaceParams\")! / 4;\n    data[off] = trans.intensity ?? 1.0;\n    const minThick = thick?.min ?? 0;\n    const maxThick = thick?.max ?? 1.0;\n    data[off + 1] = minThick;\n    data[off + 2] = maxThick - minThick;\n\n    const off2 = offsets.get(\"subsurfaceParams2\")! / 4;\n    const dd = trans.diffusionDistance ?? [1, 1, 1];\n    data[off2] = dd[0]!;\n    data[off2 + 1] = dd[1]!;\n    data[off2 + 2] = dd[2]!;\n\n    const off3 = offsets.get(\"subsurfaceParams3\")! / 4;\n    const tc = trans.color ?? [1, 1, 1];\n    data[off3] = tc[0]!;\n    data[off3 + 1] = tc[1]!;\n    data[off3 + 2] = tc[2]!;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"subsurface\",\n    phase: \"fragment\",\n    detect(mat) {\n        const m = mat as PbrMaterialProps;\n        if (!m.subsurface?.translucency) {\n            return { f: 0, f2: 0 };\n        }\n        let f = PBR_HAS_SUBSURFACE;\n        let f2 = 0;\n        if (m.subsurface.thickness?.texture) {\n            f |= PBR_HAS_THICKNESS_MAP;\n        }\n        if (m.subsurface.thickness?.useGlTFChannel) {\n            f2 |= PBR2_HAS_THICKNESS_GLTF_CHANNEL;\n        }\n        return { f, f2 };\n    },\n    frag(ctx) {\n        if (!(ctx._features & PBR_HAS_SUBSURFACE)) {\n            return null;\n        }\n        return createSubsurfaceFragment((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0, ctx._hasIbl, (ctx._features2 & PBR2_HAS_THICKNESS_GLTF_CHANNEL) !== 0);\n    },\n    writeUbo(data, mat, offsets) {\n        const m = mat as PbrMaterialProps;\n        if (m.subsurface?.translucency && offsets.has(\"subsurfaceParams\")) {\n            writeSubsurfaceUBO(data, m.subsurface as SubSurfaceProps, offsets);\n        }\n    },\n    bind(ctx, entries, b) {\n        if ((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0) {\n            const tex = (ctx._material as PbrMaterialProps).subsurface?.thickness?.texture as Texture2D | undefined;\n            if (tex) {\n                entries.push({ binding: b++, resource: tex.view });\n                entries.push({ binding: b++, resource: tex.sampler });\n            }\n        }\n        return b;\n    },\n    textures(mat, out) {\n        const t = (mat as PbrMaterialProps).subsurface?.thickness?.texture;\n        if (t) {\n            out.push(t);\n        }\n    },\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"subsurface-fragment-D7QRWN_d.js","sources":["../src/material/pbr/fragments/subsurface-fragment.ts"],"sourcesContent":["/**\n * Subsurface Fragment\n *\n * Adds translucency — light passing through thin surfaces.\n * Only bundled when a scene uses PbrMaterialProps.subsurface.\n *\n * Math follows BJS PBRSubSurfaceConfiguration:\n *  - Burley transmittance BRDF: exp-based approximation\n *  - Thickness from texture (.g channel, BJS glTF-style default)\n *  - Direct: wrap-around diffuse scaled by transmittance\n *  - IBL: irradiance reduced by (1 - intensity), transmittance-weighted contribution added\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps, SubSurfaceProps } from \"../pbr-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR_HAS_SUBSURFACE, PBR_HAS_THICKNESS_MAP, PBR2_HAS_THICKNESS_GLTF_CHANNEL } from \"../pbr-flag-bits.js\";\n\nconst SS_HELPERS = `\nfn transmittanceBRDF_Burley(tintColor: vec3<f32>, diffusionDistance: vec3<f32>, thickness: f32) -> vec3<f32> {\nlet S = 1.0 / max(vec3<f32>(0.000001), diffusionDistance);\nlet temp = exp((-0.333333333 * thickness) * S);\nreturn tintColor * 0.25 * (temp * temp * temp + 3.0 * temp);\n}\nfn computeWrappedDiffuseNdotL(NdotL: f32, w: f32) -> f32 {\nlet t = 1.0 + w;\nlet invt2 = 1.0 / (t * t);\nreturn saturate((NdotL + w) * invt2);\n}\n`;\n\n// SV: declare subsurface scope variables\nconst SS_SCOPE_VARS = `var translucencyDirect = vec3<f32>(0.0);\nvar ssTransmittance = vec3<f32>(0.0);\nvar ssIntensity = 0.0;`;\n\n// AT: sample thickness + compute transmittance.\n// Channel: R by default (matches existing non-glTF path); G when the glTF\n// KHR_materials_volume flag is on (spec mandates G channel).\nfunction makeThicknessBlock(hasThicknessMap: boolean, useGltfChannel: boolean): string {\n    const chan = useGltfChannel ? \"g\" : \"r\";\n    const texSample = hasThicknessMap ? `let thicknessSample = textureSample(thicknessTexture_, thicknessSampler_, input.uv).${chan};` : `let thicknessSample = 1.0;`;\n    return `${texSample}\nlet ssThickness = max(material.subsurfaceParams.y + thicknessSample * material.subsurfaceParams.z, 0.000001);\nlet ssTranslucencyColor = material.subsurfaceParams3.rgb;\nlet ssDiffDist = material.subsurfaceParams2.rgb;\nssIntensity = material.subsurfaceParams.x;\nssTransmittance = transmittanceBRDF_Burley(ssTranslucencyColor, ssDiffDist, ssThickness) * ssIntensity;`;\n}\n\n// AD: direct-light translucency lobe (back-facing only, wrap 0.02, 1/PI diffuse BRDF).\n// BJS also scales the front-facing direct diffuse by (1 - ssIntensity); we cannot easily\n// modify `directDiffuse` at compute time, so compensate via `color -= directDiffuse * ssIntensity`\n// in the AI/NI slot below.\nconst SS_DIRECT = `{\nlet NdotLU = dot(N, L);\nif (NdotLU < 0.0) {\nlet wrapNdotL = computeWrappedDiffuseNdotL(abs(NdotLU), 0.02);\ntranslucencyDirect += (1.0 / PI) * wrapNdotL * ssTransmittance * lightAtten * lightColor * material.directIntensity;\n}\n}`;\n\n// AI: subsurface IBL modification (runs after IBL sets `color`).\n// BJS: finalIrradiance *= (1 - ssI);  finalIrradiance += refractionIrradiance;\n// where refractionIrradiance = environmentIrradiance(-N) * transmittance (no albedo by default).\n// AO/occlusion applies to the full finalIrradiance in BJS.\n// Also: scale direct diffuse by (1-ssI) and add translucencyDirect lobe.\nconst SS_IBL_MOD = `{\nlet N_back = -N_env;\nlet envIrrBack = (scene.vSphericalL00.rgb\n  + scene.vSphericalL1_1.rgb * N_back.y + scene.vSphericalL10.rgb * N_back.z + scene.vSphericalL11.rgb * N_back.x\n  + scene.vSphericalL2_2.rgb * (N_back.y * N_back.x) + scene.vSphericalL2_1.rgb * (N_back.y * N_back.z)\n  + scene.vSphericalL20.rgb * (3.0 * N_back.z * N_back.z - 1.0) + scene.vSphericalL21.rgb * (N_back.z * N_back.x)\n  + scene.vSphericalL22.rgb * (N_back.x * N_back.x - N_back.y * N_back.y)) * material.environmentIntensity;\nlet refractionIrradiance = envIrrBack * ssTransmittance;\ncolor -= finalIrradiance * ssIntensity;\ncolor += refractionIrradiance * occlusion;\ncolor -= directDiffuse * ssIntensity;\ncolor += translucencyDirect * occlusion;\n}`;\n\n// NI: no-IBL path — just scale direct diffuse and add translucency lobe.\nconst SS_NO_IBL_MOD = `color -= directDiffuse * ssIntensity;\ncolor += translucencyDirect;`;\n\nconst STAGE_FRAGMENT = 0x2;\n\n/**\n * Create a subsurface translucency fragment.\n * @param hasThicknessMap - Whether the material has a thickness texture.\n * @param hasIbl - Whether the scene has IBL.\n * @param useGltfThicknessChannel - Sample the thickness texture's G channel\n *        (KHR_materials_volume) instead of R (BJS default).\n */\nexport function createSubsurfaceFragment(hasThicknessMap: boolean, hasIbl: boolean, useGltfThicknessChannel: boolean): ShaderFragment {\n    const bindings = hasThicknessMap\n        ? [\n              { _name: \"thicknessTexture_\", _type: { _kind: \"texture\" as const, _textureType: \"texture_2d<f32>\" as const }, _visibility: STAGE_FRAGMENT },\n              { _name: \"thicknessSampler_\", _type: { _kind: \"sampler\" as const, _samplerType: \"sampler\" as const }, _visibility: STAGE_FRAGMENT },\n          ]\n        : [];\n\n    const slots: Partial<Record<string, string>> = {\n        SV: SS_SCOPE_VARS,\n        AT: makeThicknessBlock(hasThicknessMap, useGltfThicknessChannel),\n        AD: SS_DIRECT,\n    };\n    if (hasIbl) {\n        slots.AI = SS_IBL_MOD;\n    } else {\n        slots.NI = SS_NO_IBL_MOD;\n    }\n\n    const deps: string[] = [];\n    if (hasIbl) {\n        deps.push(\"ibl\");\n    }\n\n    return {\n        _id: \"subsurface\",\n        _dependencies: deps.length > 0 ? deps : undefined,\n        _bindings: bindings.length > 0 ? bindings : undefined,\n        _uboFields: [\n            { _name: \"subsurfaceParams\", _type: \"vec4<f32>\" as const },\n            { _name: \"subsurfaceParams2\", _type: \"vec4<f32>\" as const },\n            { _name: \"subsurfaceParams3\", _type: \"vec4<f32>\" as const },\n        ],\n        _helperFunctions: SS_HELPERS,\n        _fragmentSlots: slots,\n    };\n}\n\n/** Write subsurface UBO data. Called from pbr-renderable.ts only when subsurface is active. */\nexport function writeSubsurfaceUBO(data: Float32Array, ss: SubSurfaceProps, offsets: ReadonlyMap<string, number>): void {\n    const trans = ss.translucency!;\n    const thick = ss.thickness;\n\n    const off = offsets.get(\"subsurfaceParams\")! / 4;\n    data[off] = trans.intensity ?? 1.0;\n    const minThick = thick?.min ?? 0;\n    const maxThick = thick?.max ?? 1.0;\n    data[off + 1] = minThick;\n    data[off + 2] = maxThick - minThick;\n\n    const off2 = offsets.get(\"subsurfaceParams2\")! / 4;\n    const dd = trans.diffusionDistance ?? [1, 1, 1];\n    data[off2] = dd[0]!;\n    data[off2 + 1] = dd[1]!;\n    data[off2 + 2] = dd[2]!;\n\n    const off3 = offsets.get(\"subsurfaceParams3\")! / 4;\n    const tc = trans.color ?? [1, 1, 1];\n    data[off3] = tc[0]!;\n    data[off3 + 1] = tc[1]!;\n    data[off3 + 2] = tc[2]!;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"subsurface\",\n    phase: \"fragment\",\n    detect(mat) {\n        const m = mat as PbrMaterialProps;\n        if (!m.subsurface?.translucency) {\n            return { f: 0, f2: 0 };\n        }\n        let f = PBR_HAS_SUBSURFACE;\n        let f2 = 0;\n        if (m.subsurface.thickness?.texture) {\n            f |= PBR_HAS_THICKNESS_MAP;\n        }\n        if (m.subsurface.thickness?.useGlTFChannel) {\n            f2 |= PBR2_HAS_THICKNESS_GLTF_CHANNEL;\n        }\n        return { f, f2 };\n    },\n    frag(ctx) {\n        if (!(ctx._features & PBR_HAS_SUBSURFACE)) {\n            return null;\n        }\n        return createSubsurfaceFragment((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0, ctx._hasIbl, (ctx._features2 & PBR2_HAS_THICKNESS_GLTF_CHANNEL) !== 0);\n    },\n    writeUbo(data, mat, offsets) {\n        const m = mat as PbrMaterialProps;\n        if (m.subsurface?.translucency && offsets.has(\"subsurfaceParams\")) {\n            writeSubsurfaceUBO(data, m.subsurface as SubSurfaceProps, offsets);\n        }\n    },\n    bind(ctx, entries, b) {\n        if ((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0) {\n            const tex = (ctx._material as PbrMaterialProps).subsurface?.thickness?.texture as Texture2D | undefined;\n            if (tex) {\n                entries.push({ binding: b++, resource: tex.view });\n                entries.push({ binding: b++, resource: tex.sampler });\n            }\n        }\n        return b;\n    },\n    textures(mat, out) {\n        const t = (mat as PbrMaterialProps).subsurface?.thickness?.texture;\n        if (t) {\n            out.push(t);\n        }\n    },\n};\n"],"names":[],"mappings":"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"}

package/{thin-instance-cull-binding-BNC5JiGw.js → thin-instance-cull-binding-D-p2Yxfg.js}

@@ -1,5 +1,5 @@
-import { B as BU, bS as getViewProjectionMatrix, U as U32, a as F32 } from "./index-BgY3QEzL.js";
-import { syncThinInstanceGpuData } from "./thin-instance-gpu-C1DGstap.js";
+import { B as BU, aR as getViewProjectionMatrix, U as U32, a as F32 } from "./index-C2sM8ERH.js";
+import { syncThinInstanceGpuData } from "./thin-instance-gpu-QETC_NyQ.js";
 const WORKGROUP_SIZE = 64;
 const PARAM_BYTES = 192;
 const COUNT_U32_OFFSET = 44;
@@ -307,4 +307,4 @@ function tryBind(renderable, scene, mesh, engine, hasColor, excluded, baseUpdate
 export {
   tryBind
 };
-//# sourceMappingURL=thin-instance-cull-binding-BNC5JiGw.js.map
+//# sourceMappingURL=thin-instance-cull-binding-D-p2Yxfg.js.map

package/{thin-instance-cull-binding-BNC5JiGw.js.map → thin-instance-cull-binding-D-p2Yxfg.js.map}

@@ -1 +1 @@
-{"version":3,"file":"thin-instance-cull-binding-BNC5JiGw.js","sources":["../src/mesh/thin-instance-gpu-culling.ts","../src/mesh/thin-instance-cull-binding.ts"],"sourcesContent":["/** GPU frustum culling for opt-in thin instances.\n *\n * Dynamically imported only when a scene enables thin-instance GPU culling.\n * Each render binding owns its own state so render tasks with different cameras\n * never clobber one another's compacted instance buffers or indirect args.\n */\n\nimport { F32, U32 } from \"../engine/typed-arrays.js\";\nimport { BU } from \"../engine/gpu-flags.js\";\nimport type { Camera } from \"../camera/camera.js\";\nimport { getViewProjectionMatrix } from \"../camera/camera.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { DrawUpdateContext } from \"../render/renderable.js\";\nimport type { Mat4 } from \"../math/types.js\";\nimport type { Mesh, MeshGPU } from \"./mesh.js\";\nimport type { ThinInstanceData } from \"./thin-instance.js\";\nimport { syncThinInstanceGpuData } from \"./thin-instance-gpu.js\";\nimport type { ThinInstanceDrawBuffers } from \"./thin-instance-gpu.js\";\n\nconst WORKGROUP_SIZE = 64;\nconst PARAM_BYTES = 192;\nconst COUNT_U32_OFFSET = 44;\nconst MESH_WORLD_FLOAT_OFFSET = 24;\nconst LOCAL_SPHERE_FLOAT_OFFSET = 40;\nconst INDIRECT_ARGS_BYTES = 20;\n\nconst CULL_WGSL_NO_COLOR = /* wgsl */ `\nstruct CullParams{planes:array<vec4<f32>,6>,meshWorld:mat4x4<f32>,localSphere:vec4<f32>,count:u32};\n@group(0)@binding(0)var<storage,read> srcMatrices:array<mat4x4<f32>>;\n@group(0)@binding(1)var<storage,read_write> dstMatrices:array<mat4x4<f32>>;\n@group(0)@binding(2)var<storage,read_write> args:array<atomic<u32>>;\n@group(0)@binding(3)var<uniform> params:CullParams;\nfn visible(world:mat4x4<f32>)->bool{\nlet center=(world*vec4<f32>(params.localSphere.xyz,1.0)).xyz;\nlet sx=length(world[0].xyz);\nlet sy=length(world[1].xyz);\nlet sz=length(world[2].xyz);\nlet radius=params.localSphere.w*max(max(sx,sy),sz)+0.0001;\nfor(var i=0u;i<6u;i++){\nlet p=params.planes[i];\nif(dot(p.xyz,center)+p.w < -radius){return false;}\n}\nreturn true;\n}\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid:vec3<u32>){\nlet i=gid.x;\nif(i>=params.count){return;}\nlet world=params.meshWorld*srcMatrices[i];\nif(!visible(world)){return;}\nlet outIndex=atomicAdd(&args[1],1u);\ndstMatrices[outIndex]=srcMatrices[i];\n}`;\n\nconst CULL_WGSL_COLOR = `${CULL_WGSL_NO_COLOR}\n@group(0)@binding(4)var<storage,read> srcColors:array<vec4<f32>>;\n@group(0)@binding(5)var<storage,read_write> dstColors:array<vec4<f32>>;\n@compute @workgroup_size(64)\nfn mainColor(@builtin(global_invocation_id) gid:vec3<u32>){\nlet i=gid.x;\nif(i>=params.count){return;}\nlet world=params.meshWorld*srcMatrices[i];\nif(!visible(world)){return;}\nlet outIndex=atomicAdd(&args[1],1u);\ndstMatrices[outIndex]=srcMatrices[i];\ndstColors[outIndex]=srcColors[i];\n}`;\n\n/** Per-render-binding GPU culling state. */\nexport interface ThinInstanceGpuCullState {\n    /** @internal */\n    _capacity: number;\n    /** @internal */\n    _visibleMatrixBuffer: GPUBuffer | null;\n    /** @internal */\n    _visibleColorBuffer: GPUBuffer | null;\n    /** @internal */\n    _argsBuffer: GPUBuffer | null;\n    /** @internal */\n    _paramsBuffer: GPUBuffer | null;\n    /** @internal */\n    _bindGroup: GPUBindGroup | null;\n    /** @internal */\n    _srcMatrixBuffer: GPUBuffer | null;\n    /** @internal */\n    _srcColorBuffer: GPUBuffer | null;\n    /** @internal */\n    _hasColor: boolean;\n    /** @internal */\n    _localSphereReady: boolean;\n    /** @internal */\n    _localSphere: Float32Array;\n    /** @internal */\n    _paramsBytes: ArrayBuffer;\n    /** @internal */\n    _paramsF32: Float32Array;\n    /** @internal */\n    _paramsU32: Uint32Array;\n    /** @internal */\n    _argsData: Uint32Array;\n    /** @internal */\n    _drawBuffers: ThinInstanceDrawBuffers | null;\n}\n\n/** Result consumed by a material draw closure after culling has run for the active pass. */\nexport interface ThinInstanceGpuCullResult {\n    readonly drawBuffers: ThinInstanceDrawBuffers;\n    readonly argsBuffer: GPUBuffer;\n}\n\nlet _cachedDevice: GPUDevice | null = null;\nlet _pipelineNoColor: GPUComputePipeline | null = null;\nlet _pipelineColor: GPUComputePipeline | null = null;\n\n/** Create per-binding culling state. */\nexport function createTiCullState(): ThinInstanceGpuCullState {\n    const paramsBytes = new ArrayBuffer(PARAM_BYTES);\n    return {\n        _capacity: 0,\n        _visibleMatrixBuffer: null,\n        _visibleColorBuffer: null,\n        _argsBuffer: null,\n        _paramsBuffer: null,\n        _bindGroup: null,\n        _srcMatrixBuffer: null,\n        _srcColorBuffer: null,\n        _hasColor: false,\n        _localSphereReady: false,\n        _localSphere: new F32(4),\n        _paramsBytes: paramsBytes,\n        _paramsF32: new F32(paramsBytes),\n        _paramsU32: new U32(paramsBytes),\n        _argsData: new U32(5),\n        _drawBuffers: null,\n    };\n}\n\n/** Destroy GPU resources owned by a per-binding cull state. */\nexport function destroyTiCullState(state: ThinInstanceGpuCullState): void {\n    state._visibleMatrixBuffer?.destroy();\n    state._visibleColorBuffer?.destroy();\n    state._argsBuffer?.destroy();\n    state._paramsBuffer?.destroy();\n    state._visibleMatrixBuffer = null;\n    state._visibleColorBuffer = null;\n    state._argsBuffer = null;\n    state._paramsBuffer = null;\n    state._bindGroup = null;\n    state._drawBuffers = null;\n}\n\n/** Run culling for one render binding and return buffers for the subsequent indirect draw. */\nexport function prepareTiCull(\n    engine: EngineContext,\n    state: ThinInstanceGpuCullState,\n    mesh: Mesh,\n    gpu: MeshGPU,\n    ti: ThinInstanceData,\n    hasColor: boolean,\n    context: DrawUpdateContext\n): ThinInstanceGpuCullResult | null {\n    const camera = context._camera;\n    if (!ti._gpuCullingEnabled || !camera || mesh.visible === false || ti.count === 0) {\n        state._drawBuffers = null;\n        return null;\n    }\n    if (hasColor && !ti.colors) {\n        state._drawBuffers = null;\n        return null;\n    }\n    if (!state._localSphereReady && !computeLocalSphere(mesh as Mesh, state._localSphere)) {\n        state._drawBuffers = null;\n        return null;\n    }\n    state._localSphereReady = true;\n\n    syncThinInstanceGpuData(engine, ti, hasColor);\n    const sourceMatrixBuffer = ti._gpuBuffer;\n    const sourceColorBuffer = hasColor ? ti._colorGpuBuffer : null;\n    if (!sourceMatrixBuffer || (hasColor && !sourceColorBuffer)) {\n        state._drawBuffers = null;\n        return null;\n    }\n\n    ensureCullBuffers(engine, state, ti._capacity, hasColor);\n    const visibleMatrixBuffer = state._visibleMatrixBuffer!;\n    const visibleColorBuffer = hasColor ? state._visibleColorBuffer! : null;\n    const argsBuffer = state._argsBuffer!;\n    const paramsBuffer = state._paramsBuffer!;\n    const pipeline = getCullPipeline(engine, hasColor);\n\n    if (state._bindGroup === null || state._srcMatrixBuffer !== sourceMatrixBuffer || state._srcColorBuffer !== sourceColorBuffer || state._hasColor !== hasColor) {\n        const entries: GPUBindGroupEntry[] = [\n            { binding: 0, resource: { buffer: sourceMatrixBuffer } },\n            { binding: 1, resource: { buffer: visibleMatrixBuffer } },\n            { binding: 2, resource: { buffer: argsBuffer } },\n            { binding: 3, resource: { buffer: paramsBuffer } },\n        ];\n        if (hasColor) {\n            entries.push({ binding: 4, resource: { buffer: sourceColorBuffer! } }, { binding: 5, resource: { buffer: visibleColorBuffer! } });\n        }\n        state._bindGroup = engine._device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries });\n        state._srcMatrixBuffer = sourceMatrixBuffer;\n        state._srcColorBuffer = sourceColorBuffer;\n        state._hasColor = hasColor;\n    }\n\n    const v = camera.viewport;\n    const aspect = (context.targetWidth / context.targetHeight) * (v ? v.width / v.height : 1);\n    writeCullParams(engine, state, mesh, gpu.indexCount, ti.count, camera, aspect);\n\n    const pass = engine._currentEncoder.beginComputePass();\n    pass.setPipeline(pipeline);\n    pass.setBindGroup(0, state._bindGroup);\n    pass.dispatchWorkgroups(Math.ceil(ti.count / WORKGROUP_SIZE));\n    pass.end();\n\n    state._drawBuffers = { matrixBuffer: visibleMatrixBuffer, colorBuffer: visibleColorBuffer };\n    return { drawBuffers: state._drawBuffers, argsBuffer };\n}\n\nfunction ensureCullBuffers(engine: EngineContext, state: ThinInstanceGpuCullState, capacity: number, hasColor: boolean): void {\n    const device = engine._device;\n    if (state._capacity < capacity) {\n        state._visibleMatrixBuffer?.destroy();\n        state._visibleColorBuffer?.destroy();\n        state._visibleMatrixBuffer = device.createBuffer({\n            size: Math.max(capacity * 64, 4),\n            usage: BU.VERTEX | BU.STORAGE,\n        });\n        state._visibleColorBuffer = hasColor\n            ? device.createBuffer({\n                  size: Math.max(capacity * 16, 4),\n                  usage: BU.VERTEX | BU.STORAGE,\n              })\n            : null;\n        state._capacity = capacity;\n        state._bindGroup = null;\n        state._drawBuffers = null;\n    } else if (hasColor && !state._visibleColorBuffer) {\n        state._visibleColorBuffer = device.createBuffer({\n            size: Math.max(state._capacity * 16, 4),\n            usage: BU.VERTEX | BU.STORAGE,\n        });\n        state._bindGroup = null;\n        state._drawBuffers = null;\n    }\n    if (!state._argsBuffer) {\n        state._argsBuffer = device.createBuffer({\n            size: INDIRECT_ARGS_BYTES,\n            usage: BU.INDIRECT | BU.STORAGE | BU.COPY_DST,\n        });\n    }\n    if (!state._paramsBuffer) {\n        state._paramsBuffer = device.createBuffer({\n            size: PARAM_BYTES,\n            usage: BU.UNIFORM | BU.COPY_DST,\n        });\n    }\n}\n\nfunction getCullPipeline(engine: EngineContext, hasColor: boolean): GPUComputePipeline {\n    const device = engine._device;\n    if (_cachedDevice !== device) {\n        _cachedDevice = device;\n        _pipelineNoColor = null;\n        _pipelineColor = null;\n    }\n    if (hasColor) {\n        _pipelineColor ??= device.createComputePipeline({\n            layout: \"auto\",\n            compute: { module: device.createShaderModule({ code: CULL_WGSL_COLOR }), entryPoint: \"mainColor\" },\n        });\n        return _pipelineColor;\n    }\n    _pipelineNoColor ??= device.createComputePipeline({\n        layout: \"auto\",\n        compute: { module: device.createShaderModule({ code: CULL_WGSL_NO_COLOR }), entryPoint: \"main\" },\n    });\n    return _pipelineNoColor;\n}\n\nfunction writeCullParams(engine: EngineContext, state: ThinInstanceGpuCullState, mesh: Mesh, indexCount: number, instanceCount: number, camera: Camera, aspect: number): void {\n    const params = state._paramsF32;\n    const viewProjection = getViewProjectionMatrix(camera, aspect);\n    writeFrustumPlanes(params, viewProjection);\n    params.set(mesh.worldMatrix, MESH_WORLD_FLOAT_OFFSET);\n    params.set(state._localSphere, LOCAL_SPHERE_FLOAT_OFFSET);\n    state._paramsU32[COUNT_U32_OFFSET] = instanceCount;\n\n    const args = state._argsData;\n    args[0] = indexCount;\n    args[1] = 0;\n    args[2] = 0;\n    args[3] = 0;\n    args[4] = 0;\n\n    engine._device.queue.writeBuffer(state._argsBuffer!, 0, args.buffer, args.byteOffset, args.byteLength);\n    engine._device.queue.writeBuffer(state._paramsBuffer!, 0, state._paramsBytes);\n}\n\nfunction writeFrustumPlanes(out: Float32Array, m: Mat4): void {\n    writePlane(out, 0, m[3]! + m[0]!, m[7]! + m[4]!, m[11]! + m[8]!, m[15]! + m[12]!);\n    writePlane(out, 4, m[3]! - m[0]!, m[7]! - m[4]!, m[11]! - m[8]!, m[15]! - m[12]!);\n    writePlane(out, 8, m[3]! + m[1]!, m[7]! + m[5]!, m[11]! + m[9]!, m[15]! + m[13]!);\n    writePlane(out, 12, m[3]! - m[1]!, m[7]! - m[5]!, m[11]! - m[9]!, m[15]! - m[13]!);\n    writePlane(out, 16, m[2]!, m[6]!, m[10]!, m[14]!);\n    writePlane(out, 20, m[3]! - m[2]!, m[7]! - m[6]!, m[11]! - m[10]!, m[15]! - m[14]!);\n}\n\nfunction writePlane(out: Float32Array, offset: number, x: number, y: number, z: number, w: number): void {\n    const invLen = 1 / Math.hypot(x, y, z);\n    out[offset] = x * invLen;\n    out[offset + 1] = y * invLen;\n    out[offset + 2] = z * invLen;\n    out[offset + 3] = w * invLen;\n}\n\nfunction computeLocalSphere(mesh: Mesh, out: Float32Array): boolean {\n    const positions = mesh._cpuPositions;\n    if (!positions || positions.length < 3) {\n        return false;\n    }\n    let minX = Infinity,\n        minY = Infinity,\n        minZ = Infinity;\n    let maxX = -Infinity,\n        maxY = -Infinity,\n        maxZ = -Infinity;\n    for (let i = 0; i < positions.length; i += 3) {\n        const x = positions[i]!;\n        const y = positions[i + 1]!;\n        const z = positions[i + 2]!;\n        if (x < minX) {\n            minX = x;\n        }\n        if (x > maxX) {\n            maxX = x;\n        }\n        if (y < minY) {\n            minY = y;\n        }\n        if (y > maxY) {\n            maxY = y;\n        }\n        if (z < minZ) {\n            minZ = z;\n        }\n        if (z > maxZ) {\n            maxZ = z;\n        }\n    }\n    if (!isFinite(minX)) {\n        return false;\n    }\n    const cx = (minX + maxX) * 0.5;\n    const cy = (minY + maxY) * 0.5;\n    const cz = (minZ + maxZ) * 0.5;\n    const dx = maxX - cx;\n    const dy = maxY - cy;\n    const dz = maxZ - cz;\n    out[0] = cx;\n    out[1] = cy;\n    out[2] = cz;\n    out[3] = Math.hypot(dx, dy, dz);\n    return true;\n}\n","/** Shared per-binding GPU frustum-culling lifecycle for thin-instanced renderables.\n *\n *  Dynamically imported only when a scene enables thin-instance GPU culling, and\n *  it statically pulls in the compute-cull module — so non-culling scenes fetch\n *  neither this helper nor `thin-instance-gpu-culling.ts`.\n *\n *  Factored here so Standard, PBR, and ShaderMaterial renderables share one\n *  implementation of the cull lifecycle instead of copy-pasting it three times.\n *  `tryBind` is the single seam a renderable's `bind()` calls: it does the\n *  opaque-only gate + per-mesh `_gpuCullingEnabled` check, marks the renderable\n *  `_direct` (read by the render task's buildBindings right after `bind()`\n *  returns), and creates the per-binding state. The renderable then reads\n *  `cullDrawBufs` for the compacted instance source and calls `binding.draw(...)`\n *  for the indirect-vs-fallback draw call. Keeping these few seams tiny is what\n *  lets non-culling scenes — which still fetch the per-material renderable\n *  chunks — stay within their bundle-size ceilings. */\n\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { SceneContext } from \"../scene/scene.js\";\nimport type { DrawUpdateContext, Renderable } from \"../render/renderable.js\";\nimport type { Mesh } from \"./mesh.js\";\nimport type { ThinInstanceDrawBuffers } from \"./thin-instance-gpu.js\";\nimport { createTiCullState, destroyTiCullState, prepareTiCull } from \"./thin-instance-gpu-culling.js\";\n\n/** Per-binding cull lifecycle. The renderable's `bind()` obtains one from\n *  `tryBind`, uses `update` as the binding's update, reads `cullDrawBufs` (the\n *  compacted instance source) and calls `draw()` for the final draw call. */\nexport interface TiCullBinding {\n    /** Run the binding's base update, then dispatch the compute cull pass and stash the result. */\n    update(context: DrawUpdateContext): void;\n    /** Compacted visible-instance buffers, or null to fall back to a full instanced draw. */\n    cullDrawBufs: ThinInstanceDrawBuffers | null;\n    /** @internal Indirect draw-args buffer (null until/unless culling ran this frame). */\n    _args: GPUBuffer | null;\n    /** Issue the indirect (culled) draw when visible instances were compacted, else a full instanced draw. */\n    draw(pass: GPURenderPassEncoder | GPURenderBundleEncoder, indexCount: number, instanceCount: number): void;\n}\n\n/** Create a per-binding cull lifecycle for one thin-instanced renderable binding,\n *  iff the mesh opts in and is not excluded (transparent / transmissive — v1 is\n *  opaque-only). Marks the renderable `_direct` so it leaves the cached opaque\n *  bundle; this is safe to do during `bind()` because buildBindings reads\n *  `_direct` only after `bind()` returns. Returns undefined when culling does not\n *  apply, so the caller falls back to a normal instanced draw. */\nexport function tryBind(\n    renderable: Renderable,\n    scene: SceneContext,\n    mesh: Mesh,\n    engine: EngineContext,\n    hasColor: boolean,\n    excluded: boolean,\n    baseUpdate: ((context: DrawUpdateContext) => void) | undefined\n): TiCullBinding | undefined {\n    const ti = mesh.thinInstances;\n    if (excluded || !ti?._gpuCullingEnabled) {\n        return undefined;\n    }\n    (renderable as { _direct?: boolean })._direct = true;\n    const state = createTiCullState();\n    scene._meshDisposables.get(mesh)?.push(() => {\n        destroyTiCullState(state);\n    });\n    const binding: TiCullBinding = {\n        cullDrawBufs: null,\n        _args: null,\n        update(context: DrawUpdateContext): void {\n            baseUpdate?.(context);\n            const res = prepareTiCull(engine, state, mesh, mesh._gpu, ti, hasColor, context);\n            binding.cullDrawBufs = res?.drawBuffers ?? null;\n            binding._args = res?.argsBuffer ?? null;\n        },\n        draw(pass: GPURenderPassEncoder | GPURenderBundleEncoder, indexCount: number, instanceCount: number): void {\n            if (binding._args) {\n                pass.drawIndexedIndirect(binding._args, 0);\n            } else {\n                pass.drawIndexed(indexCount, instanceCount);\n            }\n        },\n    };\n    return binding;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"thin-instance-cull-binding-D-p2Yxfg.js","sources":["../src/mesh/thin-instance-gpu-culling.ts","../src/mesh/thin-instance-cull-binding.ts"],"sourcesContent":["/** GPU frustum culling for opt-in thin instances.\n *\n * Dynamically imported only when a scene enables thin-instance GPU culling.\n * Each render binding owns its own state so render tasks with different cameras\n * never clobber one another's compacted instance buffers or indirect args.\n */\n\nimport { F32, U32 } from \"../engine/typed-arrays.js\";\nimport { BU } from \"../engine/gpu-flags.js\";\nimport type { Camera } from \"../camera/camera.js\";\nimport { getViewProjectionMatrix } from \"../camera/camera.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { DrawUpdateContext } from \"../render/renderable.js\";\nimport type { Mat4 } from \"../math/types.js\";\nimport type { Mesh, MeshGPU } from \"./mesh.js\";\nimport type { ThinInstanceData } from \"./thin-instance.js\";\nimport { syncThinInstanceGpuData } from \"./thin-instance-gpu.js\";\nimport type { ThinInstanceDrawBuffers } from \"./thin-instance-gpu.js\";\n\nconst WORKGROUP_SIZE = 64;\nconst PARAM_BYTES = 192;\nconst COUNT_U32_OFFSET = 44;\nconst MESH_WORLD_FLOAT_OFFSET = 24;\nconst LOCAL_SPHERE_FLOAT_OFFSET = 40;\nconst INDIRECT_ARGS_BYTES = 20;\n\nconst CULL_WGSL_NO_COLOR = /* wgsl */ `\nstruct CullParams{planes:array<vec4<f32>,6>,meshWorld:mat4x4<f32>,localSphere:vec4<f32>,count:u32};\n@group(0)@binding(0)var<storage,read> srcMatrices:array<mat4x4<f32>>;\n@group(0)@binding(1)var<storage,read_write> dstMatrices:array<mat4x4<f32>>;\n@group(0)@binding(2)var<storage,read_write> args:array<atomic<u32>>;\n@group(0)@binding(3)var<uniform> params:CullParams;\nfn visible(world:mat4x4<f32>)->bool{\nlet center=(world*vec4<f32>(params.localSphere.xyz,1.0)).xyz;\nlet sx=length(world[0].xyz);\nlet sy=length(world[1].xyz);\nlet sz=length(world[2].xyz);\nlet radius=params.localSphere.w*max(max(sx,sy),sz)+0.0001;\nfor(var i=0u;i<6u;i++){\nlet p=params.planes[i];\nif(dot(p.xyz,center)+p.w < -radius){return false;}\n}\nreturn true;\n}\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid:vec3<u32>){\nlet i=gid.x;\nif(i>=params.count){return;}\nlet world=params.meshWorld*srcMatrices[i];\nif(!visible(world)){return;}\nlet outIndex=atomicAdd(&args[1],1u);\ndstMatrices[outIndex]=srcMatrices[i];\n}`;\n\nconst CULL_WGSL_COLOR = `${CULL_WGSL_NO_COLOR}\n@group(0)@binding(4)var<storage,read> srcColors:array<vec4<f32>>;\n@group(0)@binding(5)var<storage,read_write> dstColors:array<vec4<f32>>;\n@compute @workgroup_size(64)\nfn mainColor(@builtin(global_invocation_id) gid:vec3<u32>){\nlet i=gid.x;\nif(i>=params.count){return;}\nlet world=params.meshWorld*srcMatrices[i];\nif(!visible(world)){return;}\nlet outIndex=atomicAdd(&args[1],1u);\ndstMatrices[outIndex]=srcMatrices[i];\ndstColors[outIndex]=srcColors[i];\n}`;\n\n/** Per-render-binding GPU culling state. */\nexport interface ThinInstanceGpuCullState {\n    /** @internal */\n    _capacity: number;\n    /** @internal */\n    _visibleMatrixBuffer: GPUBuffer | null;\n    /** @internal */\n    _visibleColorBuffer: GPUBuffer | null;\n    /** @internal */\n    _argsBuffer: GPUBuffer | null;\n    /** @internal */\n    _paramsBuffer: GPUBuffer | null;\n    /** @internal */\n    _bindGroup: GPUBindGroup | null;\n    /** @internal */\n    _srcMatrixBuffer: GPUBuffer | null;\n    /** @internal */\n    _srcColorBuffer: GPUBuffer | null;\n    /** @internal */\n    _hasColor: boolean;\n    /** @internal */\n    _localSphereReady: boolean;\n    /** @internal */\n    _localSphere: Float32Array;\n    /** @internal */\n    _paramsBytes: ArrayBuffer;\n    /** @internal */\n    _paramsF32: Float32Array;\n    /** @internal */\n    _paramsU32: Uint32Array;\n    /** @internal */\n    _argsData: Uint32Array;\n    /** @internal */\n    _drawBuffers: ThinInstanceDrawBuffers | null;\n}\n\n/** Result consumed by a material draw closure after culling has run for the active pass. */\nexport interface ThinInstanceGpuCullResult {\n    readonly drawBuffers: ThinInstanceDrawBuffers;\n    readonly argsBuffer: GPUBuffer;\n}\n\nlet _cachedDevice: GPUDevice | null = null;\nlet _pipelineNoColor: GPUComputePipeline | null = null;\nlet _pipelineColor: GPUComputePipeline | null = null;\n\n/** Create per-binding culling state. */\nexport function createTiCullState(): ThinInstanceGpuCullState {\n    const paramsBytes = new ArrayBuffer(PARAM_BYTES);\n    return {\n        _capacity: 0,\n        _visibleMatrixBuffer: null,\n        _visibleColorBuffer: null,\n        _argsBuffer: null,\n        _paramsBuffer: null,\n        _bindGroup: null,\n        _srcMatrixBuffer: null,\n        _srcColorBuffer: null,\n        _hasColor: false,\n        _localSphereReady: false,\n        _localSphere: new F32(4),\n        _paramsBytes: paramsBytes,\n        _paramsF32: new F32(paramsBytes),\n        _paramsU32: new U32(paramsBytes),\n        _argsData: new U32(5),\n        _drawBuffers: null,\n    };\n}\n\n/** Destroy GPU resources owned by a per-binding cull state. */\nexport function destroyTiCullState(state: ThinInstanceGpuCullState): void {\n    state._visibleMatrixBuffer?.destroy();\n    state._visibleColorBuffer?.destroy();\n    state._argsBuffer?.destroy();\n    state._paramsBuffer?.destroy();\n    state._visibleMatrixBuffer = null;\n    state._visibleColorBuffer = null;\n    state._argsBuffer = null;\n    state._paramsBuffer = null;\n    state._bindGroup = null;\n    state._drawBuffers = null;\n}\n\n/** Run culling for one render binding and return buffers for the subsequent indirect draw. */\nexport function prepareTiCull(\n    engine: EngineContext,\n    state: ThinInstanceGpuCullState,\n    mesh: Mesh,\n    gpu: MeshGPU,\n    ti: ThinInstanceData,\n    hasColor: boolean,\n    context: DrawUpdateContext\n): ThinInstanceGpuCullResult | null {\n    const camera = context._camera;\n    if (!ti._gpuCullingEnabled || !camera || mesh.visible === false || ti.count === 0) {\n        state._drawBuffers = null;\n        return null;\n    }\n    if (hasColor && !ti.colors) {\n        state._drawBuffers = null;\n        return null;\n    }\n    if (!state._localSphereReady && !computeLocalSphere(mesh as Mesh, state._localSphere)) {\n        state._drawBuffers = null;\n        return null;\n    }\n    state._localSphereReady = true;\n\n    syncThinInstanceGpuData(engine, ti, hasColor);\n    const sourceMatrixBuffer = ti._gpuBuffer;\n    const sourceColorBuffer = hasColor ? ti._colorGpuBuffer : null;\n    if (!sourceMatrixBuffer || (hasColor && !sourceColorBuffer)) {\n        state._drawBuffers = null;\n        return null;\n    }\n\n    ensureCullBuffers(engine, state, ti._capacity, hasColor);\n    const visibleMatrixBuffer = state._visibleMatrixBuffer!;\n    const visibleColorBuffer = hasColor ? state._visibleColorBuffer! : null;\n    const argsBuffer = state._argsBuffer!;\n    const paramsBuffer = state._paramsBuffer!;\n    const pipeline = getCullPipeline(engine, hasColor);\n\n    if (state._bindGroup === null || state._srcMatrixBuffer !== sourceMatrixBuffer || state._srcColorBuffer !== sourceColorBuffer || state._hasColor !== hasColor) {\n        const entries: GPUBindGroupEntry[] = [\n            { binding: 0, resource: { buffer: sourceMatrixBuffer } },\n            { binding: 1, resource: { buffer: visibleMatrixBuffer } },\n            { binding: 2, resource: { buffer: argsBuffer } },\n            { binding: 3, resource: { buffer: paramsBuffer } },\n        ];\n        if (hasColor) {\n            entries.push({ binding: 4, resource: { buffer: sourceColorBuffer! } }, { binding: 5, resource: { buffer: visibleColorBuffer! } });\n        }\n        state._bindGroup = engine._device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries });\n        state._srcMatrixBuffer = sourceMatrixBuffer;\n        state._srcColorBuffer = sourceColorBuffer;\n        state._hasColor = hasColor;\n    }\n\n    const v = camera.viewport;\n    const aspect = (context.targetWidth / context.targetHeight) * (v ? v.width / v.height : 1);\n    writeCullParams(engine, state, mesh, gpu.indexCount, ti.count, camera, aspect);\n\n    const pass = engine._currentEncoder.beginComputePass();\n    pass.setPipeline(pipeline);\n    pass.setBindGroup(0, state._bindGroup);\n    pass.dispatchWorkgroups(Math.ceil(ti.count / WORKGROUP_SIZE));\n    pass.end();\n\n    state._drawBuffers = { matrixBuffer: visibleMatrixBuffer, colorBuffer: visibleColorBuffer };\n    return { drawBuffers: state._drawBuffers, argsBuffer };\n}\n\nfunction ensureCullBuffers(engine: EngineContext, state: ThinInstanceGpuCullState, capacity: number, hasColor: boolean): void {\n    const device = engine._device;\n    if (state._capacity < capacity) {\n        state._visibleMatrixBuffer?.destroy();\n        state._visibleColorBuffer?.destroy();\n        state._visibleMatrixBuffer = device.createBuffer({\n            size: Math.max(capacity * 64, 4),\n            usage: BU.VERTEX | BU.STORAGE,\n        });\n        state._visibleColorBuffer = hasColor\n            ? device.createBuffer({\n                  size: Math.max(capacity * 16, 4),\n                  usage: BU.VERTEX | BU.STORAGE,\n              })\n            : null;\n        state._capacity = capacity;\n        state._bindGroup = null;\n        state._drawBuffers = null;\n    } else if (hasColor && !state._visibleColorBuffer) {\n        state._visibleColorBuffer = device.createBuffer({\n            size: Math.max(state._capacity * 16, 4),\n            usage: BU.VERTEX | BU.STORAGE,\n        });\n        state._bindGroup = null;\n        state._drawBuffers = null;\n    }\n    if (!state._argsBuffer) {\n        state._argsBuffer = device.createBuffer({\n            size: INDIRECT_ARGS_BYTES,\n            usage: BU.INDIRECT | BU.STORAGE | BU.COPY_DST,\n        });\n    }\n    if (!state._paramsBuffer) {\n        state._paramsBuffer = device.createBuffer({\n            size: PARAM_BYTES,\n            usage: BU.UNIFORM | BU.COPY_DST,\n        });\n    }\n}\n\nfunction getCullPipeline(engine: EngineContext, hasColor: boolean): GPUComputePipeline {\n    const device = engine._device;\n    if (_cachedDevice !== device) {\n        _cachedDevice = device;\n        _pipelineNoColor = null;\n        _pipelineColor = null;\n    }\n    if (hasColor) {\n        _pipelineColor ??= device.createComputePipeline({\n            layout: \"auto\",\n            compute: { module: device.createShaderModule({ code: CULL_WGSL_COLOR }), entryPoint: \"mainColor\" },\n        });\n        return _pipelineColor;\n    }\n    _pipelineNoColor ??= device.createComputePipeline({\n        layout: \"auto\",\n        compute: { module: device.createShaderModule({ code: CULL_WGSL_NO_COLOR }), entryPoint: \"main\" },\n    });\n    return _pipelineNoColor;\n}\n\nfunction writeCullParams(engine: EngineContext, state: ThinInstanceGpuCullState, mesh: Mesh, indexCount: number, instanceCount: number, camera: Camera, aspect: number): void {\n    const params = state._paramsF32;\n    const viewProjection = getViewProjectionMatrix(camera, aspect);\n    writeFrustumPlanes(params, viewProjection);\n    params.set(mesh.worldMatrix, MESH_WORLD_FLOAT_OFFSET);\n    params.set(state._localSphere, LOCAL_SPHERE_FLOAT_OFFSET);\n    state._paramsU32[COUNT_U32_OFFSET] = instanceCount;\n\n    const args = state._argsData;\n    args[0] = indexCount;\n    args[1] = 0;\n    args[2] = 0;\n    args[3] = 0;\n    args[4] = 0;\n\n    engine._device.queue.writeBuffer(state._argsBuffer!, 0, args.buffer, args.byteOffset, args.byteLength);\n    engine._device.queue.writeBuffer(state._paramsBuffer!, 0, state._paramsBytes);\n}\n\nfunction writeFrustumPlanes(out: Float32Array, m: Mat4): void {\n    writePlane(out, 0, m[3]! + m[0]!, m[7]! + m[4]!, m[11]! + m[8]!, m[15]! + m[12]!);\n    writePlane(out, 4, m[3]! - m[0]!, m[7]! - m[4]!, m[11]! - m[8]!, m[15]! - m[12]!);\n    writePlane(out, 8, m[3]! + m[1]!, m[7]! + m[5]!, m[11]! + m[9]!, m[15]! + m[13]!);\n    writePlane(out, 12, m[3]! - m[1]!, m[7]! - m[5]!, m[11]! - m[9]!, m[15]! - m[13]!);\n    writePlane(out, 16, m[2]!, m[6]!, m[10]!, m[14]!);\n    writePlane(out, 20, m[3]! - m[2]!, m[7]! - m[6]!, m[11]! - m[10]!, m[15]! - m[14]!);\n}\n\nfunction writePlane(out: Float32Array, offset: number, x: number, y: number, z: number, w: number): void {\n    const invLen = 1 / Math.hypot(x, y, z);\n    out[offset] = x * invLen;\n    out[offset + 1] = y * invLen;\n    out[offset + 2] = z * invLen;\n    out[offset + 3] = w * invLen;\n}\n\nfunction computeLocalSphere(mesh: Mesh, out: Float32Array): boolean {\n    const positions = mesh._cpuPositions;\n    if (!positions || positions.length < 3) {\n        return false;\n    }\n    let minX = Infinity,\n        minY = Infinity,\n        minZ = Infinity;\n    let maxX = -Infinity,\n        maxY = -Infinity,\n        maxZ = -Infinity;\n    for (let i = 0; i < positions.length; i += 3) {\n        const x = positions[i]!;\n        const y = positions[i + 1]!;\n        const z = positions[i + 2]!;\n        if (x < minX) {\n            minX = x;\n        }\n        if (x > maxX) {\n            maxX = x;\n        }\n        if (y < minY) {\n            minY = y;\n        }\n        if (y > maxY) {\n            maxY = y;\n        }\n        if (z < minZ) {\n            minZ = z;\n        }\n        if (z > maxZ) {\n            maxZ = z;\n        }\n    }\n    if (!isFinite(minX)) {\n        return false;\n    }\n    const cx = (minX + maxX) * 0.5;\n    const cy = (minY + maxY) * 0.5;\n    const cz = (minZ + maxZ) * 0.5;\n    const dx = maxX - cx;\n    const dy = maxY - cy;\n    const dz = maxZ - cz;\n    out[0] = cx;\n    out[1] = cy;\n    out[2] = cz;\n    out[3] = Math.hypot(dx, dy, dz);\n    return true;\n}\n","/** Shared per-binding GPU frustum-culling lifecycle for thin-instanced renderables.\n *\n *  Dynamically imported only when a scene enables thin-instance GPU culling, and\n *  it statically pulls in the compute-cull module — so non-culling scenes fetch\n *  neither this helper nor `thin-instance-gpu-culling.ts`.\n *\n *  Factored here so Standard, PBR, and ShaderMaterial renderables share one\n *  implementation of the cull lifecycle instead of copy-pasting it three times.\n *  `tryBind` is the single seam a renderable's `bind()` calls: it does the\n *  opaque-only gate + per-mesh `_gpuCullingEnabled` check, marks the renderable\n *  `_direct` (read by the render task's buildBindings right after `bind()`\n *  returns), and creates the per-binding state. The renderable then reads\n *  `cullDrawBufs` for the compacted instance source and calls `binding.draw(...)`\n *  for the indirect-vs-fallback draw call. Keeping these few seams tiny is what\n *  lets non-culling scenes — which still fetch the per-material renderable\n *  chunks — stay within their bundle-size ceilings. */\n\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { SceneContext } from \"../scene/scene.js\";\nimport type { DrawUpdateContext, Renderable } from \"../render/renderable.js\";\nimport type { Mesh } from \"./mesh.js\";\nimport type { ThinInstanceDrawBuffers } from \"./thin-instance-gpu.js\";\nimport { createTiCullState, destroyTiCullState, prepareTiCull } from \"./thin-instance-gpu-culling.js\";\n\n/** Per-binding cull lifecycle. The renderable's `bind()` obtains one from\n *  `tryBind`, uses `update` as the binding's update, reads `cullDrawBufs` (the\n *  compacted instance source) and calls `draw()` for the final draw call. */\nexport interface TiCullBinding {\n    /** Run the binding's base update, then dispatch the compute cull pass and stash the result. */\n    update(context: DrawUpdateContext): void;\n    /** Compacted visible-instance buffers, or null to fall back to a full instanced draw. */\n    cullDrawBufs: ThinInstanceDrawBuffers | null;\n    /** @internal Indirect draw-args buffer (null until/unless culling ran this frame). */\n    _args: GPUBuffer | null;\n    /** Issue the indirect (culled) draw when visible instances were compacted, else a full instanced draw. */\n    draw(pass: GPURenderPassEncoder | GPURenderBundleEncoder, indexCount: number, instanceCount: number): void;\n}\n\n/** Create a per-binding cull lifecycle for one thin-instanced renderable binding,\n *  iff the mesh opts in and is not excluded (transparent / transmissive — v1 is\n *  opaque-only). Marks the renderable `_direct` so it leaves the cached opaque\n *  bundle; this is safe to do during `bind()` because buildBindings reads\n *  `_direct` only after `bind()` returns. Returns undefined when culling does not\n *  apply, so the caller falls back to a normal instanced draw. */\nexport function tryBind(\n    renderable: Renderable,\n    scene: SceneContext,\n    mesh: Mesh,\n    engine: EngineContext,\n    hasColor: boolean,\n    excluded: boolean,\n    baseUpdate: ((context: DrawUpdateContext) => void) | undefined\n): TiCullBinding | undefined {\n    const ti = mesh.thinInstances;\n    if (excluded || !ti?._gpuCullingEnabled) {\n        return undefined;\n    }\n    (renderable as { _direct?: boolean })._direct = true;\n    const state = createTiCullState();\n    scene._meshDisposables.get(mesh)?.push(() => {\n        destroyTiCullState(state);\n    });\n    const binding: TiCullBinding = {\n        cullDrawBufs: null,\n        _args: null,\n        update(context: DrawUpdateContext): void {\n            baseUpdate?.(context);\n            const res = prepareTiCull(engine, state, mesh, mesh._gpu, ti, hasColor, context);\n            binding.cullDrawBufs = res?.drawBuffers ?? null;\n            binding._args = res?.argsBuffer ?? null;\n        },\n        draw(pass: GPURenderPassEncoder | GPURenderBundleEncoder, indexCount: number, instanceCount: number): void {\n            if (binding._args) {\n                pass.drawIndexedIndirect(binding._args, 0);\n            } else {\n                pass.drawIndexed(indexCount, instanceCount);\n            }\n        },\n    };\n    return binding;\n}\n"],"names":[],"mappings":"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"}

package/{thin-instance-gpu-C1DGstap.js → thin-instance-gpu-QETC_NyQ.js}

@@ -1,4 +1,4 @@
-import { B as BU, a as F32, p as packMat4IntoF32 } from "./index-BgY3QEzL.js";
+import { B as BU, a as F32, p as packMat4IntoF32 } from "./index-C2sM8ERH.js";
 function syncThinInstanceGpuData(engine, ti, hasColor) {
   var _a, _b;
   const device = engine._device;
@@ -84,4 +84,4 @@ export {
   syncThinInstanceBuffers,
   syncThinInstanceGpuData
 };
-//# sourceMappingURL=thin-instance-gpu-C1DGstap.js.map
+//# sourceMappingURL=thin-instance-gpu-QETC_NyQ.js.map

package/{thin-instance-gpu-C1DGstap.js.map → thin-instance-gpu-QETC_NyQ.js.map}

@@ -1 +1 @@
-{"version":3,"file":"thin-instance-gpu-C1DGstap.js","sources":["../src/mesh/thin-instance-gpu.ts"],"sourcesContent":["/** Thin instance GPU buffer sync — dynamically loaded only by scenes with thin instances.\n *  Keeps the standard renderable chunk unchanged for scenes without thin instances. */\n\nimport { F32 } from \"../engine/typed-arrays.js\";\nimport { BU } from \"../engine/gpu-flags.js\";\nimport type { ThinInstanceData } from \"./thin-instance.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport { packMat4IntoF32 } from \"../math/pack-mat4-into-f32.js\";\n\n/** @internal Optional replacement buffers used by GPU culling after it compacts visible instances. */\nexport interface ThinInstanceDrawBuffers {\n    readonly matrixBuffer: GPUBuffer;\n    readonly colorBuffer: GPUBuffer | null;\n}\n\n/** @internal Sync CPU thin-instance data to GPU buffers, optionally with STORAGE usage for compute culling. */\nexport function syncThinInstanceGpuData(engine: EngineContext, ti: ThinInstanceData, hasColor: boolean): void {\n    const device = engine._device;\n    const needsStorage = ti._gpuCullingEnabled;\n    if (ti._version !== ti._gpuVersion || ti._gpuBufferStorage !== needsStorage) {\n        const byteSize = ti.count * 64;\n        let bufferRecreated = false;\n        if (!ti._gpuBuffer || ti._gpuBuffer.size < byteSize || ti._gpuBufferStorage !== needsStorage) {\n            ti._gpuBuffer?.destroy();\n            ti._gpuBuffer = device.createBuffer({\n                size: Math.max(ti._capacity * 64, 4),\n                // STORAGE is always included: the GPU picker binds this matrix\n                // buffer as a read-only storage buffer for thin-instance picking,\n                // so it must be storage-capable even when compute culling is off\n                // (otherwise the whole pick pass is invalidated → nothing is pickable).\n                usage: BU.VERTEX | BU.COPY_DST | BU.STORAGE,\n            });\n            ti._gpuBufferStorage = needsStorage;\n            bufferRecreated = true;\n        }\n        // Upload only the dirty range (or full range if buffer was just created)\n        const dirtyMin = bufferRecreated ? 0 : ti._dirtyMin;\n        const dirtyMax = bufferRecreated ? ti.count : Math.min(ti._dirtyMax, ti.count);\n        if (dirtyMax > dirtyMin) {\n            const minByte = dirtyMin * 64;\n            const maxByte = dirtyMax * 64;\n            if (ti.matrices instanceof F32) {\n                // Fast path: F32 source — direct byte copy, no per-instance pack.\n                device.queue.writeBuffer(ti._gpuBuffer, minByte, ti.matrices.buffer, ti.matrices.byteOffset + minByte, maxByte - minByte);\n            } else {\n                // F64 source (HPM-on path) — pack each dirty instance into a\n                // per-mesh reused F32 upload scratch, then writeBuffer the\n                // dirty subrange. Scratch is sized to capacity in F32 floats\n                // and grown when capacity grows; never per-frame allocated.\n                const neededFloats = ti._capacity * 16;\n                if (!ti._uploadF32 || ti._uploadF32.length < neededFloats) {\n                    ti._uploadF32 = new F32(neededFloats);\n                }\n                const upload = ti._uploadF32;\n                for (let i = dirtyMin; i < dirtyMax; i++) {\n                    packMat4IntoF32(upload, ti.matrices, i * 16, i * 16);\n                }\n                device.queue.writeBuffer(ti._gpuBuffer, minByte, upload.buffer, upload.byteOffset + minByte, maxByte - minByte);\n            }\n        }\n        ti._dirtyMin = ti.count;\n        ti._dirtyMax = 0;\n        ti._gpuVersion = ti._version;\n    }\n\n    if (hasColor && ti.colors) {\n        if (ti._colorVersion !== ti._colorGpuVersion || ti._colorGpuBufferStorage !== needsStorage) {\n            const colorByteSize = ti.count * 16;\n            let colorRecreated = false;\n            if (!ti._colorGpuBuffer || ti._colorGpuBuffer.size < colorByteSize || ti._colorGpuBufferStorage !== needsStorage) {\n                ti._colorGpuBuffer?.destroy();\n                ti._colorGpuBuffer = device.createBuffer({\n                    size: Math.max(ti._capacity * 16, 4),\n                    usage: BU.VERTEX | BU.COPY_DST | (needsStorage ? BU.STORAGE : 0),\n                });\n                ti._colorGpuBufferStorage = needsStorage;\n                colorRecreated = true;\n            }\n            // Upload only the dirty colour range (mirrors the matrix path) — full range on (re)create.\n            const cMin = colorRecreated ? 0 : ti._colorDirtyMin;\n            const cMax = colorRecreated ? ti.count : Math.min(ti._colorDirtyMax, ti.count);\n            if (cMax > cMin) {\n                device.queue.writeBuffer(ti._colorGpuBuffer, cMin * 16, ti.colors.buffer, ti.colors.byteOffset + cMin * 16, (cMax - cMin) * 16);\n            }\n            ti._colorDirtyMin = ti.count;\n            ti._colorDirtyMax = 0;\n            ti._colorGpuVersion = ti._colorVersion;\n        }\n    }\n}\n\n/** Sync thin instance matrix + optional color GPU buffers and bind to vertex slots. */\nexport function syncThinInstanceBuffers(\n    engine: EngineContext,\n    ti: ThinInstanceData,\n    pass: GPURenderPassEncoder | GPURenderBundleEncoder,\n    slot: number,\n    hasColor: boolean,\n    drawBuffers?: ThinInstanceDrawBuffers | null\n): number {\n    syncThinInstanceGpuData(engine, ti, hasColor);\n    const matrixBuffer = drawBuffers?.matrixBuffer ?? ti._gpuBuffer;\n    if (matrixBuffer) {\n        pass.setVertexBuffer(slot++, matrixBuffer);\n    }\n\n    if (hasColor) {\n        const colorBuffer = drawBuffers?.colorBuffer ?? ti._colorGpuBuffer;\n        if (colorBuffer) {\n            pass.setVertexBuffer(slot++, colorBuffer);\n        }\n    }\n\n    return slot;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"thin-instance-gpu-QETC_NyQ.js","sources":["../src/mesh/thin-instance-gpu.ts"],"sourcesContent":["/** Thin instance GPU buffer sync — dynamically loaded only by scenes with thin instances.\n *  Keeps the standard renderable chunk unchanged for scenes without thin instances. */\n\nimport { F32 } from \"../engine/typed-arrays.js\";\nimport { BU } from \"../engine/gpu-flags.js\";\nimport type { ThinInstanceData } from \"./thin-instance.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport { packMat4IntoF32 } from \"../math/pack-mat4-into-f32.js\";\n\n/** @internal Optional replacement buffers used by GPU culling after it compacts visible instances. */\nexport interface ThinInstanceDrawBuffers {\n    readonly matrixBuffer: GPUBuffer;\n    readonly colorBuffer: GPUBuffer | null;\n}\n\n/** @internal Sync CPU thin-instance data to GPU buffers, optionally with STORAGE usage for compute culling. */\nexport function syncThinInstanceGpuData(engine: EngineContext, ti: ThinInstanceData, hasColor: boolean): void {\n    const device = engine._device;\n    const needsStorage = ti._gpuCullingEnabled;\n    if (ti._version !== ti._gpuVersion || ti._gpuBufferStorage !== needsStorage) {\n        const byteSize = ti.count * 64;\n        let bufferRecreated = false;\n        if (!ti._gpuBuffer || ti._gpuBuffer.size < byteSize || ti._gpuBufferStorage !== needsStorage) {\n            ti._gpuBuffer?.destroy();\n            ti._gpuBuffer = device.createBuffer({\n                size: Math.max(ti._capacity * 64, 4),\n                // STORAGE is always included: the GPU picker binds this matrix\n                // buffer as a read-only storage buffer for thin-instance picking,\n                // so it must be storage-capable even when compute culling is off\n                // (otherwise the whole pick pass is invalidated → nothing is pickable).\n                usage: BU.VERTEX | BU.COPY_DST | BU.STORAGE,\n            });\n            ti._gpuBufferStorage = needsStorage;\n            bufferRecreated = true;\n        }\n        // Upload only the dirty range (or full range if buffer was just created)\n        const dirtyMin = bufferRecreated ? 0 : ti._dirtyMin;\n        const dirtyMax = bufferRecreated ? ti.count : Math.min(ti._dirtyMax, ti.count);\n        if (dirtyMax > dirtyMin) {\n            const minByte = dirtyMin * 64;\n            const maxByte = dirtyMax * 64;\n            if (ti.matrices instanceof F32) {\n                // Fast path: F32 source — direct byte copy, no per-instance pack.\n                device.queue.writeBuffer(ti._gpuBuffer, minByte, ti.matrices.buffer, ti.matrices.byteOffset + minByte, maxByte - minByte);\n            } else {\n                // F64 source (HPM-on path) — pack each dirty instance into a\n                // per-mesh reused F32 upload scratch, then writeBuffer the\n                // dirty subrange. Scratch is sized to capacity in F32 floats\n                // and grown when capacity grows; never per-frame allocated.\n                const neededFloats = ti._capacity * 16;\n                if (!ti._uploadF32 || ti._uploadF32.length < neededFloats) {\n                    ti._uploadF32 = new F32(neededFloats);\n                }\n                const upload = ti._uploadF32;\n                for (let i = dirtyMin; i < dirtyMax; i++) {\n                    packMat4IntoF32(upload, ti.matrices, i * 16, i * 16);\n                }\n                device.queue.writeBuffer(ti._gpuBuffer, minByte, upload.buffer, upload.byteOffset + minByte, maxByte - minByte);\n            }\n        }\n        ti._dirtyMin = ti.count;\n        ti._dirtyMax = 0;\n        ti._gpuVersion = ti._version;\n    }\n\n    if (hasColor && ti.colors) {\n        if (ti._colorVersion !== ti._colorGpuVersion || ti._colorGpuBufferStorage !== needsStorage) {\n            const colorByteSize = ti.count * 16;\n            let colorRecreated = false;\n            if (!ti._colorGpuBuffer || ti._colorGpuBuffer.size < colorByteSize || ti._colorGpuBufferStorage !== needsStorage) {\n                ti._colorGpuBuffer?.destroy();\n                ti._colorGpuBuffer = device.createBuffer({\n                    size: Math.max(ti._capacity * 16, 4),\n                    usage: BU.VERTEX | BU.COPY_DST | (needsStorage ? BU.STORAGE : 0),\n                });\n                ti._colorGpuBufferStorage = needsStorage;\n                colorRecreated = true;\n            }\n            // Upload only the dirty colour range (mirrors the matrix path) — full range on (re)create.\n            const cMin = colorRecreated ? 0 : ti._colorDirtyMin;\n            const cMax = colorRecreated ? ti.count : Math.min(ti._colorDirtyMax, ti.count);\n            if (cMax > cMin) {\n                device.queue.writeBuffer(ti._colorGpuBuffer, cMin * 16, ti.colors.buffer, ti.colors.byteOffset + cMin * 16, (cMax - cMin) * 16);\n            }\n            ti._colorDirtyMin = ti.count;\n            ti._colorDirtyMax = 0;\n            ti._colorGpuVersion = ti._colorVersion;\n        }\n    }\n}\n\n/** Sync thin instance matrix + optional color GPU buffers and bind to vertex slots. */\nexport function syncThinInstanceBuffers(\n    engine: EngineContext,\n    ti: ThinInstanceData,\n    pass: GPURenderPassEncoder | GPURenderBundleEncoder,\n    slot: number,\n    hasColor: boolean,\n    drawBuffers?: ThinInstanceDrawBuffers | null\n): number {\n    syncThinInstanceGpuData(engine, ti, hasColor);\n    const matrixBuffer = drawBuffers?.matrixBuffer ?? ti._gpuBuffer;\n    if (matrixBuffer) {\n        pass.setVertexBuffer(slot++, matrixBuffer);\n    }\n\n    if (hasColor) {\n        const colorBuffer = drawBuffers?.colorBuffer ?? ti._colorGpuBuffer;\n        if (colorBuffer) {\n            pass.setVertexBuffer(slot++, colorBuffer);\n        }\n    }\n\n    return slot;\n}\n"],"names":[],"mappings":"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"}

package/{tracking-primitives-CMBWLxGr.js → tracking-primitives-CqIIi7Ej.js}

@@ -1,4 +1,4 @@
-import { f as markMaterialUboDirty } from "./index-BgY3QEzL.js";
+import { f as markMaterialUboDirty } from "./index-C2sM8ERH.js";
 function observableColor3(r, g, b, owner) {
   const arr = [r, g, b];
   for (let i = 0; i < 3; i++) {
@@ -79,4 +79,4 @@ export {
   observableColor3 as o,
   trackScalar as t
 };
-//# sourceMappingURL=tracking-primitives-CMBWLxGr.js.map
+//# sourceMappingURL=tracking-primitives-CqIIi7Ej.js.map

package/{tracking-primitives-CMBWLxGr.js.map → tracking-primitives-CqIIi7Ej.js.map}

@@ -1 +1 @@
-{"version":3,"file":"tracking-primitives-CMBWLxGr.js","sources":["../src/material/tracking/tracking-primitives.ts"],"sourcesContent":["/** Shared tracking primitives for observable material properties. */\n\nimport type { Material } from \"../material.js\";\nimport { markMaterialUboDirty } from \"../material-dirty.js\";\n\nexport function observableColor3(r: number, g: number, b: number, owner: Material): [number, number, number] {\n    const arr = [r, g, b] as [number, number, number];\n    for (let i = 0; i < 3; i++) {\n        let val = arr[i]!;\n        Object.defineProperty(arr, i, {\n            get() {\n                return val;\n            },\n            set(v: number) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(owner);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n    return arr;\n}\n\nexport function observableVec2(x: number, y: number, owner: Material): [number, number] {\n    const arr = [x, y] as [number, number];\n    for (let i = 0; i < 2; i++) {\n        let val = arr[i]!;\n        Object.defineProperty(arr, i, {\n            get() {\n                return val;\n            },\n            set(v: number) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(owner);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n    return arr;\n}\n\nexport function trackScalar(obj: any, key: string): void {\n    let val = obj[key];\n    Object.defineProperty(obj, key, {\n        get() {\n            return val;\n        },\n        set(v: any) {\n            if (val !== v) {\n                val = v;\n                markMaterialUboDirty(obj as Material);\n            }\n        },\n        configurable: true,\n        enumerable: true,\n    });\n}\n\nexport function trackSubProps(parent: Material, sub: any, keys: string[]): void {\n    for (const key of keys) {\n        let val = sub[key];\n        Object.defineProperty(sub, key, {\n            get() {\n                return val;\n            },\n            set(v: any) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(parent);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n}\n"],"names":[],"mappings":";AAKO,SAAS,iBAAiB,GAAW,GAAW,GAAW,OAA2C;AACzG,QAAM,MAAM,CAAC,GAAG,GAAG,CAAC;AACpB,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,QAAI,MAAM,IAAI,CAAC;AACf,WAAO,eAAe,KAAK,GAAG;AAAA,MAC1B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAW;AACX,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,KAAK;AAAA,QAC9B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACA,SAAO;AACX;AAEO,SAAS,eAAe,GAAW,GAAW,OAAmC;AACpF,QAAM,MAAM,CAAC,GAAG,CAAC;AACjB,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,QAAI,MAAM,IAAI,CAAC;AACf,WAAO,eAAe,KAAK,GAAG;AAAA,MAC1B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAW;AACX,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,KAAK;AAAA,QAC9B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACA,SAAO;AACX;AAEO,SAAS,YAAY,KAAU,KAAmB;AACrD,MAAI,MAAM,IAAI,GAAG;AACjB,SAAO,eAAe,KAAK,KAAK;AAAA,IAC5B,MAAM;AACF,aAAO;AAAA,IACX;AAAA,IACA,IAAI,GAAQ;AACR,UAAI,QAAQ,GAAG;AACX,cAAM;AACN,6BAAqB,GAAe;AAAA,MACxC;AAAA,IACJ;AAAA,IACA,cAAc;AAAA,IACd,YAAY;AAAA,EAAA,CACf;AACL;AAEO,SAAS,cAAc,QAAkB,KAAU,MAAsB;AAC5E,aAAW,OAAO,MAAM;AACpB,QAAI,MAAM,IAAI,GAAG;AACjB,WAAO,eAAe,KAAK,KAAK;AAAA,MAC5B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAQ;AACR,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,MAAM;AAAA,QAC/B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACJ;"}
+{"version":3,"file":"tracking-primitives-CqIIi7Ej.js","sources":["../src/material/tracking/tracking-primitives.ts"],"sourcesContent":["/** Shared tracking primitives for observable material properties. */\n\nimport type { Material } from \"../material.js\";\nimport { markMaterialUboDirty } from \"../material-dirty.js\";\n\nexport function observableColor3(r: number, g: number, b: number, owner: Material): [number, number, number] {\n    const arr = [r, g, b] as [number, number, number];\n    for (let i = 0; i < 3; i++) {\n        let val = arr[i]!;\n        Object.defineProperty(arr, i, {\n            get() {\n                return val;\n            },\n            set(v: number) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(owner);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n    return arr;\n}\n\nexport function observableVec2(x: number, y: number, owner: Material): [number, number] {\n    const arr = [x, y] as [number, number];\n    for (let i = 0; i < 2; i++) {\n        let val = arr[i]!;\n        Object.defineProperty(arr, i, {\n            get() {\n                return val;\n            },\n            set(v: number) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(owner);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n    return arr;\n}\n\nexport function trackScalar(obj: any, key: string): void {\n    let val = obj[key];\n    Object.defineProperty(obj, key, {\n        get() {\n            return val;\n        },\n        set(v: any) {\n            if (val !== v) {\n                val = v;\n                markMaterialUboDirty(obj as Material);\n            }\n        },\n        configurable: true,\n        enumerable: true,\n    });\n}\n\nexport function trackSubProps(parent: Material, sub: any, keys: string[]): void {\n    for (const key of keys) {\n        let val = sub[key];\n        Object.defineProperty(sub, key, {\n            get() {\n                return val;\n            },\n            set(v: any) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(parent);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n}\n"],"names":[],"mappings":";AAKO,SAAS,iBAAiB,GAAW,GAAW,GAAW,OAA2C;AACzG,QAAM,MAAM,CAAC,GAAG,GAAG,CAAC;AACpB,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,QAAI,MAAM,IAAI,CAAC;AACf,WAAO,eAAe,KAAK,GAAG;AAAA,MAC1B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAW;AACX,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,KAAK;AAAA,QAC9B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACA,SAAO;AACX;AAEO,SAAS,eAAe,GAAW,GAAW,OAAmC;AACpF,QAAM,MAAM,CAAC,GAAG,CAAC;AACjB,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,QAAI,MAAM,IAAI,CAAC;AACf,WAAO,eAAe,KAAK,GAAG;AAAA,MAC1B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAW;AACX,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,KAAK;AAAA,QAC9B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACA,SAAO;AACX;AAEO,SAAS,YAAY,KAAU,KAAmB;AACrD,MAAI,MAAM,IAAI,GAAG;AACjB,SAAO,eAAe,KAAK,KAAK;AAAA,IAC5B,MAAM;AACF,aAAO;AAAA,IACX;AAAA,IACA,IAAI,GAAQ;AACR,UAAI,QAAQ,GAAG;AACX,cAAM;AACN,6BAAqB,GAAe;AAAA,MACxC;AAAA,IACJ;AAAA,IACA,cAAc;AAAA,IACd,YAAY;AAAA,EAAA,CACf;AACL;AAEO,SAAS,cAAc,QAAkB,KAAU,MAAsB;AAC5E,aAAW,OAAO,MAAM;AACpB,QAAI,MAAM,IAAI,GAAG;AACjB,WAAO,eAAe,KAAK,KAAK;AAAA,MAC5B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAQ;AACR,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,MAAM;AAAA,QAC/B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACJ;"}

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

@@ -1,4 +1,4 @@
-import { b6 as PBR2_HAS_UNLIT } from "./index-BgY3QEzL.js";
+import { bh as PBR2_HAS_UNLIT } from "./index-C2sM8ERH.js";
 function createUnlitFragment(hasIbl) {
   const assign = `color = baseColor * material.unlitColor;`;
   return {
@@ -40,4 +40,4 @@ export {
   pbrExt,
   writeUnlitUBO
 };
-//# sourceMappingURL=unlit-fragment-BsHrS9XX.js.map
+//# sourceMappingURL=unlit-fragment-DPWDQLxo.js.map