@babylonjs/lite 0.1.1

package/shadow-fragment-core-DHN2G6FI.js

@@ -0,0 +1,110 @@
+const STAGE_FRAGMENT = 2;
+const STAGE_VERTEX = 1;
+function createShadowFragment(id, shadowLights) {
+  const varyings = [];
+  const bindings = [];
+  const vertexLines = [];
+  const fragmentLines = [];
+  const helperParts = [];
+  for (const slot of shadowLights) {
+    const li = slot.lightIndex;
+    const suffix = `_${li}`;
+    varyings.push({ _name: `vPosFromLight${suffix}`, _type: "vec4<f32>" }, { _name: `vDepthMetric${suffix}`, _type: "f32" });
+    if (slot.shadowType === "pcf") {
+      bindings.push(
+        { _name: `shadowTex${suffix}`, _type: { _kind: "texture", _textureType: "texture_depth_2d", _sampleType: "depth" }, _group: "shadow", _visibility: STAGE_FRAGMENT },
+        { _name: `shadowComp${suffix}`, _type: { _kind: "sampler", _samplerType: "sampler_comparison" }, _group: "shadow", _visibility: STAGE_FRAGMENT }
+      );
+    } else {
+      bindings.push(
+        { _name: `shadowTex${suffix}`, _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _group: "shadow", _visibility: STAGE_FRAGMENT },
+        { _name: `shadowSamp${suffix}`, _type: { _kind: "sampler", _samplerType: "sampler" }, _group: "shadow", _visibility: STAGE_FRAGMENT }
+      );
+    }
+    bindings.push({ _name: `shadowInfo${suffix}`, _type: { _kind: "uniform-buffer" }, _group: "shadow", _visibility: STAGE_FRAGMENT | STAGE_VERTEX });
+    vertexLines.push(
+      `out.vPosFromLight${suffix} = shadowInfo${suffix}.lightMatrix * worldPos4;`,
+      `out.vDepthMetric${suffix} = (out.vPosFromLight${suffix}.z + shadowInfo${suffix}.depthValues.x) / shadowInfo${suffix}.depthValues.y;`
+    );
+    if (slot.shadowType === "pcf") {
+      fragmentLines.push(
+        `shadowFactors[${li}] = computeShadowPCF${suffix}(input.vPosFromLight${suffix}, input.vDepthMetric${suffix}, shadowInfo${suffix}.shadowsInfo.x, shadowInfo${suffix}.shadowsInfo.y, shadowInfo${suffix}.shadowsInfo.z);`
+      );
+    } else {
+      fragmentLines.push(
+        `shadowFactors[${li}] = computeShadowESM${suffix}(input.vPosFromLight${suffix}, input.vDepthMetric${suffix}, shadowInfo${suffix}.shadowsInfo.x, shadowInfo${suffix}.shadowsInfo.z, shadowInfo${suffix}.shadowsInfo.w);`
+      );
+    }
+  }
+  for (const slot of shadowLights) {
+    const li = slot.lightIndex;
+    const suffix = `_${li}`;
+    helperParts.push(`struct shadowInfo${suffix}Uniforms { lightMatrix: mat4x4<f32>, depthValues: vec4<f32>, shadowsInfo: vec4<f32> };`);
+    if (slot.shadowType === "pcf") {
+      helperParts.push(`
+fn computeShadowPCF${suffix}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, mapSz: f32, invMapSz: f32) -> f32 {
+let clipSpace = posFromLight.xyz / posFromLight.w;
+let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);
+if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }
+let depthRef = clamp(clipSpace.z, 0.0, 1.0);
+var tc = uv * mapSz + 0.5;
+let st = fract(tc);
+let base = (floor(tc) - 0.5) * invMapSz;
+let uvw0 = 4.0 - 3.0 * st;
+let uvw1 = vec2<f32>(7.0);
+let uvw2 = 1.0 + 3.0 * st;
+let u = vec3<f32>((3.0 - 2.0 * st.x) / uvw0.x - 2.0, (3.0 + st.x) / uvw1.x, st.x / uvw2.x + 2.0) * invMapSz;
+let v = vec3<f32>((3.0 - 2.0 * st.y) / uvw0.y - 2.0, (3.0 + st.y) / uvw1.y, st.y / uvw2.y + 2.0) * invMapSz;
+var sh = 0.0;
+sh += uvw0.x * uvw0.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[0], v[0]), depthRef);
+sh += uvw1.x * uvw0.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[1], v[0]), depthRef);
+sh += uvw2.x * uvw0.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[2], v[0]), depthRef);
+sh += uvw0.x * uvw1.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[0], v[1]), depthRef);
+sh += uvw1.x * uvw1.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[1], v[1]), depthRef);
+sh += uvw2.x * uvw1.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[2], v[1]), depthRef);
+sh += uvw0.x * uvw2.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[0], v[2]), depthRef);
+sh += uvw1.x * uvw2.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[1], v[2]), depthRef);
+sh += uvw2.x * uvw2.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[2], v[2]), depthRef);
+sh /= 144.0;
+return mix(darkness, 1.0, sh);
+}`);
+    } else {
+      helperParts.push(`
+fn computeFallOff${suffix}(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {
+let mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));
+return mix(value, 1.0, mask);
+}
+fn computeShadowESM${suffix}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, depthScale: f32, frustumEdgeFalloff: f32) -> f32 {
+let clipSpace = posFromLight.xyz / posFromLight.w;
+let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);
+if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }
+let shadowPixelDepth = clamp(depthMetric, 0.0, 1.0);
+let shadowMapSample = textureSampleLevel(shadowTex${suffix}, shadowSamp${suffix}, uv, 0.0).x;
+let esm = 1.0 - clamp(exp(min(87.0, depthScale * shadowPixelDepth)) * shadowMapSample, 0.0, 1.0 - darkness);
+return computeFallOff${suffix}(esm, clipSpace.xy, frustumEdgeFalloff);
+}`);
+    }
+  }
+  const vertexHelperParts = [];
+  for (const slot of shadowLights) {
+    const suffix = `_${slot.lightIndex}`;
+    vertexHelperParts.push(`struct shadowInfo${suffix}Uniforms { lightMatrix: mat4x4<f32>, depthValues: vec4<f32>, shadowsInfo: vec4<f32> };`);
+  }
+  return {
+    _id: id,
+    _varyings: varyings,
+    _bindings: bindings,
+    _helperFunctions: helperParts.join("\n"),
+    _vertexHelperFunctions: vertexHelperParts.join("\n"),
+    _vertexSlots: {
+      VB: vertexLines.join("\n")
+    },
+    _fragmentSlots: {
+      AD: fragmentLines.join("\n")
+    }
+  };
+}
+export {
+  createShadowFragment as c
+};
+//# sourceMappingURL=shadow-fragment-core-DHN2G6FI.js.map

package/shadow-fragment-core-DHN2G6FI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-fragment-core-DHN2G6FI.js","sources":["../src/shader/fragments/shadow-fragment-core.ts"],"sourcesContent":["/**\n * Shadow Fragment Core — Shared WGSL Generation for Shadows\n *\n * Contains the shadow sampling WGSL codegen shared by both Standard and PBR\n * materials. Each material wrapper calls `createShadowFragment` with its own\n * fragment ID (\"std-shadow\" / \"pbr-shadow\"), keeping the generated shader\n * code byte-for-byte identical.\n *\n * Zero module-level side effects — safe for tree-shaking.\n */\n\nimport type { ShaderFragment, BindingDecl, Varying } from \"../fragment-types.js\";\n\nconst STAGE_FRAGMENT = 0x2;\nconst STAGE_VERTEX = 0x1;\n\n/** Describes one shadow-casting light for the fragment generator. */\nexport interface ShadowLightSlot {\n    /** Index of this light in the scene.lights array (0-based). */\n    lightIndex: number;\n    /** Shadow type for this light. */\n    shadowType: \"esm\" | \"pcf\";\n}\n\n/**\n * Create a per-light shadow fragment.\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 */\nexport function createShadowFragment(id: string, shadowLights: ShadowLightSlot[]): ShaderFragment {\n    const varyings: Varying[] = [];\n    const bindings: BindingDecl[] = [];\n    const vertexLines: string[] = [];\n    const fragmentLines: string[] = [];\n    const helperParts: string[] = [];\n\n    for (const slot of shadowLights) {\n        const li = slot.lightIndex;\n        const suffix = `_${li}`;\n\n        varyings.push({ _name: `vPosFromLight${suffix}`, _type: \"vec4<f32>\" }, { _name: `vDepthMetric${suffix}`, _type: \"f32\" });\n\n        if (slot.shadowType === \"pcf\") {\n            bindings.push(\n                { _name: `shadowTex${suffix}`, _type: { _kind: \"texture\", _textureType: \"texture_depth_2d\", _sampleType: \"depth\" }, _group: \"shadow\", _visibility: STAGE_FRAGMENT },\n                { _name: `shadowComp${suffix}`, _type: { _kind: \"sampler\", _samplerType: \"sampler_comparison\" }, _group: \"shadow\", _visibility: STAGE_FRAGMENT }\n            );\n        } else {\n            bindings.push(\n                { _name: `shadowTex${suffix}`, _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _group: \"shadow\", _visibility: STAGE_FRAGMENT },\n                { _name: `shadowSamp${suffix}`, _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _group: \"shadow\", _visibility: STAGE_FRAGMENT }\n            );\n        }\n        bindings.push({ _name: `shadowInfo${suffix}`, _type: { _kind: \"uniform-buffer\" }, _group: \"shadow\", _visibility: STAGE_FRAGMENT | STAGE_VERTEX });\n\n        vertexLines.push(\n            `out.vPosFromLight${suffix} = shadowInfo${suffix}.lightMatrix * worldPos4;`,\n            `out.vDepthMetric${suffix} = (out.vPosFromLight${suffix}.z + shadowInfo${suffix}.depthValues.x) / shadowInfo${suffix}.depthValues.y;`\n        );\n\n        if (slot.shadowType === \"pcf\") {\n            fragmentLines.push(\n                `shadowFactors[${li}] = computeShadowPCF${suffix}(input.vPosFromLight${suffix}, input.vDepthMetric${suffix}, shadowInfo${suffix}.shadowsInfo.x, shadowInfo${suffix}.shadowsInfo.y, shadowInfo${suffix}.shadowsInfo.z);`\n            );\n        } else {\n            fragmentLines.push(\n                `shadowFactors[${li}] = computeShadowESM${suffix}(input.vPosFromLight${suffix}, input.vDepthMetric${suffix}, shadowInfo${suffix}.shadowsInfo.x, shadowInfo${suffix}.shadowsInfo.z, shadowInfo${suffix}.shadowsInfo.w);`\n            );\n        }\n    }\n\n    // Helper structs + sampling functions\n    for (const slot of shadowLights) {\n        const li = slot.lightIndex;\n        const suffix = `_${li}`;\n        helperParts.push(`struct shadowInfo${suffix}Uniforms { lightMatrix: mat4x4<f32>, depthValues: vec4<f32>, shadowsInfo: vec4<f32> };`);\n\n        if (slot.shadowType === \"pcf\") {\n            helperParts.push(`\nfn computeShadowPCF${suffix}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, mapSz: f32, invMapSz: f32) -> f32 {\nlet clipSpace = posFromLight.xyz / posFromLight.w;\nlet uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\nif (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\nlet depthRef = clamp(clipSpace.z, 0.0, 1.0);\nvar tc = uv * mapSz + 0.5;\nlet st = fract(tc);\nlet base = (floor(tc) - 0.5) * invMapSz;\nlet uvw0 = 4.0 - 3.0 * st;\nlet uvw1 = vec2<f32>(7.0);\nlet uvw2 = 1.0 + 3.0 * st;\nlet u = vec3<f32>((3.0 - 2.0 * st.x) / uvw0.x - 2.0, (3.0 + st.x) / uvw1.x, st.x / uvw2.x + 2.0) * invMapSz;\nlet v = vec3<f32>((3.0 - 2.0 * st.y) / uvw0.y - 2.0, (3.0 + st.y) / uvw1.y, st.y / uvw2.y + 2.0) * invMapSz;\nvar sh = 0.0;\nsh += uvw0.x * uvw0.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[0], v[0]), depthRef);\nsh += uvw1.x * uvw0.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[1], v[0]), depthRef);\nsh += uvw2.x * uvw0.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[2], v[0]), depthRef);\nsh += uvw0.x * uvw1.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[0], v[1]), depthRef);\nsh += uvw1.x * uvw1.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[1], v[1]), depthRef);\nsh += uvw2.x * uvw1.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[2], v[1]), depthRef);\nsh += uvw0.x * uvw2.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[0], v[2]), depthRef);\nsh += uvw1.x * uvw2.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[1], v[2]), depthRef);\nsh += uvw2.x * uvw2.y * textureSampleCompareLevel(shadowTex${suffix}, shadowComp${suffix}, base + vec2<f32>(u[2], v[2]), depthRef);\nsh /= 144.0;\nreturn mix(darkness, 1.0, sh);\n}`);\n        } else {\n            helperParts.push(`\nfn computeFallOff${suffix}(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {\nlet mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));\nreturn mix(value, 1.0, mask);\n}\nfn computeShadowESM${suffix}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, depthScale: f32, frustumEdgeFalloff: f32) -> f32 {\nlet clipSpace = posFromLight.xyz / posFromLight.w;\nlet uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\nif (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\nlet shadowPixelDepth = clamp(depthMetric, 0.0, 1.0);\nlet shadowMapSample = textureSampleLevel(shadowTex${suffix}, shadowSamp${suffix}, uv, 0.0).x;\nlet esm = 1.0 - clamp(exp(min(87.0, depthScale * shadowPixelDepth)) * shadowMapSample, 0.0, 1.0 - darkness);\nreturn computeFallOff${suffix}(esm, clipSpace.xy, frustumEdgeFalloff);\n}`);\n        }\n    }\n\n    // Vertex helper: UBO struct declarations (needed for lightMatrix access in vertex shader)\n    const vertexHelperParts: string[] = [];\n    for (const slot of shadowLights) {\n        const suffix = `_${slot.lightIndex}`;\n        vertexHelperParts.push(`struct shadowInfo${suffix}Uniforms { lightMatrix: mat4x4<f32>, depthValues: vec4<f32>, shadowsInfo: vec4<f32> };`);\n    }\n\n    return {\n        _id: id,\n        _varyings: varyings,\n        _bindings: bindings,\n        _helperFunctions: helperParts.join(\"\\n\"),\n        _vertexHelperFunctions: vertexHelperParts.join(\"\\n\"),\n        _vertexSlots: {\n            VB: vertexLines.join(\"\\n\"),\n        },\n        _fragmentSlots: {\n            AD: fragmentLines.join(\"\\n\"),\n        },\n    };\n}\n"],"names":[],"mappings":"AAaA,MAAM,iBAAiB;AACvB,MAAM,eAAe;AAed,SAAS,qBAAqB,IAAY,cAAiD;AAC9F,QAAM,WAAsB,CAAA;AAC5B,QAAM,WAA0B,CAAA;AAChC,QAAM,cAAwB,CAAA;AAC9B,QAAM,gBAA0B,CAAA;AAChC,QAAM,cAAwB,CAAA;AAE9B,aAAW,QAAQ,cAAc;AAC7B,UAAM,KAAK,KAAK;AAChB,UAAM,SAAS,IAAI,EAAE;AAErB,aAAS,KAAK,EAAE,OAAO,gBAAgB,MAAM,IAAI,OAAO,YAAA,GAAe,EAAE,OAAO,eAAe,MAAM,IAAI,OAAO,OAAO;AAEvH,QAAI,KAAK,eAAe,OAAO;AAC3B,eAAS;AAAA,QACL,EAAE,OAAO,YAAY,MAAM,IAAI,OAAO,EAAE,OAAO,WAAW,cAAc,oBAAoB,aAAa,QAAA,GAAW,QAAQ,UAAU,aAAa,eAAA;AAAA,QACnJ,EAAE,OAAO,aAAa,MAAM,IAAI,OAAO,EAAE,OAAO,WAAW,cAAc,qBAAA,GAAwB,QAAQ,UAAU,aAAa,eAAA;AAAA,MAAe;AAAA,IAEvJ,OAAO;AACH,eAAS;AAAA,QACL,EAAE,OAAO,YAAY,MAAM,IAAI,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,QAAQ,UAAU,aAAa,eAAA;AAAA,QAC5H,EAAE,OAAO,aAAa,MAAM,IAAI,OAAO,EAAE,OAAO,WAAW,cAAc,UAAA,GAAa,QAAQ,UAAU,aAAa,eAAA;AAAA,MAAe;AAAA,IAE5I;AACA,aAAS,KAAK,EAAE,OAAO,aAAa,MAAM,IAAI,OAAO,EAAE,OAAO,iBAAA,GAAoB,QAAQ,UAAU,aAAa,iBAAiB,cAAc;AAEhJ,gBAAY;AAAA,MACR,oBAAoB,MAAM,gBAAgB,MAAM;AAAA,MAChD,mBAAmB,MAAM,wBAAwB,MAAM,kBAAkB,MAAM,+BAA+B,MAAM;AAAA,IAAA;AAGxH,QAAI,KAAK,eAAe,OAAO;AAC3B,oBAAc;AAAA,QACV,iBAAiB,EAAE,uBAAuB,MAAM,uBAAuB,MAAM,uBAAuB,MAAM,eAAe,MAAM,6BAA6B,MAAM,6BAA6B,MAAM;AAAA,MAAA;AAAA,IAE7M,OAAO;AACH,oBAAc;AAAA,QACV,iBAAiB,EAAE,uBAAuB,MAAM,uBAAuB,MAAM,uBAAuB,MAAM,eAAe,MAAM,6BAA6B,MAAM,6BAA6B,MAAM;AAAA,MAAA;AAAA,IAE7M;AAAA,EACJ;AAGA,aAAW,QAAQ,cAAc;AAC7B,UAAM,KAAK,KAAK;AAChB,UAAM,SAAS,IAAI,EAAE;AACrB,gBAAY,KAAK,oBAAoB,MAAM,wFAAwF;AAEnI,QAAI,KAAK,eAAe,OAAO;AAC3B,kBAAY,KAAK;AAAA,qBACR,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6DAckC,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA,6DAC3B,MAAM,eAAe,MAAM;AAAA;AAAA;AAAA,EAGtF;AAAA,IACM,OAAO;AACH,kBAAY,KAAK;AAAA,mBACV,MAAM;AAAA;AAAA;AAAA;AAAA,qBAIJ,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,oDAKyB,MAAM,eAAe,MAAM;AAAA;AAAA,uBAExD,MAAM;AAAA,EAC3B;AAAA,IACM;AAAA,EACJ;AAGA,QAAM,oBAA8B,CAAA;AACpC,aAAW,QAAQ,cAAc;AAC7B,UAAM,SAAS,IAAI,KAAK,UAAU;AAClC,sBAAkB,KAAK,oBAAoB,MAAM,wFAAwF;AAAA,EAC7I;AAEA,SAAO;AAAA,IACH,KAAK;AAAA,IACL,WAAW;AAAA,IACX,WAAW;AAAA,IACX,kBAAkB,YAAY,KAAK,IAAI;AAAA,IACvC,wBAAwB,kBAAkB,KAAK,IAAI;AAAA,IACnD,cAAc;AAAA,MACV,IAAI,YAAY,KAAK,IAAI;AAAA,IAAA;AAAA,IAE7B,gBAAgB;AAAA,MACZ,IAAI,cAAc,KAAK,IAAI;AAAA,IAAA;AAAA,EAC/B;AAER;"}

package/shadow-map-CQNQC-Fw.js

@@ -0,0 +1,13 @@
+const emitter = {
+  className: "ShadowMapBlock",
+  stage: "fragment",
+  emit(block, _outputName, _stage, _state, _ctx) {
+    const idxRaw = block.serialized.lightId;
+    const idx = typeof idxRaw === "number" ? idxRaw : 0;
+    return { expr: `_NME_SHADOW_${idx}_`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=shadow-map-CQNQC-Fw.js.map

package/shadow-map-CQNQC-Fw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-map-CQNQC-Fw.js","sources":["../src/material/node/blocks/shadow-map.ts"],"sourcesContent":["/** ShadowMapBlock — samples a light's shadow map and returns a shadow factor.\n *\n *  Inputs: worldPosition, worldNormal, lightDirection.\n *  Output: output (f32 in [0, 1], 1.0 = fully lit).\n *\n *  The pipeline builder is responsible for binding the shadow map +\n *  light-space-projection matrix under `_NME_SHADOW_MAP_<idx>_` sentinels.\n *  Until that integration lands this emitter returns a conservative 1.0 — the\n *  pipeline builder rewrites the expression when a real shadow generator is\n *  attached to the selected light.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ShadowMapBlock\",\n    stage: \"fragment\",\n    emit(block, _outputName, _stage, _state, _ctx) {\n        const idxRaw = block.serialized.lightId;\n        const idx = typeof idxRaw === \"number\" ? idxRaw : 0;\n        return { expr: `_NME_SHADOW_${idx}_`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAcO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,QAAQ,QAAQ,MAAM;AAC3C,UAAM,SAAS,MAAM,WAAW;AAChC,UAAM,MAAM,OAAO,WAAW,WAAW,SAAS;AAClD,WAAO,EAAE,MAAM,eAAe,GAAG,KAAK,MAAM,MAAA;AAAA,EAChD;AACJ;"}

package/sheen-block-BugfJqK3.js

@@ -0,0 +1,12 @@
+const emitter = {
+  className: "SheenBlock",
+  stage: "fragment",
+  emit(_block, _outputName, _stage, state, _ctx) {
+    state.usesSheen = true;
+    return { expr: `vec3<f32>(0.0)`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=sheen-block-BugfJqK3.js.map

package/sheen-block-BugfJqK3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheen-block-BugfJqK3.js","sources":["../src/material/node/blocks/sheen-block.ts"],"sourcesContent":["/** SheenBlock — soft cloth/velvet sheen layer marker for PBR-MR.\n *\n *  Like ClearCoatBlock, this is a marker: it flips `state.usesSheen` so PBR-MR\n *  knows to emit the Charlie-NDF + Ashikhmin-visibility code path, and PBR-MR\n *  walks into the connected SheenBlock to gather intensity / color / roughness.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"SheenBlock\",\n    stage: \"fragment\",\n    emit(_block, _outputName, _stage, state, _ctx) {\n        state.usesSheen = true;\n        return { expr: `vec3<f32>(0.0)`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AASO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,OAAO,MAAM;AAC3C,UAAM,YAAY;AAClB,WAAO,EAAE,MAAM,kBAAkB,MAAM,QAAA;AAAA,EAC3C;AACJ;"}

package/sheen-fragment-Dze2f7XJ.js

@@ -0,0 +1,215 @@
+import { aA as PBR_HAS_SHEEN_TEXTURE, aB as PBR_HAS_SHEEN, aC as PBR2_HAS_SHEEN_UV_TX, aD as PBR_HAS_SHEEN_ALBEDO_SCALING } from "./index-C8HOR2sB.js";
+const STAGE_FRAGMENT = 2;
+const SHEEN_HELPERS = `
+fn normalDistributionFunction_CharlieSheen(NdotH_sh: f32, alphaG_sh: f32) -> f32 {
+let invR = 1.0 / alphaG_sh;
+let cos2h = NdotH_sh * NdotH_sh;
+let sin2h = 1.0 - cos2h;
+return (2.0 + invR) * pow(sin2h, invR * 0.5) / (2.0 * 3.141592653589793);
+}
+fn visibility_Ashikhmin(NdotL_sh: f32, NdotV_sh: f32) -> f32 {
+return 1.0 / (4.0 * (NdotL_sh + NdotV_sh - NdotL_sh * NdotV_sh));
+}
+`;
+const SHEEN_DIRECT_MOD = (intensityExpr) => `
+{
+let shIntensity = ${intensityExpr};
+let shColorScaled = sheenColorFinal * shIntensity;
+let shRoughness_clamped = max(sheenRoughnessAdjusted, AA_factor_x);
+let shAlphaG = shRoughness_clamped * shRoughness_clamped + 0.0005;
+let shD = normalDistributionFunction_CharlieSheen(NdotH, shAlphaG);
+let shV = visibility_Ashikhmin(NdotL, NdotV);
+sheenDirectTerm = shColorScaled * shD * shV * NdotL * lightColor * lightAtten * material.directIntensity;
+}
+`;
+const SHEEN_IBL_MOD = (intensityExpr, albedoScaling) => `
+{
+let shIntensity_ibl = ${intensityExpr};
+let shColorScaled = sheenColorFinal * shIntensity_ibl;
+let shRoughness_ibl = sheenRoughnessAdjusted;
+let shAlphaG_ibl = shRoughness_ibl * shRoughness_ibl + 0.0005 + AA_factor_y;
+var shSpecLod = log2(cubemapDim * shAlphaG_ibl) * scene.vImageInfos.z;
+let shEnvRadiance = textureSampleLevel(iblTexture, iblSampler, R, clamp(shSpecLod, 0.0, maxLod)).rgb * material.environmentIntensity;
+let shBrdf = textureSampleLevel(brdfLUT, brdfSampler_, vec2<f32>(NdotV, shRoughness_ibl), 0.0);
+let shEnvReflectance = shColorScaled * shBrdf.b${albedoScaling ? " * seo * eho" : ""};
+sheenIblTerm = shEnvRadiance * shEnvReflectance;
+${albedoScaling ? "let shMax = max(shColorScaled.r, max(shColorScaled.g, shColorScaled.b));\nsheenAlbedoScaling = 1.0 - shMax * shBrdf.b;" : ""}
+}
+`;
+const SHEEN_IBL_COLOR_MOD = (albedoScaling) => albedoScaling ? `
+{
+color = (finalIrradiance
+      + finalRadianceScaled
+      + finalSpecularScaled
+      + directDiffuse) * sheenAlbedoScaling
+      + sheenDirectTerm
+      + sheenIblTerm
+      + emissive;
+}
+` : `
+{
+color = finalIrradiance
+      + finalRadianceScaled
+      + finalSpecularScaled
+      + directDiffuse
+      + sheenDirectTerm
+      + sheenIblTerm
+      + emissive;
+}
+`;
+const SHEEN_NON_IBL_MOD = `
+{
+color = color + sheenDirectTerm;
+}
+`;
+function createSheenFragment(hasSheenTexture, hasIbl = false, hasAlbedoScaling = false, hasSheenUvTx = false) {
+  let scopeVars = `var sheenDirectTerm = vec3<f32>(0.0);
+var sheenIblTerm = vec3<f32>(0.0);
+var sheenAlbedoScaling = 1.0;
+var sheenColorFinal = material.sheenParams.rgb;
+var sheenRoughnessAdjusted = material.sheenParams2.x;`;
+  if (hasSheenTexture) {
+    const gammaStmt = hasAlbedoScaling ? "sheenMapData.rgb" : "pow(sheenMapData.rgb, vec3<f32>(2.2))";
+    const sheenUvDecl = hasSheenUvTx ? "let sheenUV = vec2<f32>(dot(material.sheenUVm.xy, input.uv), dot(material.sheenUVm.zw, input.uv)) + material.sheenUVt.xy;" : "let sheenUV = input.uv;";
+    scopeVars += `
+{
+${sheenUvDecl}
+let sheenMapData = textureSample(sheenTexture_, sheenSampler_, sheenUV);
+sheenColorFinal *= ${gammaStmt};
+sheenRoughnessAdjusted *= sheenMapData.a;
+}`;
+  }
+  const intensityExpr = hasAlbedoScaling ? "material.sheenParams.a" : "material.sheenParams.a * (1.0 - dielectricF0)";
+  const slots = {
+    SV: scopeVars,
+    AD: SHEEN_DIRECT_MOD(intensityExpr)
+  };
+  if (hasIbl) {
+    slots.AI = SHEEN_IBL_MOD(intensityExpr, hasAlbedoScaling) + SHEEN_IBL_COLOR_MOD(hasAlbedoScaling);
+  } else {
+    slots.NI = SHEEN_NON_IBL_MOD;
+  }
+  const bindings = [];
+  if (hasSheenTexture) {
+    bindings.push(
+      { _name: "sheenTexture_", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "sheenSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+  }
+  const uboFields = [
+    { _name: "sheenParams", _type: "vec4<f32>" },
+    { _name: "sheenParams2", _type: "vec4<f32>" }
+  ];
+  if (hasSheenUvTx) {
+    uboFields.push({ _name: "sheenUVm", _type: "vec4<f32>" }, { _name: "sheenUVt", _type: "vec4<f32>" });
+  }
+  return {
+    _id: "sheen",
+    _dependencies: hasIbl ? ["ibl"] : void 0,
+    _uboFields: uboFields,
+    _bindings: bindings,
+    _helperFunctions: SHEEN_HELPERS,
+    _fragmentSlots: slots
+  };
+}
+function writeSheenUBO(data, material, offsets) {
+  const sh = material.sheen;
+  if (!(sh == null ? void 0 : sh.isEnabled) || !offsets.has("sheenParams")) {
+    return;
+  }
+  const off = offsets.get("sheenParams") / 4;
+  const color = sh.color ?? [1, 1, 1];
+  data[off] = color[0];
+  data[off + 1] = color[1];
+  data[off + 2] = color[2];
+  data[off + 3] = sh.intensity ?? 1;
+  data[off + 4] = sh.roughness ?? 0;
+  data[off + 5] = sh.texture ? 1 : 0;
+  const mOff = offsets.get("sheenUVm");
+  const tOff = offsets.get("sheenUVt");
+  if (mOff === void 0 || tOff === void 0) {
+    return;
+  }
+  const tex = sh.texture;
+  const sx = (tex == null ? void 0 : tex.uScale) ?? 1;
+  const sy = (tex == null ? void 0 : tex.vScale) ?? 1;
+  const ang = (tex == null ? void 0 : tex.uAng) ?? 0;
+  const ox = (tex == null ? void 0 : tex.uOffset) ?? 0;
+  const oy = (tex == null ? void 0 : tex.vOffset) ?? 0;
+  const mi = mOff / 4;
+  const ti = tOff / 4;
+  if (ang === 0) {
+    data[mi] = sx;
+    data[mi + 1] = 0;
+    data[mi + 2] = 0;
+    data[mi + 3] = sy;
+  } else {
+    const c = Math.cos(ang);
+    const s = Math.sin(ang);
+    data[mi] = c * sx;
+    data[mi + 1] = -s * sy;
+    data[mi + 2] = s * sx;
+    data[mi + 3] = c * sy;
+  }
+  data[ti] = ox;
+  data[ti + 1] = oy;
+  data[ti + 2] = 0;
+  data[ti + 3] = 0;
+}
+const pbrExt = {
+  id: "sheen",
+  phase: "base-tex",
+  detect(mat) {
+    const sh = mat.sheen;
+    if (!(sh == null ? void 0 : sh.isEnabled)) {
+      return { f: 0, f2: 0 };
+    }
+    let f = PBR_HAS_SHEEN;
+    let f2 = 0;
+    if (sh.texture) {
+      f |= PBR_HAS_SHEEN_TEXTURE;
+      if (sh.texture._hasTx) {
+        f2 |= PBR2_HAS_SHEEN_UV_TX;
+      }
+    }
+    if (sh.albedoScaling) {
+      f |= PBR_HAS_SHEEN_ALBEDO_SCALING;
+    }
+    return { f, f2 };
+  },
+  frag(ctx) {
+    if (!(ctx._features & PBR_HAS_SHEEN)) {
+      return null;
+    }
+    return createSheenFragment(
+      (ctx._features & PBR_HAS_SHEEN_TEXTURE) !== 0,
+      ctx._hasIbl,
+      (ctx._features & PBR_HAS_SHEEN_ALBEDO_SCALING) !== 0,
+      (ctx._features2 & PBR2_HAS_SHEEN_UV_TX) !== 0
+    );
+  },
+  writeUbo: writeSheenUBO,
+  bind(ctx, entries, b) {
+    if ((ctx._features & PBR_HAS_SHEEN_TEXTURE) === 0) {
+      return b;
+    }
+    const sh = ctx._material.sheen;
+    if (sh == null ? void 0 : sh.texture) {
+      entries.push({ binding: b++, resource: sh.texture.view });
+      entries.push({ binding: b++, resource: sh.texture.sampler });
+    }
+    return b;
+  },
+  textures(mat, out) {
+    const sh = mat.sheen;
+    if (sh == null ? void 0 : sh.texture) {
+      out.push(sh.texture);
+    }
+  }
+};
+export {
+  createSheenFragment,
+  pbrExt,
+  writeSheenUBO
+};
+//# sourceMappingURL=sheen-fragment-Dze2f7XJ.js.map

package/sheen-fragment-Dze2f7XJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheen-fragment-Dze2f7XJ.js","sources":["../src/material/pbr/fragments/sheen-fragment.ts"],"sourcesContent":["/**\n * Sheen Fragment\n *\n * Adds a soft velvet-like sheen layer (fabric, cloth).\n * Only bundled when a scene uses PbrMaterialProps.sheen.\n *\n * Math follows BJS PBRSheenConfiguration:\n *  - Charlie NDF (sheen distribution)\n *  - Ashikhmin visibility\n *  - IBL: environment sampled at sheen roughness, BRDF LUT blue channel\n *  - Energy conservation: albedo scaled by (1 - maxSheenColor * brdf.b)\n */\n\nimport type { ShaderFragment, BindingDecl, UboField } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps, SheenProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR_HAS_SHEEN, PBR_HAS_SHEEN_TEXTURE, PBR_HAS_SHEEN_ALBEDO_SCALING, PBR2_HAS_SHEEN_UV_TX } from \"../pbr-flag-bits.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nconst SHEEN_HELPERS = `\nfn normalDistributionFunction_CharlieSheen(NdotH_sh: f32, alphaG_sh: f32) -> f32 {\nlet invR = 1.0 / alphaG_sh;\nlet cos2h = NdotH_sh * NdotH_sh;\nlet sin2h = 1.0 - cos2h;\nreturn (2.0 + invR) * pow(sin2h, invR * 0.5) / (2.0 * 3.141592653589793);\n}\nfn visibility_Ashikhmin(NdotL_sh: f32, NdotV_sh: f32) -> f32 {\nreturn 1.0 / (4.0 * (NdotL_sh + NdotV_sh - NdotL_sh * NdotV_sh));\n}\n`;\n\nconst SHEEN_DIRECT_MOD = (intensityExpr: string): string => `\n{\nlet shIntensity = ${intensityExpr};\nlet shColorScaled = sheenColorFinal * shIntensity;\nlet shRoughness_clamped = max(sheenRoughnessAdjusted, AA_factor_x);\nlet shAlphaG = shRoughness_clamped * shRoughness_clamped + 0.0005;\nlet shD = normalDistributionFunction_CharlieSheen(NdotH, shAlphaG);\nlet shV = visibility_Ashikhmin(NdotL, NdotV);\nsheenDirectTerm = shColorScaled * shD * shV * NdotL * lightColor * lightAtten * material.directIntensity;\n}\n`;\n\nconst SHEEN_IBL_MOD = (intensityExpr: string, albedoScaling: boolean): string => `\n{\nlet shIntensity_ibl = ${intensityExpr};\nlet shColorScaled = sheenColorFinal * shIntensity_ibl;\nlet shRoughness_ibl = sheenRoughnessAdjusted;\nlet shAlphaG_ibl = shRoughness_ibl * shRoughness_ibl + 0.0005 + AA_factor_y;\nvar shSpecLod = log2(cubemapDim * shAlphaG_ibl) * scene.vImageInfos.z;\nlet shEnvRadiance = textureSampleLevel(iblTexture, iblSampler, R, clamp(shSpecLod, 0.0, maxLod)).rgb * material.environmentIntensity;\nlet shBrdf = textureSampleLevel(brdfLUT, brdfSampler_, vec2<f32>(NdotV, shRoughness_ibl), 0.0);\nlet shEnvReflectance = shColorScaled * shBrdf.b${albedoScaling ? \" * seo * eho\" : \"\"};\nsheenIblTerm = shEnvRadiance * shEnvReflectance;\n${albedoScaling ? \"let shMax = max(shColorScaled.r, max(shColorScaled.g, shColorScaled.b));\\nsheenAlbedoScaling = 1.0 - shMax * shBrdf.b;\" : \"\"}\n}\n`;\n\nconst SHEEN_IBL_COLOR_MOD = (albedoScaling: boolean): string =>\n    albedoScaling\n        ? `\n{\ncolor = (finalIrradiance\n      + finalRadianceScaled\n      + finalSpecularScaled\n      + directDiffuse) * sheenAlbedoScaling\n      + sheenDirectTerm\n      + sheenIblTerm\n      + emissive;\n}\n`\n        : `\n{\ncolor = finalIrradiance\n      + finalRadianceScaled\n      + finalSpecularScaled\n      + directDiffuse\n      + sheenDirectTerm\n      + sheenIblTerm\n      + emissive;\n}\n`;\n\nconst SHEEN_NON_IBL_MOD = `\n{\ncolor = color + sheenDirectTerm;\n}\n`;\n\n/**\n * Create a sheen fragment.\n * @param hasSheenTexture - Whether the material has a sheen texture.\n * @param hasIbl - Whether IBL is active for this pipeline.\n * @param hasAlbedoScaling - When true, uses BJS-spec sheen math (no F0 attenuation,\n *   proper base-layer albedo scaling, treats sheen texture as linear — upload\n *   as sRGB so the sampler does the conversion). When false (legacy), applies\n *   pow(rgb, 2.2) to the texture and uses (1-F0) as the sheen intensity scalar.\n */\nexport function createSheenFragment(hasSheenTexture: boolean, hasIbl: boolean = false, hasAlbedoScaling: boolean = false, hasSheenUvTx: boolean = false): ShaderFragment {\n    let scopeVars = `var sheenDirectTerm = vec3<f32>(0.0);\nvar sheenIblTerm = vec3<f32>(0.0);\nvar sheenAlbedoScaling = 1.0;\nvar sheenColorFinal = material.sheenParams.rgb;\nvar sheenRoughnessAdjusted = material.sheenParams2.x;`;\n    if (hasSheenTexture) {\n        const gammaStmt = hasAlbedoScaling ? \"sheenMapData.rgb\" : \"pow(sheenMapData.rgb, vec3<f32>(2.2))\";\n        const sheenUvDecl = hasSheenUvTx\n            ? \"let sheenUV = vec2<f32>(dot(material.sheenUVm.xy, input.uv), dot(material.sheenUVm.zw, input.uv)) + material.sheenUVt.xy;\"\n            : \"let sheenUV = input.uv;\";\n        scopeVars += `\n{\n${sheenUvDecl}\nlet sheenMapData = textureSample(sheenTexture_, sheenSampler_, sheenUV);\nsheenColorFinal *= ${gammaStmt};\nsheenRoughnessAdjusted *= sheenMapData.a;\n}`;\n    }\n\n    const intensityExpr = hasAlbedoScaling ? \"material.sheenParams.a\" : \"material.sheenParams.a * (1.0 - dielectricF0)\";\n    const slots: Partial<Record<string, string>> = {\n        SV: scopeVars,\n        AD: SHEEN_DIRECT_MOD(intensityExpr),\n    };\n    // AI and NI are mutually exclusive — only one path runs\n    if (hasIbl) {\n        slots.AI = SHEEN_IBL_MOD(intensityExpr, hasAlbedoScaling) + SHEEN_IBL_COLOR_MOD(hasAlbedoScaling);\n    } else {\n        slots.NI = SHEEN_NON_IBL_MOD;\n    }\n\n    const bindings: BindingDecl[] = [];\n    if (hasSheenTexture) {\n        bindings.push(\n            { _name: \"sheenTexture_\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"sheenSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n    }\n\n    const uboFields: UboField[] = [\n        { _name: \"sheenParams\", _type: \"vec4<f32>\" },\n        { _name: \"sheenParams2\", _type: \"vec4<f32>\" },\n    ];\n    if (hasSheenUvTx) {\n        uboFields.push({ _name: \"sheenUVm\", _type: \"vec4<f32>\" }, { _name: \"sheenUVt\", _type: \"vec4<f32>\" });\n    }\n\n    return {\n        _id: \"sheen\",\n        _dependencies: hasIbl ? [\"ibl\"] : undefined,\n\n        _uboFields: uboFields,\n\n        _bindings: bindings,\n\n        _helperFunctions: SHEEN_HELPERS,\n\n        _fragmentSlots: slots,\n    };\n}\n\n/** Write the sheen material-UBO slice (sheenParams, sheenParams2, optional UV transform). */\nexport function writeSheenUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    const sh = material.sheen as SheenProps | undefined;\n    if (!sh?.isEnabled || !offsets.has(\"sheenParams\")) {\n        return;\n    }\n    const off = offsets.get(\"sheenParams\")! / 4;\n    const color = sh.color ?? [1, 1, 1];\n    data[off] = color[0]!;\n    data[off + 1] = color[1]!;\n    data[off + 2] = color[2]!;\n    data[off + 3] = sh.intensity ?? 1.0;\n    data[off + 4] = sh.roughness ?? 0.0;\n    data[off + 5] = sh.texture ? 1.0 : 0.0;\n\n    // Optional per-texture UV transform (KHR_texture_transform on sheenColorTexture).\n    const mOff = offsets.get(\"sheenUVm\");\n    const tOff = offsets.get(\"sheenUVt\");\n    if (mOff === undefined || tOff === undefined) {\n        return;\n    }\n    const tex = sh.texture;\n    const sx = tex?.uScale ?? 1;\n    const sy = tex?.vScale ?? 1;\n    const ang = tex?.uAng ?? 0;\n    const ox = tex?.uOffset ?? 0;\n    const oy = tex?.vOffset ?? 0;\n    const mi = mOff / 4;\n    const ti = tOff / 4;\n    if (ang === 0) {\n        data[mi] = sx;\n        data[mi + 1] = 0;\n        data[mi + 2] = 0;\n        data[mi + 3] = sy;\n    } else {\n        const c = Math.cos(ang);\n        const s = Math.sin(ang);\n        data[mi] = c * sx;\n        data[mi + 1] = -s * sy;\n        data[mi + 2] = s * sx;\n        data[mi + 3] = c * sy;\n    }\n    data[ti] = ox;\n    data[ti + 1] = oy;\n    data[ti + 2] = 0;\n    data[ti + 3] = 0;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"sheen\",\n    phase: \"base-tex\",\n    detect(mat) {\n        const sh = (mat as PbrMaterialProps).sheen as SheenProps | undefined;\n        if (!sh?.isEnabled) {\n            return { f: 0, f2: 0 };\n        }\n        let f = PBR_HAS_SHEEN;\n        let f2 = 0;\n        if (sh.texture) {\n            f |= PBR_HAS_SHEEN_TEXTURE;\n            if ((sh.texture as { _hasTx?: boolean })._hasTx) {\n                f2 |= PBR2_HAS_SHEEN_UV_TX;\n            }\n        }\n        if (sh.albedoScaling) {\n            f |= PBR_HAS_SHEEN_ALBEDO_SCALING;\n        }\n        return { f, f2 };\n    },\n    frag(ctx) {\n        if (!(ctx._features & PBR_HAS_SHEEN)) {\n            return null;\n        }\n        return createSheenFragment(\n            (ctx._features & PBR_HAS_SHEEN_TEXTURE) !== 0,\n            ctx._hasIbl,\n            (ctx._features & PBR_HAS_SHEEN_ALBEDO_SCALING) !== 0,\n            (ctx._features2 & PBR2_HAS_SHEEN_UV_TX) !== 0\n        );\n    },\n    writeUbo: writeSheenUBO as PbrExt[\"writeUbo\"],\n    bind(ctx, entries, b) {\n        if ((ctx._features & PBR_HAS_SHEEN_TEXTURE) === 0) {\n            return b;\n        }\n        const sh = (ctx._material as PbrMaterialProps).sheen as SheenProps | undefined;\n        if (sh?.texture) {\n            entries.push({ binding: b++, resource: sh.texture.view });\n            entries.push({ binding: b++, resource: sh.texture.sampler });\n        }\n        return b;\n    },\n    textures(mat, out) {\n        const sh = (mat as PbrMaterialProps).sheen;\n        if (sh?.texture) {\n            out.push(sh.texture);\n        }\n    },\n};\n"],"names":[],"mappings":"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"}

package/simplex-perlin-3d-block-CcMtofzV.js

@@ -0,0 +1,58 @@
+const emitter = {
+  className: "SimplexPerlin3DBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const seed = ctx.cast(ctx.resolve(block, "seed", stage, state), "vec3f");
+    state[stage].helpers.set(
+      "nme_simplexPerlin3D",
+      `fn nme_simplexPerlin3D(source: vec3<f32>) -> f32 {
+let SKEWFACTOR = 1.0 / 3.0;
+let UNSKEWFACTOR = 1.0 / 6.0;
+let SIMPLEX_CORNER_POS = 0.5;
+let SIMPLEX_TETRAHEDRON_HEIGHT = 0.7071067811865476;
+var P = source;
+if (P.x == 0.0 && P.y == 0.0 && P.z == 0.0) {
+P.x = 0.00001;
+}
+P *= SIMPLEX_TETRAHEDRON_HEIGHT;
+var Pi = floor(P + dot(P, vec3<f32>(SKEWFACTOR)));
+let x0 = P - Pi + dot(Pi, vec3<f32>(UNSKEWFACTOR));
+let g = step(x0.yzx, x0.xyz);
+let l = vec3<f32>(1.0) - g;
+var Pi_1 = min(g.xyz, l.zxy);
+var Pi_2 = max(g.xyz, l.zxy);
+let x1 = x0 - Pi_1 + vec3<f32>(UNSKEWFACTOR);
+let x2 = x0 - Pi_2 + vec3<f32>(SKEWFACTOR);
+let x3 = x0 - vec3<f32>(SIMPLEX_CORNER_POS);
+let v1234_x = vec4<f32>(x0.x, x1.x, x2.x, x3.x);
+let v1234_y = vec4<f32>(x0.y, x1.y, x2.y, x3.y);
+let v1234_z = vec4<f32>(x0.z, x1.z, x2.z, x3.z);
+Pi = Pi - floor(Pi * (1.0 / 69.0)) * 69.0;
+let Pi_inc1 = step(Pi, vec3<f32>(69.0 - 1.5)) * (Pi + vec3<f32>(1.0));
+var Pt = vec4<f32>(Pi.x, Pi.y, Pi_inc1.x, Pi_inc1.y) + vec4<f32>(50.0, 161.0, 50.0, 161.0);
+Pt *= Pt;
+let V1xy_V2xy = mix(vec4<f32>(Pt.x, Pt.y, Pt.x, Pt.y), vec4<f32>(Pt.z, Pt.w, Pt.z, Pt.w), vec4<f32>(Pi_1.x, Pi_1.y, Pi_2.x, Pi_2.y));
+Pt = vec4<f32>(Pt.x, V1xy_V2xy.x, V1xy_V2xy.z, Pt.z) * vec4<f32>(Pt.y, V1xy_V2xy.y, V1xy_V2xy.w, Pt.w);
+let SOMELARGEFLOATS = vec3<f32>(635.298681, 682.357502, 668.926525);
+let ZINC = vec3<f32>(48.500388, 65.294118, 63.934599);
+let lowz_mods = vec3<f32>(1.0) / (SOMELARGEFLOATS + Pi.zzz * ZINC);
+let highz_mods = vec3<f32>(1.0) / (SOMELARGEFLOATS + Pi_inc1.zzz * ZINC);
+Pi_1 = select(highz_mods, lowz_mods, Pi_1.z < 0.5);
+Pi_2 = select(highz_mods, lowz_mods, Pi_2.z < 0.5);
+let hash_0 = fract(Pt * vec4<f32>(lowz_mods.x, Pi_1.x, Pi_2.x, highz_mods.x)) - vec4<f32>(0.49999);
+let hash_1 = fract(Pt * vec4<f32>(lowz_mods.y, Pi_1.y, Pi_2.y, highz_mods.y)) - vec4<f32>(0.49999);
+let hash_2 = fract(Pt * vec4<f32>(lowz_mods.z, Pi_1.z, Pi_2.z, highz_mods.z)) - vec4<f32>(0.49999);
+let grad_results = inverseSqrt(hash_0 * hash_0 + hash_1 * hash_1 + hash_2 * hash_2) * (hash_0 * v1234_x + hash_1 * v1234_y + hash_2 * v1234_z);
+let FINAL_NORMALIZATION = 37.837227241611314;
+var kernel_weights = v1234_x * v1234_x + v1234_y * v1234_y + v1234_z * v1234_z;
+kernel_weights = max(vec4<f32>(0.5) - kernel_weights, vec4<f32>(0.0));
+kernel_weights = kernel_weights * kernel_weights * kernel_weights;
+return dot(kernel_weights, grad_results) * FINAL_NORMALIZATION;
+}`
+    );
+    return { expr: `nme_simplexPerlin3D(${seed.expr})`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=simplex-perlin-3d-block-CcMtofzV.js.map

package/simplex-perlin-3d-block-CcMtofzV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplex-perlin-3d-block-CcMtofzV.js","sources":["../src/material/node/blocks/simplex-perlin-3d-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"SimplexPerlin3DBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const seed = ctx.cast(ctx.resolve(block, \"seed\", stage, state), \"vec3f\");\n        state[stage].helpers.set(\n            \"nme_simplexPerlin3D\",\n            `fn nme_simplexPerlin3D(source: vec3<f32>) -> f32 {\nlet SKEWFACTOR = 1.0 / 3.0;\nlet UNSKEWFACTOR = 1.0 / 6.0;\nlet SIMPLEX_CORNER_POS = 0.5;\nlet SIMPLEX_TETRAHEDRON_HEIGHT = 0.7071067811865476;\nvar P = source;\nif (P.x == 0.0 && P.y == 0.0 && P.z == 0.0) {\nP.x = 0.00001;\n}\nP *= SIMPLEX_TETRAHEDRON_HEIGHT;\nvar Pi = floor(P + dot(P, vec3<f32>(SKEWFACTOR)));\nlet x0 = P - Pi + dot(Pi, vec3<f32>(UNSKEWFACTOR));\nlet g = step(x0.yzx, x0.xyz);\nlet l = vec3<f32>(1.0) - g;\nvar Pi_1 = min(g.xyz, l.zxy);\nvar Pi_2 = max(g.xyz, l.zxy);\nlet x1 = x0 - Pi_1 + vec3<f32>(UNSKEWFACTOR);\nlet x2 = x0 - Pi_2 + vec3<f32>(SKEWFACTOR);\nlet x3 = x0 - vec3<f32>(SIMPLEX_CORNER_POS);\nlet v1234_x = vec4<f32>(x0.x, x1.x, x2.x, x3.x);\nlet v1234_y = vec4<f32>(x0.y, x1.y, x2.y, x3.y);\nlet v1234_z = vec4<f32>(x0.z, x1.z, x2.z, x3.z);\nPi = Pi - floor(Pi * (1.0 / 69.0)) * 69.0;\nlet Pi_inc1 = step(Pi, vec3<f32>(69.0 - 1.5)) * (Pi + vec3<f32>(1.0));\nvar Pt = vec4<f32>(Pi.x, Pi.y, Pi_inc1.x, Pi_inc1.y) + vec4<f32>(50.0, 161.0, 50.0, 161.0);\nPt *= Pt;\nlet V1xy_V2xy = mix(vec4<f32>(Pt.x, Pt.y, Pt.x, Pt.y), vec4<f32>(Pt.z, Pt.w, Pt.z, Pt.w), vec4<f32>(Pi_1.x, Pi_1.y, Pi_2.x, Pi_2.y));\nPt = vec4<f32>(Pt.x, V1xy_V2xy.x, V1xy_V2xy.z, Pt.z) * vec4<f32>(Pt.y, V1xy_V2xy.y, V1xy_V2xy.w, Pt.w);\nlet SOMELARGEFLOATS = vec3<f32>(635.298681, 682.357502, 668.926525);\nlet ZINC = vec3<f32>(48.500388, 65.294118, 63.934599);\nlet lowz_mods = vec3<f32>(1.0) / (SOMELARGEFLOATS + Pi.zzz * ZINC);\nlet highz_mods = vec3<f32>(1.0) / (SOMELARGEFLOATS + Pi_inc1.zzz * ZINC);\nPi_1 = select(highz_mods, lowz_mods, Pi_1.z < 0.5);\nPi_2 = select(highz_mods, lowz_mods, Pi_2.z < 0.5);\nlet hash_0 = fract(Pt * vec4<f32>(lowz_mods.x, Pi_1.x, Pi_2.x, highz_mods.x)) - vec4<f32>(0.49999);\nlet hash_1 = fract(Pt * vec4<f32>(lowz_mods.y, Pi_1.y, Pi_2.y, highz_mods.y)) - vec4<f32>(0.49999);\nlet hash_2 = fract(Pt * vec4<f32>(lowz_mods.z, Pi_1.z, Pi_2.z, highz_mods.z)) - vec4<f32>(0.49999);\nlet grad_results = inverseSqrt(hash_0 * hash_0 + hash_1 * hash_1 + hash_2 * hash_2) * (hash_0 * v1234_x + hash_1 * v1234_y + hash_2 * v1234_z);\nlet FINAL_NORMALIZATION = 37.837227241611314;\nvar kernel_weights = v1234_x * v1234_x + v1234_y * v1234_y + v1234_z * v1234_z;\nkernel_weights = max(vec4<f32>(0.5) - kernel_weights, vec4<f32>(0.0));\nkernel_weights = kernel_weights * kernel_weights * kernel_weights;\nreturn dot(kernel_weights, grad_results) * FINAL_NORMALIZATION;\n}`\n        );\n        return { expr: `nme_simplexPerlin3D(${seed.expr})`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,OAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK,GAAG,OAAO;AACvE,UAAM,KAAK,EAAE,QAAQ;AAAA,MACjB;AAAA,MACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AA6CJ,WAAO,EAAE,MAAM,uBAAuB,KAAK,IAAI,KAAK,MAAM,MAAA;AAAA,EAC9D;AACJ;"}

package/singlelight-directional-wgsl-CmUDZxwz.js

@@ -0,0 +1,39 @@
+import { M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+const SINGLE_LIGHT_STRUCTS = `
+struct LightEntry {
+vLightData: vec4<f32>,
+vLightDiffuse: vec4<f32>,
+vLightSpecular: vec4<f32>,
+vLightDirection: vec4<f32>,
+};
+struct lightsUniforms {
+count: u32, _p0: u32, _p1: u32, _p2: u32,
+    lights: array<LightEntry, ${MAX_LIGHTS}>,
+};
+`;
+function specularBlock() {
+  return `let H = normalize(V + L);
+let NdotH = clamp(dot(N, H), 0.0000001, 1.0);
+let VdotH = saturate(dot(V, H));
+let directRoughness = max(roughness, AA_factor_x);
+let directAlphaG = directRoughness * directRoughness + 0.0005;
+let D = distributionGGX(NdotH, directAlphaG);
+let G = geometrySmithGGX(NdotL, NdotV, directAlphaG);
+let coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);
+var directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;
+}
+function getSingleLightBlock() {
+  return `let entry = lights.lights[mli(0u)];
+let L = normalize(-entry.vLightData.xyz);
+let NdotL = max(dot(N, L), 0.0);
+let lightAtten = 1.0;
+let lightColor = entry.vLightDiffuse.rgb;
+var directDiffuse = surfaceAlbedo * (1.0 / PI) * NdotL * lightColor * material.directIntensity;
+${specularBlock()}
+/*AD*/`;
+}
+export {
+  SINGLE_LIGHT_STRUCTS,
+  getSingleLightBlock
+};
+//# sourceMappingURL=singlelight-directional-wgsl-CmUDZxwz.js.map

package/singlelight-directional-wgsl-CmUDZxwz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singlelight-directional-wgsl-CmUDZxwz.js","sources":["../src/material/pbr/fragments/singlelight-directional-wgsl.ts"],"sourcesContent":["/** Single directional-light WGSL helpers for the PBR template. */\n\nimport { MAX_LIGHTS } from \"../../../light/types.js\";\n\nexport const SINGLE_LIGHT_STRUCTS = `\nstruct LightEntry {\nvLightData: vec4<f32>,\nvLightDiffuse: vec4<f32>,\nvLightSpecular: vec4<f32>,\nvLightDirection: vec4<f32>,\n};\nstruct lightsUniforms {\ncount: u32, _p0: u32, _p1: u32, _p2: u32,\n    lights: array<LightEntry, ${MAX_LIGHTS}>,\n};\n`;\n\nfunction specularBlock(): string {\n    return `let H = normalize(V + L);\nlet NdotH = clamp(dot(N, H), 0.0000001, 1.0);\nlet VdotH = saturate(dot(V, H));\nlet directRoughness = max(roughness, AA_factor_x);\nlet directAlphaG = directRoughness * directRoughness + 0.0005;\nlet D = distributionGGX(NdotH, directAlphaG);\nlet G = geometrySmithGGX(NdotL, NdotV, directAlphaG);\nlet coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);\nvar directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;\n}\n\nexport function getSingleLightBlock(): string {\n    return `let entry = lights.lights[mli(0u)];\nlet L = normalize(-entry.vLightData.xyz);\nlet NdotL = max(dot(N, L), 0.0);\nlet lightAtten = 1.0;\nlet lightColor = entry.vLightDiffuse.rgb;\nvar directDiffuse = surfaceAlbedo * (1.0 / PI) * NdotL * lightColor * material.directIntensity;\n${specularBlock()}\n/*AD*/`;\n}\n"],"names":[],"mappings":";AAIO,MAAM,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCASJ,UAAU;AAAA;AAAA;AAI1C,SAAS,gBAAwB;AAC7B,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASX;AAEO,SAAS,sBAA8B;AAC1C,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMT,eAAe;AAAA;AAEjB;"}

package/singlelight-hemispheric-wgsl-t-83IP_s.js

@@ -0,0 +1,40 @@
+import { M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+const SINGLE_LIGHT_STRUCTS = `
+struct LightEntry {
+vLightData: vec4<f32>,
+vLightDiffuse: vec4<f32>,
+vLightSpecular: vec4<f32>,
+vLightDirection: vec4<f32>,
+};
+struct lightsUniforms {
+count: u32, _p0: u32, _p1: u32, _p2: u32,
+    lights: array<LightEntry, ${MAX_LIGHTS}>,
+};
+`;
+function specularBlock() {
+  return `let H = normalize(V + L);
+let NdotH = clamp(dot(N, H), 0.0000001, 1.0);
+let VdotH = saturate(dot(V, H));
+let directRoughness = max(roughness, AA_factor_x);
+let directAlphaG = directRoughness * directRoughness + 0.0005;
+let D = distributionGGX(NdotH, directAlphaG);
+let G = geometrySmithGGX(NdotL, NdotV, directAlphaG);
+let coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);
+var directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;
+}
+function getSingleLightBlock() {
+  return `let entry = lights.lights[mli(0u)];
+let L = normalize(entry.vLightData.xyz);
+let NdotL = dot(N, L) * 0.5 + 0.5;
+let lightAtten = 1.0;
+let lightColor = entry.vLightDiffuse.rgb;
+let hemiDiffuse = mix(entry.vLightDirection.xyz, lightColor, NdotL);
+var directDiffuse = hemiDiffuse * surfaceAlbedo * material.directIntensity;
+${specularBlock()}
+/*AD*/`;
+}
+export {
+  SINGLE_LIGHT_STRUCTS,
+  getSingleLightBlock
+};
+//# sourceMappingURL=singlelight-hemispheric-wgsl-t-83IP_s.js.map

package/singlelight-hemispheric-wgsl-t-83IP_s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singlelight-hemispheric-wgsl-t-83IP_s.js","sources":["../src/material/pbr/fragments/singlelight-hemispheric-wgsl.ts"],"sourcesContent":["/** Single hemispheric-light WGSL helpers for the PBR template. */\n\nimport { MAX_LIGHTS } from \"../../../light/types.js\";\n\nexport const SINGLE_LIGHT_STRUCTS = `\nstruct LightEntry {\nvLightData: vec4<f32>,\nvLightDiffuse: vec4<f32>,\nvLightSpecular: vec4<f32>,\nvLightDirection: vec4<f32>,\n};\nstruct lightsUniforms {\ncount: u32, _p0: u32, _p1: u32, _p2: u32,\n    lights: array<LightEntry, ${MAX_LIGHTS}>,\n};\n`;\n\nfunction specularBlock(): string {\n    return `let H = normalize(V + L);\nlet NdotH = clamp(dot(N, H), 0.0000001, 1.0);\nlet VdotH = saturate(dot(V, H));\nlet directRoughness = max(roughness, AA_factor_x);\nlet directAlphaG = directRoughness * directRoughness + 0.0005;\nlet D = distributionGGX(NdotH, directAlphaG);\nlet G = geometrySmithGGX(NdotL, NdotV, directAlphaG);\nlet coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);\nvar directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;\n}\n\nexport function getSingleLightBlock(): string {\n    return `let entry = lights.lights[mli(0u)];\nlet L = normalize(entry.vLightData.xyz);\nlet NdotL = dot(N, L) * 0.5 + 0.5;\nlet lightAtten = 1.0;\nlet lightColor = entry.vLightDiffuse.rgb;\nlet hemiDiffuse = mix(entry.vLightDirection.xyz, lightColor, NdotL);\nvar directDiffuse = hemiDiffuse * surfaceAlbedo * material.directIntensity;\n${specularBlock()}\n/*AD*/`;\n}\n"],"names":[],"mappings":";AAIO,MAAM,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCASJ,UAAU;AAAA;AAAA;AAI1C,SAAS,gBAAwB;AAC7B,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASX;AAEO,SAAS,sBAA8B;AAC1C,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,eAAe;AAAA;AAEjB;"}

package/singlelight-point-wgsl-CLzULIYV.js

@@ -0,0 +1,45 @@
+import { M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+const SINGLE_LIGHT_STRUCTS = `
+struct LightEntry {
+vLightData: vec4<f32>,
+vLightDiffuse: vec4<f32>,
+vLightSpecular: vec4<f32>,
+vLightDirection: vec4<f32>,
+};
+struct lightsUniforms {
+count: u32, _p0: u32, _p1: u32, _p2: u32,
+    lights: array<LightEntry, ${MAX_LIGHTS}>,
+};
+`;
+function specularBlock() {
+  return `let H = normalize(V + L);
+let NdotH = clamp(dot(N, H), 0.0000001, 1.0);
+let VdotH = saturate(dot(V, H));
+let directRoughness = max(roughness, AA_factor_x);
+let directAlphaG = directRoughness * directRoughness + 0.0005;
+let D = distributionGGX(NdotH, directAlphaG);
+let G = geometrySmithGGX(NdotL, NdotV, directAlphaG);
+let coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);
+var directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;
+}
+function getSingleLightBlock() {
+  return `let entry = lights.lights[mli(0u)];
+let lightToFrag = entry.vLightData.xyz - input.worldPos;
+let lightDist2 = dot(lightToFrag, lightToFrag);
+let L = normalize(lightToFrag);
+let NdotL = max(dot(N, L), 0.0);
+let range = entry.vLightDiffuse.a;
+let physicalFalloff = material.lightFalloffMode >= 0.5;
+let physicalAtten = 1.0 / max(lightDist2, 0.0001);
+let standardAtten = max(0.0, 1.0 - sqrt(lightDist2) / range);
+let lightAtten = select(standardAtten, physicalAtten, physicalFalloff);
+let lightColor = entry.vLightDiffuse.rgb;
+var directDiffuse = surfaceAlbedo * (1.0 / PI) * NdotL * lightColor * lightAtten * material.directIntensity;
+${specularBlock()}
+/*AD*/`;
+}
+export {
+  SINGLE_LIGHT_STRUCTS,
+  getSingleLightBlock
+};
+//# sourceMappingURL=singlelight-point-wgsl-CLzULIYV.js.map

package/singlelight-point-wgsl-CLzULIYV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singlelight-point-wgsl-CLzULIYV.js","sources":["../src/material/pbr/fragments/singlelight-point-wgsl.ts"],"sourcesContent":["/** Single point-light WGSL helpers for the PBR template. */\n\nimport { MAX_LIGHTS } from \"../../../light/types.js\";\n\nexport const SINGLE_LIGHT_STRUCTS = `\nstruct LightEntry {\nvLightData: vec4<f32>,\nvLightDiffuse: vec4<f32>,\nvLightSpecular: vec4<f32>,\nvLightDirection: vec4<f32>,\n};\nstruct lightsUniforms {\ncount: u32, _p0: u32, _p1: u32, _p2: u32,\n    lights: array<LightEntry, ${MAX_LIGHTS}>,\n};\n`;\n\nfunction specularBlock(): string {\n    return `let H = normalize(V + L);\nlet NdotH = clamp(dot(N, H), 0.0000001, 1.0);\nlet VdotH = saturate(dot(V, H));\nlet directRoughness = max(roughness, AA_factor_x);\nlet directAlphaG = directRoughness * directRoughness + 0.0005;\nlet D = distributionGGX(NdotH, directAlphaG);\nlet G = geometrySmithGGX(NdotL, NdotV, directAlphaG);\nlet coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);\nvar directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;\n}\n\nexport function getSingleLightBlock(): string {\n    return `let entry = lights.lights[mli(0u)];\nlet lightToFrag = entry.vLightData.xyz - input.worldPos;\nlet lightDist2 = dot(lightToFrag, lightToFrag);\nlet L = normalize(lightToFrag);\nlet NdotL = max(dot(N, L), 0.0);\nlet range = entry.vLightDiffuse.a;\nlet physicalFalloff = material.lightFalloffMode >= 0.5;\nlet physicalAtten = 1.0 / max(lightDist2, 0.0001);\nlet standardAtten = max(0.0, 1.0 - sqrt(lightDist2) / range);\nlet lightAtten = select(standardAtten, physicalAtten, physicalFalloff);\nlet lightColor = entry.vLightDiffuse.rgb;\nvar directDiffuse = surfaceAlbedo * (1.0 / PI) * NdotL * lightColor * lightAtten * material.directIntensity;\n${specularBlock()}\n/*AD*/`;\n}\n"],"names":[],"mappings":";AAIO,MAAM,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCASJ,UAAU;AAAA;AAAA;AAI1C,SAAS,gBAAwB;AAC7B,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASX;AAEO,SAAS,sBAA8B;AAC1C,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYT,eAAe;AAAA;AAEjB;"}