@babylonjs/lite 0.1.1

package/iridescence-fragment-Gymp7or5.js

@@ -0,0 +1,243 @@
+import { aE as PBR2_HAS_IRIDESCENCE_MAP, aF as PBR2_HAS_IRIDESCENCE_THICKNESS_MAP, aG as PBR2_HAS_IRIDESCENCE, aq as PBR_HAS_METALLIC_REFLECTANCE_MAP, ar as PBR_HAS_REFLECTANCE_MAP, as as PBR2_HAS_REFLECTANCE_FACTORS } from "./index-C8HOR2sB.js";
+const STAGE_FRAGMENT = 2;
+const PBR2_HAS_IRIDESCENCE_UV_TX = 1 << 20;
+const PBR2_HAS_IRIDESCENCE_THICKNESS_UV_TX = 1 << 21;
+const PBR2_HAS_IRIDESCENCE_UV2 = 1 << 22;
+const PBR2_HAS_IRIDESCENCE_THICKNESS_UV2 = 1 << 23;
+const IRI_MSH_HAS_UV2 = 1 << 7;
+const IRIDESCENCE_HELPERS = `const IRI_XYZ_TO_REC709:mat3x3<f32>=mat3x3<f32>(
+3.2404542,-0.9692660,0.0556434,
+-1.5371385,1.8760108,-0.2040259,
+-0.4985314,0.0415560,1.0572252);
+fn iri_square3(x:vec3<f32>)->vec3<f32>{return x*x;}
+fn iri_iorFromAirF0(f0:vec3<f32>)->vec3<f32>{
+let s=sqrt(clamp(f0,vec3<f32>(0.0),vec3<f32>(0.9999)));
+return (vec3<f32>(1.0)+s)/(vec3<f32>(1.0)-s);
+}
+fn iri_r0FromIor3(iorT:vec3<f32>,iorI:f32)->vec3<f32>{return iri_square3((iorT-vec3<f32>(iorI))/(iorT+vec3<f32>(iorI)));}
+fn iri_r0FromIor(iorT:f32,iorI:f32)->f32{let r=(iorT-iorI)/(iorT+iorI);return r*r;}
+fn iri_fresSchlick(c:f32,F0:vec3<f32>,F90:vec3<f32>)->vec3<f32>{
+let t=1.0-c;
+let t2=t*t;
+return F0+(F90-F0)*(t2*t2*t);
+}
+fn iri_evalSensitivity(opd:f32,shift:vec3<f32>)->vec3<f32>{
+let phase=6.283185307179586*opd*1.0e-9;
+let val=vec3<f32>(5.4856e-13,4.4201e-13,5.2481e-13);
+let pos=vec3<f32>(1.6810e+06,1.7953e+06,2.2084e+06);
+let vr=vec3<f32>(4.3278e+09,9.3046e+09,6.6121e+09);
+var xyz=val*sqrt(6.283185307179586*vr)*cos(pos*phase+shift)*exp(-(phase*phase)*vr);
+xyz.x=xyz.x+9.7470e-14*sqrt(6.283185307179586*4.5282e+09)*cos(2.2399e+06*phase+shift.x)*exp(-4.5282e+09*phase*phase);
+xyz=xyz/1.0685e-7;
+return IRI_XYZ_TO_REC709*xyz;
+}
+fn iri_eval(outsideIor:f32,eta2:f32,cosTheta1:f32,thickness:f32,baseF0:vec3<f32>)->vec3<f32>{
+let iridescenceIor=mix(outsideIor,eta2,smoothstep(0.0,0.03,thickness));
+let eta=outsideIor/iridescenceIor;
+let sinTheta2Sq=eta*eta*(1.0-cosTheta1*cosTheta1);
+let cosTheta2Sq=1.0-sinTheta2Sq;
+if(cosTheta2Sq<0.0){return vec3<f32>(1.0);}
+let cosTheta2=sqrt(cosTheta2Sq);
+let r0=iri_r0FromIor(iridescenceIor,outsideIor);
+let r12=iri_fresSchlick(cosTheta1,vec3<f32>(r0),vec3<f32>(1.0)).x;
+let t121=1.0-r12;
+var phi12=0.0;
+if(iridescenceIor<outsideIor){phi12=3.141592653589793;}
+let phi21=3.141592653589793-phi12;
+let baseIor=iri_iorFromAirF0(baseF0);
+let r1=iri_r0FromIor3(baseIor,iridescenceIor);
+let r23=iri_fresSchlick(cosTheta2,r1,vec3<f32>(1.0));
+var phi23=vec3<f32>(0.0);
+if(baseIor.x<iridescenceIor){phi23.x=3.141592653589793;}
+if(baseIor.y<iridescenceIor){phi23.y=3.141592653589793;}
+if(baseIor.z<iridescenceIor){phi23.z=3.141592653589793;}
+let opd=2.0*iridescenceIor*thickness*cosTheta2;
+let phi=vec3<f32>(phi21)+phi23;
+let r123=clamp(vec3<f32>(r12)*r23,vec3<f32>(1e-5),vec3<f32>(0.9999));
+let smallR123=sqrt(r123);
+let rs=(t121*t121)*r23/(vec3<f32>(1.0)-r123);
+var outI=vec3<f32>(r12)+rs;
+var cm=rs-vec3<f32>(t121);
+for(var m:i32=1;m<=2;m=m+1){
+cm=cm*smallR123;
+outI=outI+cm*(2.0*iri_evalSensitivity(f32(m)*opd,f32(m)*phi));
+}
+return max(outI,vec3<f32>(0.0));
+}`;
+const IRI_TEX = [
+  [PBR2_HAS_IRIDESCENCE_MAP, "texture"],
+  [PBR2_HAS_IRIDESCENCE_THICKNESS_MAP, "thicknessTexture"]
+];
+function uvBaseExpr(features2, meshFeatures, uv2Flag) {
+  return (features2 & uv2Flag) !== 0 && (meshFeatures & IRI_MSH_HAS_UV2) !== 0 ? "input.uv2" : "input.uv";
+}
+function uvDecl(name, baseUv, hasTx) {
+  return hasTx ? `let ${name}=vec2<f32>(dot(material.${name}m.xy,${baseUv}),dot(material.${name}m.zw,${baseUv}))+material.${name}t.xy;` : `let ${name}=${baseUv};`;
+}
+function uvTransformUboFields(name) {
+  return [
+    { _name: `${name}m`, _type: "vec4<f32>" },
+    { _name: `${name}t`, _type: "vec4<f32>" }
+  ];
+}
+function writeUvTransform(data, offsets, name, tex) {
+  const mOff = offsets.get(`${name}m`);
+  const tOff = offsets.get(`${name}t`);
+  if (mOff === void 0 || tOff === void 0) {
+    return;
+  }
+  const mi = mOff / 4;
+  const ti = tOff / 4;
+  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;
+  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;
+}
+function createIridescenceFragment(features, features2, meshFeatures) {
+  if ((features2 & PBR2_HAS_IRIDESCENCE) === 0) {
+    return null;
+  }
+  const hasIntensityMap = (features2 & PBR2_HAS_IRIDESCENCE_MAP) !== 0;
+  const hasThicknessMap = (features2 & PBR2_HAS_IRIDESCENCE_THICKNESS_MAP) !== 0;
+  const hasIntensityUvTx = (features2 & PBR2_HAS_IRIDESCENCE_UV_TX) !== 0;
+  const hasThicknessUvTx = (features2 & PBR2_HAS_IRIDESCENCE_THICKNESS_UV_TX) !== 0;
+  const bindings = [];
+  const uboFields = [{ _name: "iridescenceParams", _type: "vec4<f32>" }];
+  if (hasIntensityMap) {
+    bindings.push(
+      { _name: "iridescenceTexture", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "iridescenceSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+    if (hasIntensityUvTx) {
+      uboFields.push(...uvTransformUboFields("iridescenceUV"));
+    }
+  }
+  if (hasThicknessMap) {
+    bindings.push(
+      { _name: "iridescenceThicknessTexture", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "iridescenceThicknessSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+    if (hasThicknessUvTx) {
+      uboFields.push(...uvTransformUboFields("iridescenceThicknessUV"));
+    }
+  }
+  const scopeVars = [];
+  if (hasIntensityMap) {
+    scopeVars.push(uvDecl("iridescenceUV", uvBaseExpr(features2, meshFeatures, PBR2_HAS_IRIDESCENCE_UV2), hasIntensityUvTx));
+  }
+  if (hasThicknessMap) {
+    scopeVars.push(uvDecl("iridescenceThicknessUV", uvBaseExpr(features2, meshFeatures, PBR2_HAS_IRIDESCENCE_THICKNESS_UV2), hasThicknessUvTx));
+  }
+  const intensity = hasIntensityMap ? "material.iridescenceParams.x*textureSample(iridescenceTexture,iridescenceSampler_,iridescenceUV).r" : "material.iridescenceParams.x";
+  const thickness = hasThicknessMap ? "mix(material.iridescenceParams.z,material.iridescenceParams.w,textureSample(iridescenceThicknessTexture,iridescenceThicknessSampler_,iridescenceThicknessUV).g)" : "material.iridescenceParams.w";
+  return {
+    _id: "iridescence",
+    _dependencies: (features & (PBR_HAS_METALLIC_REFLECTANCE_MAP | PBR_HAS_REFLECTANCE_MAP)) !== 0 || (features2 & PBR2_HAS_REFLECTANCE_FACTORS) !== 0 ? ["reflectance"] : void 0,
+    _uboFields: uboFields,
+    _bindings: bindings,
+    _helperFunctions: IRIDESCENCE_HELPERS,
+    _fragmentSlots: {
+      ...scopeVars.length ? { SV: scopeVars.join("\n") } : void 0,
+      MF: `{
+let iriIntensity=clamp(${intensity},0.0,1.0);
+let iriThickness=max(${thickness},0.0);
+let iriF0=iri_eval(1.0,max(material.iridescenceParams.y,1.0001),NdotV,iriThickness,colorF0);
+colorF0=mix(colorF0,iriF0,iriIntensity);
+}`
+    }
+  };
+}
+function writeIridescenceUBO(data, material, offsets) {
+  const iri = material.iridescence;
+  if (!(iri == null ? void 0 : iri.isEnabled) || !offsets.has("iridescenceParams")) {
+    return;
+  }
+  const off = offsets.get("iridescenceParams") / 4;
+  data[off] = iri.intensity ?? 1;
+  data[off + 1] = iri.indexOfRefraction ?? 1.3;
+  data[off + 2] = iri.minimumThickness ?? 100;
+  data[off + 3] = iri.maximumThickness ?? 400;
+  writeUvTransform(data, offsets, "iridescenceUV", iri.texture);
+  writeUvTransform(data, offsets, "iridescenceThicknessUV", iri.thicknessTexture);
+}
+const pbrExt = {
+  id: "iridescence",
+  phase: "base-tex",
+  detect(mat) {
+    const iri = mat.iridescence;
+    if (!(iri == null ? void 0 : iri.isEnabled)) {
+      return { f: 0, f2: 0 };
+    }
+    let f2 = PBR2_HAS_IRIDESCENCE;
+    if (iri.texture) {
+      f2 |= PBR2_HAS_IRIDESCENCE_MAP;
+      if (iri.texture._hasTx) {
+        f2 |= PBR2_HAS_IRIDESCENCE_UV_TX;
+      }
+      if (iri.texture._texCoord === 1) {
+        f2 |= PBR2_HAS_IRIDESCENCE_UV2;
+      }
+    }
+    if (iri.thicknessTexture) {
+      f2 |= PBR2_HAS_IRIDESCENCE_THICKNESS_MAP;
+      if (iri.thicknessTexture._hasTx) {
+        f2 |= PBR2_HAS_IRIDESCENCE_THICKNESS_UV_TX;
+      }
+      if (iri.thicknessTexture._texCoord === 1) {
+        f2 |= PBR2_HAS_IRIDESCENCE_THICKNESS_UV2;
+      }
+    }
+    return { f: 0, f2 };
+  },
+  frag: (ctx) => createIridescenceFragment(ctx._features, ctx._features2, ctx._meshFeatures),
+  writeUbo: writeIridescenceUBO,
+  bind(ctx, entries, b) {
+    const iri = ctx._material.iridescence;
+    if (!iri) {
+      return b;
+    }
+    for (const [flag, key] of IRI_TEX) {
+      const tex = iri[key];
+      if ((ctx._features2 & flag) !== 0 && tex) {
+        entries.push({ binding: b++, resource: tex.view });
+        entries.push({ binding: b++, resource: tex.sampler });
+      }
+    }
+    return b;
+  },
+  textures(mat, t) {
+    const iri = mat.iridescence;
+    if (!iri) {
+      return;
+    }
+    for (const [, key] of IRI_TEX) {
+      const tex = iri[key];
+      if (tex) {
+        t.push(tex);
+      }
+    }
+  }
+};
+export {
+  pbrExt,
+  writeIridescenceUBO
+};
+//# sourceMappingURL=iridescence-fragment-Gymp7or5.js.map

package/iridescence-fragment-Gymp7or5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iridescence-fragment-Gymp7or5.js","sources":["../src/material/pbr/fragments/iridescence-fragment.ts"],"sourcesContent":["/**\n * Iridescence Fragment\n *\n * Native PBR thin-film iridescence (BJS PBRMaterial.iridescence and\n * KHR_materials_iridescence). Modifies the already-computed base-layer colorF0\n * before direct and IBL lighting consume it.\n */\n\nimport type { BindingDecl, ShaderFragment, UboField } from \"../../../shader/fragment-types.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport type { IridescenceProps, PbrMaterialProps } from \"../pbr-material.js\";\nimport {\n    PBR_HAS_METALLIC_REFLECTANCE_MAP,\n    PBR_HAS_REFLECTANCE_MAP,\n    PBR2_HAS_IRIDESCENCE,\n    PBR2_HAS_IRIDESCENCE_MAP,\n    PBR2_HAS_IRIDESCENCE_THICKNESS_MAP,\n    PBR2_HAS_REFLECTANCE_FACTORS,\n} from \"../pbr-flag-bits.js\";\n\nconst STAGE_FRAGMENT = 0x2;\nconst PBR2_HAS_IRIDESCENCE_UV_TX = 1 << 20;\nconst PBR2_HAS_IRIDESCENCE_THICKNESS_UV_TX = 1 << 21;\nconst PBR2_HAS_IRIDESCENCE_UV2 = 1 << 22;\nconst PBR2_HAS_IRIDESCENCE_THICKNESS_UV2 = 1 << 23;\nconst IRI_MSH_HAS_UV2 = 1 << 7;\n\nconst IRIDESCENCE_HELPERS = `const IRI_XYZ_TO_REC709:mat3x3<f32>=mat3x3<f32>(\n3.2404542,-0.9692660,0.0556434,\n-1.5371385,1.8760108,-0.2040259,\n-0.4985314,0.0415560,1.0572252);\nfn iri_square3(x:vec3<f32>)->vec3<f32>{return x*x;}\nfn iri_iorFromAirF0(f0:vec3<f32>)->vec3<f32>{\nlet s=sqrt(clamp(f0,vec3<f32>(0.0),vec3<f32>(0.9999)));\nreturn (vec3<f32>(1.0)+s)/(vec3<f32>(1.0)-s);\n}\nfn iri_r0FromIor3(iorT:vec3<f32>,iorI:f32)->vec3<f32>{return iri_square3((iorT-vec3<f32>(iorI))/(iorT+vec3<f32>(iorI)));}\nfn iri_r0FromIor(iorT:f32,iorI:f32)->f32{let r=(iorT-iorI)/(iorT+iorI);return r*r;}\nfn iri_fresSchlick(c:f32,F0:vec3<f32>,F90:vec3<f32>)->vec3<f32>{\nlet t=1.0-c;\nlet t2=t*t;\nreturn F0+(F90-F0)*(t2*t2*t);\n}\nfn iri_evalSensitivity(opd:f32,shift:vec3<f32>)->vec3<f32>{\nlet phase=6.283185307179586*opd*1.0e-9;\nlet val=vec3<f32>(5.4856e-13,4.4201e-13,5.2481e-13);\nlet pos=vec3<f32>(1.6810e+06,1.7953e+06,2.2084e+06);\nlet vr=vec3<f32>(4.3278e+09,9.3046e+09,6.6121e+09);\nvar xyz=val*sqrt(6.283185307179586*vr)*cos(pos*phase+shift)*exp(-(phase*phase)*vr);\nxyz.x=xyz.x+9.7470e-14*sqrt(6.283185307179586*4.5282e+09)*cos(2.2399e+06*phase+shift.x)*exp(-4.5282e+09*phase*phase);\nxyz=xyz/1.0685e-7;\nreturn IRI_XYZ_TO_REC709*xyz;\n}\nfn iri_eval(outsideIor:f32,eta2:f32,cosTheta1:f32,thickness:f32,baseF0:vec3<f32>)->vec3<f32>{\nlet iridescenceIor=mix(outsideIor,eta2,smoothstep(0.0,0.03,thickness));\nlet eta=outsideIor/iridescenceIor;\nlet sinTheta2Sq=eta*eta*(1.0-cosTheta1*cosTheta1);\nlet cosTheta2Sq=1.0-sinTheta2Sq;\nif(cosTheta2Sq<0.0){return vec3<f32>(1.0);}\nlet cosTheta2=sqrt(cosTheta2Sq);\nlet r0=iri_r0FromIor(iridescenceIor,outsideIor);\nlet r12=iri_fresSchlick(cosTheta1,vec3<f32>(r0),vec3<f32>(1.0)).x;\nlet t121=1.0-r12;\nvar phi12=0.0;\nif(iridescenceIor<outsideIor){phi12=3.141592653589793;}\nlet phi21=3.141592653589793-phi12;\nlet baseIor=iri_iorFromAirF0(baseF0);\nlet r1=iri_r0FromIor3(baseIor,iridescenceIor);\nlet r23=iri_fresSchlick(cosTheta2,r1,vec3<f32>(1.0));\nvar phi23=vec3<f32>(0.0);\nif(baseIor.x<iridescenceIor){phi23.x=3.141592653589793;}\nif(baseIor.y<iridescenceIor){phi23.y=3.141592653589793;}\nif(baseIor.z<iridescenceIor){phi23.z=3.141592653589793;}\nlet opd=2.0*iridescenceIor*thickness*cosTheta2;\nlet phi=vec3<f32>(phi21)+phi23;\nlet r123=clamp(vec3<f32>(r12)*r23,vec3<f32>(1e-5),vec3<f32>(0.9999));\nlet smallR123=sqrt(r123);\nlet rs=(t121*t121)*r23/(vec3<f32>(1.0)-r123);\nvar outI=vec3<f32>(r12)+rs;\nvar cm=rs-vec3<f32>(t121);\nfor(var m:i32=1;m<=2;m=m+1){\ncm=cm*smallR123;\noutI=outI+cm*(2.0*iri_evalSensitivity(f32(m)*opd,f32(m)*phi));\n}\nreturn max(outI,vec3<f32>(0.0));\n}`;\n\nconst IRI_TEX: ReadonlyArray<readonly [number, \"texture\" | \"thicknessTexture\"]> = [\n    [PBR2_HAS_IRIDESCENCE_MAP, \"texture\"],\n    [PBR2_HAS_IRIDESCENCE_THICKNESS_MAP, \"thicknessTexture\"],\n];\n\nfunction uvBaseExpr(features2: number, meshFeatures: number, uv2Flag: number): string {\n    return (features2 & uv2Flag) !== 0 && (meshFeatures & IRI_MSH_HAS_UV2) !== 0 ? \"input.uv2\" : \"input.uv\";\n}\n\nfunction uvDecl(name: string, baseUv: string, hasTx: boolean): string {\n    return hasTx ? `let ${name}=vec2<f32>(dot(material.${name}m.xy,${baseUv}),dot(material.${name}m.zw,${baseUv}))+material.${name}t.xy;` : `let ${name}=${baseUv};`;\n}\n\nfunction uvTransformUboFields(name: string): UboField[] {\n    return [\n        { _name: `${name}m`, _type: \"vec4<f32>\" },\n        { _name: `${name}t`, _type: \"vec4<f32>\" },\n    ];\n}\n\nfunction writeUvTransform(data: Float32Array, offsets: ReadonlyMap<string, number>, name: string, tex: Texture2D | undefined): void {\n    const mOff = offsets.get(`${name}m`);\n    const tOff = offsets.get(`${name}t`);\n    if (mOff === undefined || tOff === undefined) {\n        return;\n    }\n    const mi = mOff / 4;\n    const ti = tOff / 4;\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    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\nfunction createIridescenceFragment(features: number, features2: number, meshFeatures: number): ShaderFragment | null {\n    if ((features2 & PBR2_HAS_IRIDESCENCE) === 0) {\n        return null;\n    }\n    const hasIntensityMap = (features2 & PBR2_HAS_IRIDESCENCE_MAP) !== 0;\n    const hasThicknessMap = (features2 & PBR2_HAS_IRIDESCENCE_THICKNESS_MAP) !== 0;\n    const hasIntensityUvTx = (features2 & PBR2_HAS_IRIDESCENCE_UV_TX) !== 0;\n    const hasThicknessUvTx = (features2 & PBR2_HAS_IRIDESCENCE_THICKNESS_UV_TX) !== 0;\n    const bindings: BindingDecl[] = [];\n    const uboFields: UboField[] = [{ _name: \"iridescenceParams\", _type: \"vec4<f32>\" }];\n    if (hasIntensityMap) {\n        bindings.push(\n            { _name: \"iridescenceTexture\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"iridescenceSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n        if (hasIntensityUvTx) {\n            uboFields.push(...uvTransformUboFields(\"iridescenceUV\"));\n        }\n    }\n    if (hasThicknessMap) {\n        bindings.push(\n            { _name: \"iridescenceThicknessTexture\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"iridescenceThicknessSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n        if (hasThicknessUvTx) {\n            uboFields.push(...uvTransformUboFields(\"iridescenceThicknessUV\"));\n        }\n    }\n\n    const scopeVars: string[] = [];\n    if (hasIntensityMap) {\n        scopeVars.push(uvDecl(\"iridescenceUV\", uvBaseExpr(features2, meshFeatures, PBR2_HAS_IRIDESCENCE_UV2), hasIntensityUvTx));\n    }\n    if (hasThicknessMap) {\n        scopeVars.push(uvDecl(\"iridescenceThicknessUV\", uvBaseExpr(features2, meshFeatures, PBR2_HAS_IRIDESCENCE_THICKNESS_UV2), hasThicknessUvTx));\n    }\n\n    const intensity = hasIntensityMap ? \"material.iridescenceParams.x*textureSample(iridescenceTexture,iridescenceSampler_,iridescenceUV).r\" : \"material.iridescenceParams.x\";\n    const thickness = hasThicknessMap\n        ? \"mix(material.iridescenceParams.z,material.iridescenceParams.w,textureSample(iridescenceThicknessTexture,iridescenceThicknessSampler_,iridescenceThicknessUV).g)\"\n        : \"material.iridescenceParams.w\";\n    return {\n        _id: \"iridescence\",\n        _dependencies:\n            (features & (PBR_HAS_METALLIC_REFLECTANCE_MAP | PBR_HAS_REFLECTANCE_MAP)) !== 0 || (features2 & PBR2_HAS_REFLECTANCE_FACTORS) !== 0 ? [\"reflectance\"] : undefined,\n        _uboFields: uboFields,\n        _bindings: bindings,\n        _helperFunctions: IRIDESCENCE_HELPERS,\n        _fragmentSlots: {\n            ...(scopeVars.length ? { SV: scopeVars.join(\"\\n\") } : undefined),\n            MF: `{\nlet iriIntensity=clamp(${intensity},0.0,1.0);\nlet iriThickness=max(${thickness},0.0);\nlet iriF0=iri_eval(1.0,max(material.iridescenceParams.y,1.0001),NdotV,iriThickness,colorF0);\ncolorF0=mix(colorF0,iriF0,iriIntensity);\n}`,\n        },\n    };\n}\n\nexport function writeIridescenceUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    const iri = material.iridescence as IridescenceProps | undefined;\n    if (!iri?.isEnabled || !offsets.has(\"iridescenceParams\")) {\n        return;\n    }\n    const off = offsets.get(\"iridescenceParams\")! / 4;\n    data[off] = iri.intensity ?? 1.0;\n    data[off + 1] = iri.indexOfRefraction ?? 1.3;\n    data[off + 2] = iri.minimumThickness ?? 100;\n    data[off + 3] = iri.maximumThickness ?? 400;\n    writeUvTransform(data, offsets, \"iridescenceUV\", iri.texture);\n    writeUvTransform(data, offsets, \"iridescenceThicknessUV\", iri.thicknessTexture);\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"iridescence\",\n    phase: \"base-tex\",\n    detect(mat) {\n        const iri = (mat as PbrMaterialProps).iridescence;\n        if (!iri?.isEnabled) {\n            return { f: 0, f2: 0 };\n        }\n        let f2 = PBR2_HAS_IRIDESCENCE;\n        if (iri.texture) {\n            f2 |= PBR2_HAS_IRIDESCENCE_MAP;\n            if ((iri.texture as { _hasTx?: boolean })._hasTx) {\n                f2 |= PBR2_HAS_IRIDESCENCE_UV_TX;\n            }\n            if ((iri.texture as { _texCoord?: number })._texCoord === 1) {\n                f2 |= PBR2_HAS_IRIDESCENCE_UV2;\n            }\n        }\n        if (iri.thicknessTexture) {\n            f2 |= PBR2_HAS_IRIDESCENCE_THICKNESS_MAP;\n            if ((iri.thicknessTexture as { _hasTx?: boolean })._hasTx) {\n                f2 |= PBR2_HAS_IRIDESCENCE_THICKNESS_UV_TX;\n            }\n            if ((iri.thicknessTexture as { _texCoord?: number })._texCoord === 1) {\n                f2 |= PBR2_HAS_IRIDESCENCE_THICKNESS_UV2;\n            }\n        }\n        return { f: 0, f2 };\n    },\n    frag: (ctx) => createIridescenceFragment(ctx._features, ctx._features2, ctx._meshFeatures),\n    writeUbo: writeIridescenceUBO as PbrExt[\"writeUbo\"],\n    bind(ctx, entries, b) {\n        const iri = (ctx._material as PbrMaterialProps).iridescence;\n        if (!iri) {\n            return b;\n        }\n        for (const [flag, key] of IRI_TEX) {\n            const tex = iri[key];\n            if ((ctx._features2 & flag) !== 0 && 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, t) {\n        const iri = (mat as PbrMaterialProps).iridescence;\n        if (!iri) {\n            return;\n        }\n        for (const [, key] of IRI_TEX) {\n            const tex = iri[key];\n            if (tex) {\n                t.push(tex);\n            }\n        }\n    },\n};\n"],"names":[],"mappings":";AAqBA,MAAM,iBAAiB;AACvB,MAAM,6BAA6B,KAAK;AACxC,MAAM,uCAAuC,KAAK;AAClD,MAAM,2BAA2B,KAAK;AACtC,MAAM,qCAAqC,KAAK;AAChD,MAAM,kBAAkB,KAAK;AAE7B,MAAM,sBAAsB;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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4D5B,MAAM,UAA4E;AAAA,EAC9E,CAAC,0BAA0B,SAAS;AAAA,EACpC,CAAC,oCAAoC,kBAAkB;AAC3D;AAEA,SAAS,WAAW,WAAmB,cAAsB,SAAyB;AAClF,UAAQ,YAAY,aAAa,MAAM,eAAe,qBAAqB,IAAI,cAAc;AACjG;AAEA,SAAS,OAAO,MAAc,QAAgB,OAAwB;AAClE,SAAO,QAAQ,OAAO,IAAI,2BAA2B,IAAI,QAAQ,MAAM,kBAAkB,IAAI,QAAQ,MAAM,eAAe,IAAI,UAAU,OAAO,IAAI,IAAI,MAAM;AACjK;AAEA,SAAS,qBAAqB,MAA0B;AACpD,SAAO;AAAA,IACH,EAAE,OAAO,GAAG,IAAI,KAAK,OAAO,YAAA;AAAA,IAC5B,EAAE,OAAO,GAAG,IAAI,KAAK,OAAO,YAAA;AAAA,EAAY;AAEhD;AAEA,SAAS,iBAAiB,MAAoB,SAAsC,MAAc,KAAkC;AAChI,QAAM,OAAO,QAAQ,IAAI,GAAG,IAAI,GAAG;AACnC,QAAM,OAAO,QAAQ,IAAI,GAAG,IAAI,GAAG;AACnC,MAAI,SAAS,UAAa,SAAS,QAAW;AAC1C;AAAA,EACJ;AACA,QAAM,KAAK,OAAO;AAClB,QAAM,KAAK,OAAO;AAClB,QAAM,MAAK,2BAAK,WAAU;AAC1B,QAAM,MAAK,2BAAK,WAAU;AAC1B,QAAM,OAAM,2BAAK,SAAQ;AACzB,QAAM,MAAK,2BAAK,YAAW;AAC3B,QAAM,MAAK,2BAAK,YAAW;AAC3B,MAAI,QAAQ,GAAG;AACX,SAAK,EAAE,IAAI;AACX,SAAK,KAAK,CAAC,IAAI;AACf,SAAK,KAAK,CAAC,IAAI;AACf,SAAK,KAAK,CAAC,IAAI;AAAA,EACnB,OAAO;AACH,UAAM,IAAI,KAAK,IAAI,GAAG;AACtB,UAAM,IAAI,KAAK,IAAI,GAAG;AACtB,SAAK,EAAE,IAAI,IAAI;AACf,SAAK,KAAK,CAAC,IAAI,CAAC,IAAI;AACpB,SAAK,KAAK,CAAC,IAAI,IAAI;AACnB,SAAK,KAAK,CAAC,IAAI,IAAI;AAAA,EACvB;AACA,OAAK,EAAE,IAAI;AACX,OAAK,KAAK,CAAC,IAAI;AACf,OAAK,KAAK,CAAC,IAAI;AACf,OAAK,KAAK,CAAC,IAAI;AACnB;AAEA,SAAS,0BAA0B,UAAkB,WAAmB,cAA6C;AACjH,OAAK,YAAY,0BAA0B,GAAG;AAC1C,WAAO;AAAA,EACX;AACA,QAAM,mBAAmB,YAAY,8BAA8B;AACnE,QAAM,mBAAmB,YAAY,wCAAwC;AAC7E,QAAM,oBAAoB,YAAY,gCAAgC;AACtE,QAAM,oBAAoB,YAAY,0CAA0C;AAChF,QAAM,WAA0B,CAAA;AAChC,QAAM,YAAwB,CAAC,EAAE,OAAO,qBAAqB,OAAO,aAAa;AACjF,MAAI,iBAAiB;AACjB,aAAS;AAAA,MACL,EAAE,OAAO,sBAAsB,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,aAAa,eAAA;AAAA,MAC1G,EAAE,OAAO,uBAAuB,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,eAAA;AAAA,IAAe;AAEtH,QAAI,kBAAkB;AAClB,gBAAU,KAAK,GAAG,qBAAqB,eAAe,CAAC;AAAA,IAC3D;AAAA,EACJ;AACA,MAAI,iBAAiB;AACjB,aAAS;AAAA,MACL,EAAE,OAAO,+BAA+B,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,aAAa,eAAA;AAAA,MACnH,EAAE,OAAO,gCAAgC,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,eAAA;AAAA,IAAe;AAE/H,QAAI,kBAAkB;AAClB,gBAAU,KAAK,GAAG,qBAAqB,wBAAwB,CAAC;AAAA,IACpE;AAAA,EACJ;AAEA,QAAM,YAAsB,CAAA;AAC5B,MAAI,iBAAiB;AACjB,cAAU,KAAK,OAAO,iBAAiB,WAAW,WAAW,cAAc,wBAAwB,GAAG,gBAAgB,CAAC;AAAA,EAC3H;AACA,MAAI,iBAAiB;AACjB,cAAU,KAAK,OAAO,0BAA0B,WAAW,WAAW,cAAc,kCAAkC,GAAG,gBAAgB,CAAC;AAAA,EAC9I;AAEA,QAAM,YAAY,kBAAkB,uGAAuG;AAC3I,QAAM,YAAY,kBACZ,oKACA;AACN,SAAO;AAAA,IACH,KAAK;AAAA,IACL,gBACK,YAAY,mCAAmC,8BAA8B,MAAM,YAAY,kCAAkC,IAAI,CAAC,aAAa,IAAI;AAAA,IAC5J,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,kBAAkB;AAAA,IAClB,gBAAgB;AAAA,MACZ,GAAI,UAAU,SAAS,EAAE,IAAI,UAAU,KAAK,IAAI,EAAA,IAAM;AAAA,MACtD,IAAI;AAAA,yBACS,SAAS;AAAA,uBACX,SAAS;AAAA;AAAA;AAAA;AAAA,IAAA;AAAA,EAIxB;AAER;AAEO,SAAS,oBAAoB,MAAoB,UAA4B,SAA4C;AAC5H,QAAM,MAAM,SAAS;AACrB,MAAI,EAAC,2BAAK,cAAa,CAAC,QAAQ,IAAI,mBAAmB,GAAG;AACtD;AAAA,EACJ;AACA,QAAM,MAAM,QAAQ,IAAI,mBAAmB,IAAK;AAChD,OAAK,GAAG,IAAI,IAAI,aAAa;AAC7B,OAAK,MAAM,CAAC,IAAI,IAAI,qBAAqB;AACzC,OAAK,MAAM,CAAC,IAAI,IAAI,oBAAoB;AACxC,OAAK,MAAM,CAAC,IAAI,IAAI,oBAAoB;AACxC,mBAAiB,MAAM,SAAS,iBAAiB,IAAI,OAAO;AAC5D,mBAAiB,MAAM,SAAS,0BAA0B,IAAI,gBAAgB;AAClF;AAEO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,OAAO,KAAK;AACR,UAAM,MAAO,IAAyB;AACtC,QAAI,EAAC,2BAAK,YAAW;AACjB,aAAO,EAAE,GAAG,GAAG,IAAI,EAAA;AAAA,IACvB;AACA,QAAI,KAAK;AACT,QAAI,IAAI,SAAS;AACb,YAAM;AACN,UAAK,IAAI,QAAiC,QAAQ;AAC9C,cAAM;AAAA,MACV;AACA,UAAK,IAAI,QAAmC,cAAc,GAAG;AACzD,cAAM;AAAA,MACV;AAAA,IACJ;AACA,QAAI,IAAI,kBAAkB;AACtB,YAAM;AACN,UAAK,IAAI,iBAA0C,QAAQ;AACvD,cAAM;AAAA,MACV;AACA,UAAK,IAAI,iBAA4C,cAAc,GAAG;AAClE,cAAM;AAAA,MACV;AAAA,IACJ;AACA,WAAO,EAAE,GAAG,GAAG,GAAA;AAAA,EACnB;AAAA,EACA,MAAM,CAAC,QAAQ,0BAA0B,IAAI,WAAW,IAAI,YAAY,IAAI,aAAa;AAAA,EACzF,UAAU;AAAA,EACV,KAAK,KAAK,SAAS,GAAG;AAClB,UAAM,MAAO,IAAI,UAA+B;AAChD,QAAI,CAAC,KAAK;AACN,aAAO;AAAA,IACX;AACA,eAAW,CAAC,MAAM,GAAG,KAAK,SAAS;AAC/B,YAAM,MAAM,IAAI,GAAG;AACnB,WAAK,IAAI,aAAa,UAAU,KAAK,KAAK;AACtC,gBAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,MAAM;AACjD,gBAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,SAAS;AAAA,MACxD;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AAAA,EACA,SAAS,KAAK,GAAG;AACb,UAAM,MAAO,IAAyB;AACtC,QAAI,CAAC,KAAK;AACN;AAAA,IACJ;AACA,eAAW,CAAA,EAAG,GAAG,KAAK,SAAS;AAC3B,YAAM,MAAM,IAAI,GAAG;AACnB,UAAI,KAAK;AACL,UAAE,KAAK,GAAG;AAAA,MACd;AAAA,IACJ;AAAA,EACJ;AACJ;"}

package/length-block-ChOkeiHR.js

@@ -0,0 +1,11 @@
+const emitter = {
+  className: "LengthBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const value = ctx.resolve(block, "value", stage, state);
+    return { expr: `length(${value.expr})`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=length-block-ChOkeiHR.js.map

package/length-block-ChOkeiHR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"length-block-ChOkeiHR.js","sources":["../src/material/node/blocks/length-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"LengthBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const value = ctx.resolve(block, \"value\", stage, state);\n        return { expr: `length(${value.expr})`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,WAAO,EAAE,MAAM,UAAU,MAAM,IAAI,KAAK,MAAM,MAAA;AAAA,EAClD;AACJ;"}

package/lerp-block-DjI2SfmI.js

@@ -0,0 +1,18 @@
+import { w as widerType } from "./_math-factory-C-QqW-Wi.js";
+const emitter = {
+  className: "LerpBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const left = ctx.resolve(block, "left", stage, state);
+    const right = ctx.resolve(block, "right", stage, state);
+    const gradient = ctx.resolve(block, "gradient", stage, state);
+    const t = widerType(left.type, right.type);
+    const lc = ctx.cast(left, t).expr;
+    const rc = ctx.cast(right, t).expr;
+    const gc = ctx.cast(gradient, t).expr;
+    return { expr: `mix(${lc}, ${rc}, ${gc})`, type: t };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=lerp-block-DjI2SfmI.js.map

package/lerp-block-DjI2SfmI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lerp-block-DjI2SfmI.js","sources":["../src/material/node/blocks/lerp-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\nimport { widerType } from \"./_math-factory.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"LerpBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const left = ctx.resolve(block, \"left\", stage, state);\n        const right = ctx.resolve(block, \"right\", stage, state);\n        const gradient = ctx.resolve(block, \"gradient\", stage, state);\n        const t = widerType(left.type, right.type);\n        const lc = ctx.cast(left, t).expr;\n        const rc = ctx.cast(right, t).expr;\n        // Gradient can be scalar (broadcast) or vector (per-component). Cast to result type.\n        const gc = ctx.cast(gradient, t).expr;\n        return { expr: `mix(${lc}, ${rc}, ${gc})`, type: t };\n    },\n};\n"],"names":[],"mappings":";AAGO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,OAAO,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK;AACpD,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,WAAW,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK;AAC5D,UAAM,IAAI,UAAU,KAAK,MAAM,MAAM,IAAI;AACzC,UAAM,KAAK,IAAI,KAAK,MAAM,CAAC,EAAE;AAC7B,UAAM,KAAK,IAAI,KAAK,OAAO,CAAC,EAAE;AAE9B,UAAM,KAAK,IAAI,KAAK,UAAU,CAAC,EAAE;AACjC,WAAO,EAAE,MAAM,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,MAAM,EAAA;AAAA,EACrD;AACJ;"}

package/light-block-B11ew7FA.js

@@ -0,0 +1,123 @@
+import { M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+const NME_LIGHTING_HELPER_KEY = "nme_lighting";
+const NME_LIGHTING_HELPER_WGSL = `struct NmeLightResult {
+    diffuse: vec3<f32>,
+    specular: vec3<f32>,
+    shadow: f32,
+};
+
+fn nme_computeLighting(
+    worldPos: vec3<f32>,
+    worldNormal: vec3<f32>,
+    cameraPos: vec3<f32>,
+    diffuseColor: vec3<f32>,
+    specularColor: vec3<f32>,
+    glossiness: f32,
+    shadowFactors: array<f32, ${MAX_LIGHTS}>
+) -> NmeLightResult {
+    var result: NmeLightResult;
+    result.diffuse = vec3<f32>(0.0);
+    result.specular = vec3<f32>(0.0);
+    var aggShadow: f32 = 0.0;
+    var numLights: f32 = 0.0;
+    let viewDir = normalize(cameraPos - worldPos);
+    let N = normalize(worldNormal);
+     let lc = min(meshU.lc, ${MAX_LIGHTS}u);
+     for (var i: u32 = 0u; i < lc; i = i + 1u) {
+        let lightIndex = nli(i);
+        let L = nmeLights.lights[lightIndex];
+        let t = u32(L.vLightData.w);
+        let sh = shadowFactors[lightIndex];
+        var lv: vec3<f32>;
+        var atten: f32 = 1.0;
+        if (t == 3u) {
+            // Hemispheric: ground/sky mix via half-lambert.
+            let nl = 0.5 + 0.5 * dot(N, normalize(L.vLightData.xyz));
+            let diff = mix(L.vLightDirection.xyz, L.vLightDiffuse.rgb, nl);
+            result.diffuse = result.diffuse + diff * diffuseColor * sh;
+            let H = normalize(viewDir + normalize(L.vLightData.xyz));
+            let sf = pow(max(0.0, dot(N, H)), max(1.0, glossiness));
+            result.specular = result.specular + sf * L.vLightSpecular.rgb * specularColor * sh;
+            aggShadow = aggShadow + sh;
+            numLights = numLights + 1.0;
+            continue;
+        }
+        if (t == 1u) {
+            // Directional: vLightData.xyz is the light's forward direction.
+            lv = normalize(-L.vLightData.xyz);
+        } else {
+            // Point / Spot: vLightData.xyz is world-space position; range in vLightDiffuse.a.
+            let d = L.vLightData.xyz - worldPos;
+            atten = max(0.0, 1.0 - length(d) / L.vLightDiffuse.a);
+            lv = normalize(d);
+            if (t == 2u) {
+                // Spot cone falloff (vLightDirection.xyz=dir, .w=cosHalfAngle; vLightSpecular.a=exp).
+                let c = max(0.0, dot(L.vLightDirection.xyz, -lv));
+                if (c >= L.vLightDirection.w) {
+                    atten = atten * max(0.0, pow(c, L.vLightSpecular.a));
+                } else {
+                    atten = 0.0;
+                }
+            }
+        }
+        let NdotL = max(0.0, dot(N, lv));
+        result.diffuse = result.diffuse + L.vLightDiffuse.rgb * diffuseColor * NdotL * atten * sh;
+        let H = normalize(lv + viewDir);
+        let NdotH = max(0.0, dot(N, H));
+        let specFactor = pow(NdotH, max(1.0, glossiness));
+        result.specular = result.specular + L.vLightSpecular.rgb * specularColor * specFactor * atten * sh;
+        aggShadow = aggShadow + sh;
+        numLights = numLights + 1.0;
+    }
+    if (numLights > 0.0) {
+        result.shadow = aggShadow / numLights;
+    } else {
+        result.shadow = 1.0;
+    }
+    return result;
+}
+`;
+const SHADOW_FACTORS_ONE = `array<f32, ${MAX_LIGHTS}>(${new Array(MAX_LIGHTS).fill("1.0").join(", ")})`;
+function resolveOptional(block, inputName, fallback, stage, state, ctx, target) {
+  const input = block.inputs.get(inputName);
+  if (input == null ? void 0 : input.source) {
+    return ctx.cast(ctx.resolve(block, inputName, stage, state), target).expr;
+  }
+  return fallback;
+}
+const emitter = {
+  className: "LightBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    state.fragment.helpers.set(NME_LIGHTING_HELPER_KEY, NME_LIGHTING_HELPER_WGSL);
+    state.usesLightsUbo = true;
+    const memoKey = `_light_${block.id}_call`;
+    const callExpr = state.fragment.memo.get(memoKey);
+    let callVar;
+    if (!callExpr) {
+      const wp = resolveOptional(block, "worldPosition", "vec3<f32>(0.0)", stage, state, ctx, "vec3f");
+      const wn = resolveOptional(block, "worldNormal", "vec3<f32>(0.0, 1.0, 0.0)", stage, state, ctx, "vec3f");
+      const cp = resolveOptional(block, "cameraPosition", "_NME_CAMERA_POS_", stage, state, ctx, "vec3f");
+      const dc = resolveOptional(block, "diffuseColor", "vec3<f32>(1.0)", stage, state, ctx, "vec3f");
+      const sc = resolveOptional(block, "specularColor", "vec3<f32>(1.0)", stage, state, ctx, "vec3f");
+      const gl = resolveOptional(block, "glossiness", "1.0", stage, state, ctx, "f32");
+      const gp = resolveOptional(block, "glossPower", "1024.0", stage, state, ctx, "f32");
+      const sf = state.shadowLights.length > 0 ? `nme_computeShadowFactors(in)` : SHADOW_FACTORS_ONE;
+      callVar = `_lt${ctx.temp(state, "light")}`;
+      state.fragment.body.push(`let ${callVar} = nme_computeLighting(${wp}, ${wn}, ${cp}, ${dc}, ${sc}, (${gl}) * (${gp}), ${sf});`);
+      state.fragment.memo.set(memoKey, { expr: callVar, type: "vec4f" });
+    } else {
+      callVar = callExpr.expr;
+    }
+    const out = {
+      diffuseOutput: { expr: `${callVar}.diffuse`, type: "vec3f" },
+      specularOutput: { expr: `${callVar}.specular`, type: "vec3f" },
+      shadow: { expr: `${callVar}.shadow`, type: "f32" }
+    };
+    return out[outputName] ?? { expr: `${callVar}.diffuse`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=light-block-B11ew7FA.js.map

package/light-block-B11ew7FA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"light-block-B11ew7FA.js","sources":["../src/material/node/blocks/_lighting-helper.ts","../src/material/node/blocks/light-block.ts"],"sourcesContent":["/** Shared WGSL helper source for LightBlock.\n *\n *  This module exports just the `nme_computeLighting` function definition.\n *  The surrounding `LightEntry` / `lightsUniforms` struct decls and the\n *  `@group(1) @binding(N) var<uniform> nmeLights` declaration are injected\n *  by the pipeline builder (see node-pipeline.ts) once `state.usesLightsUbo`\n *  is true. Keeping them out of the helper lets a single `MAX_LIGHTS` value\n *  (at compile time) drive both the WGSL array length and the BGL entry size.\n */\n\nimport { MAX_LIGHTS } from \"../../../light/types.js\";\n\nexport const NME_LIGHTING_HELPER_KEY = \"nme_lighting\";\n\nexport const NME_LIGHTING_HELPER_WGSL = `struct NmeLightResult {\n    diffuse: vec3<f32>,\n    specular: vec3<f32>,\n    shadow: f32,\n};\n\nfn nme_computeLighting(\n    worldPos: vec3<f32>,\n    worldNormal: vec3<f32>,\n    cameraPos: vec3<f32>,\n    diffuseColor: vec3<f32>,\n    specularColor: vec3<f32>,\n    glossiness: f32,\n    shadowFactors: array<f32, ${MAX_LIGHTS}>\n) -> NmeLightResult {\n    var result: NmeLightResult;\n    result.diffuse = vec3<f32>(0.0);\n    result.specular = vec3<f32>(0.0);\n    var aggShadow: f32 = 0.0;\n    var numLights: f32 = 0.0;\n    let viewDir = normalize(cameraPos - worldPos);\n    let N = normalize(worldNormal);\n     let lc = min(meshU.lc, ${MAX_LIGHTS}u);\n     for (var i: u32 = 0u; i < lc; i = i + 1u) {\n        let lightIndex = nli(i);\n        let L = nmeLights.lights[lightIndex];\n        let t = u32(L.vLightData.w);\n        let sh = shadowFactors[lightIndex];\n        var lv: vec3<f32>;\n        var atten: f32 = 1.0;\n        if (t == 3u) {\n            // Hemispheric: ground/sky mix via half-lambert.\n            let nl = 0.5 + 0.5 * dot(N, normalize(L.vLightData.xyz));\n            let diff = mix(L.vLightDirection.xyz, L.vLightDiffuse.rgb, nl);\n            result.diffuse = result.diffuse + diff * diffuseColor * sh;\n            let H = normalize(viewDir + normalize(L.vLightData.xyz));\n            let sf = pow(max(0.0, dot(N, H)), max(1.0, glossiness));\n            result.specular = result.specular + sf * L.vLightSpecular.rgb * specularColor * sh;\n            aggShadow = aggShadow + sh;\n            numLights = numLights + 1.0;\n            continue;\n        }\n        if (t == 1u) {\n            // Directional: vLightData.xyz is the light's forward direction.\n            lv = normalize(-L.vLightData.xyz);\n        } else {\n            // Point / Spot: vLightData.xyz is world-space position; range in vLightDiffuse.a.\n            let d = L.vLightData.xyz - worldPos;\n            atten = max(0.0, 1.0 - length(d) / L.vLightDiffuse.a);\n            lv = normalize(d);\n            if (t == 2u) {\n                // Spot cone falloff (vLightDirection.xyz=dir, .w=cosHalfAngle; vLightSpecular.a=exp).\n                let c = max(0.0, dot(L.vLightDirection.xyz, -lv));\n                if (c >= L.vLightDirection.w) {\n                    atten = atten * max(0.0, pow(c, L.vLightSpecular.a));\n                } else {\n                    atten = 0.0;\n                }\n            }\n        }\n        let NdotL = max(0.0, dot(N, lv));\n        result.diffuse = result.diffuse + L.vLightDiffuse.rgb * diffuseColor * NdotL * atten * sh;\n        let H = normalize(lv + viewDir);\n        let NdotH = max(0.0, dot(N, H));\n        let specFactor = pow(NdotH, max(1.0, glossiness));\n        result.specular = result.specular + L.vLightSpecular.rgb * specularColor * specFactor * atten * sh;\n        aggShadow = aggShadow + sh;\n        numLights = numLights + 1.0;\n    }\n    if (numLights > 0.0) {\n        result.shadow = aggShadow / numLights;\n    } else {\n        result.shadow = 1.0;\n    }\n    return result;\n}\n`;\n","/** LightBlock — classic Blinn-Phong lighting.\n *\n *  Inputs: worldPosition, worldNormal, cameraPosition, glossiness, glossPower\n *  (optional), diffuseColor, specularColor.\n *  Outputs: diffuseOutput (vec3), specularOutput (vec3), shadow (f32).\n *\n *  The actual math lives in `_lighting-helper.ts` and is injected into the\n *  fragment helper map. The pipeline builder is responsible for binding the\n *  scene's Lights UBO under `nmeLights` / `nmeLightsCount` at group/binding\n *  slots reserved for NME.\n */\n\nimport type { BlockEmitter, NodeExpr } from \"../node-types.js\";\nimport { NME_LIGHTING_HELPER_KEY, NME_LIGHTING_HELPER_WGSL } from \"./_lighting-helper.js\";\nimport { MAX_LIGHTS } from \"../../../light/types.js\";\n\nconst SHADOW_FACTORS_ONE = `array<f32, ${MAX_LIGHTS}>(${new Array(MAX_LIGHTS).fill(\"1.0\").join(\", \")})`;\n\nfunction resolveOptional(\n    block: Parameters<BlockEmitter[\"emit\"]>[0],\n    inputName: string,\n    fallback: string,\n    stage: Parameters<BlockEmitter[\"emit\"]>[2],\n    state: Parameters<BlockEmitter[\"emit\"]>[3],\n    ctx: Parameters<BlockEmitter[\"emit\"]>[4],\n    target: \"vec3f\" | \"f32\"\n): string {\n    const input = block.inputs.get(inputName);\n    if (input?.source) {\n        return ctx.cast(ctx.resolve(block, inputName, stage, state), target).expr;\n    }\n    return fallback;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"LightBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx) {\n        // Inject helper + mark the lights UBO as required.\n        state.fragment.helpers.set(NME_LIGHTING_HELPER_KEY, NME_LIGHTING_HELPER_WGSL);\n        state.usesLightsUbo = true;\n\n        const memoKey = `_light_${block.id}_call`;\n        const callExpr = state.fragment.memo.get(memoKey);\n        let callVar: string;\n        if (!callExpr) {\n            const wp = resolveOptional(block, \"worldPosition\", \"vec3<f32>(0.0)\", stage, state, ctx, \"vec3f\");\n            const wn = resolveOptional(block, \"worldNormal\", \"vec3<f32>(0.0, 1.0, 0.0)\", stage, state, ctx, \"vec3f\");\n            const cp = resolveOptional(block, \"cameraPosition\", \"_NME_CAMERA_POS_\", stage, state, ctx, \"vec3f\");\n            const dc = resolveOptional(block, \"diffuseColor\", \"vec3<f32>(1.0)\", stage, state, ctx, \"vec3f\");\n            const sc = resolveOptional(block, \"specularColor\", \"vec3<f32>(1.0)\", stage, state, ctx, \"vec3f\");\n            const gl = resolveOptional(block, \"glossiness\", \"1.0\", stage, state, ctx, \"f32\");\n            // BJS multiplies glossiness * glossPower; default glossPower is 1024 when unconnected.\n            const gp = resolveOptional(block, \"glossPower\", \"1024.0\", stage, state, ctx, \"f32\");\n            const sf = state.shadowLights.length > 0 ? `nme_computeShadowFactors(in)` : SHADOW_FACTORS_ONE;\n            callVar = `_lt${ctx.temp(state, \"light\")}`;\n            state.fragment.body.push(`let ${callVar} = nme_computeLighting(${wp}, ${wn}, ${cp}, ${dc}, ${sc}, (${gl}) * (${gp}), ${sf});`);\n            state.fragment.memo.set(memoKey, { expr: callVar, type: \"vec4f\" });\n        } else {\n            callVar = callExpr.expr;\n        }\n\n        const out: Record<string, NodeExpr> = {\n            diffuseOutput: { expr: `${callVar}.diffuse`, type: \"vec3f\" },\n            specularOutput: { expr: `${callVar}.specular`, type: \"vec3f\" },\n            shadow: { expr: `${callVar}.shadow`, type: \"f32\" },\n        };\n        return out[outputName] ?? { expr: `${callVar}.diffuse`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":";AAYO,MAAM,0BAA0B;AAEhC,MAAM,2BAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAaR,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,8BASZ,UAAU;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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACpBxC,MAAM,qBAAqB,cAAc,UAAU,KAAK,IAAI,MAAM,UAAU,EAAE,KAAK,KAAK,EAAE,KAAK,IAAI,CAAC;AAEpG,SAAS,gBACL,OACA,WACA,UACA,OACA,OACA,KACA,QACM;AACN,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,MAAI,+BAAO,QAAQ;AACf,WAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK,GAAG,MAAM,EAAE;AAAA,EACzE;AACA,SAAO;AACX;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AAEvC,UAAM,SAAS,QAAQ,IAAI,yBAAyB,wBAAwB;AAC5E,UAAM,gBAAgB;AAEtB,UAAM,UAAU,UAAU,MAAM,EAAE;AAClC,UAAM,WAAW,MAAM,SAAS,KAAK,IAAI,OAAO;AAChD,QAAI;AACJ,QAAI,CAAC,UAAU;AACX,YAAM,KAAK,gBAAgB,OAAO,iBAAiB,kBAAkB,OAAO,OAAO,KAAK,OAAO;AAC/F,YAAM,KAAK,gBAAgB,OAAO,eAAe,4BAA4B,OAAO,OAAO,KAAK,OAAO;AACvG,YAAM,KAAK,gBAAgB,OAAO,kBAAkB,oBAAoB,OAAO,OAAO,KAAK,OAAO;AAClG,YAAM,KAAK,gBAAgB,OAAO,gBAAgB,kBAAkB,OAAO,OAAO,KAAK,OAAO;AAC9F,YAAM,KAAK,gBAAgB,OAAO,iBAAiB,kBAAkB,OAAO,OAAO,KAAK,OAAO;AAC/F,YAAM,KAAK,gBAAgB,OAAO,cAAc,OAAO,OAAO,OAAO,KAAK,KAAK;AAE/E,YAAM,KAAK,gBAAgB,OAAO,cAAc,UAAU,OAAO,OAAO,KAAK,KAAK;AAClF,YAAM,KAAK,MAAM,aAAa,SAAS,IAAI,iCAAiC;AAC5E,gBAAU,MAAM,IAAI,KAAK,OAAO,OAAO,CAAC;AACxC,YAAM,SAAS,KAAK,KAAK,OAAO,OAAO,0BAA0B,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI;AAC7H,YAAM,SAAS,KAAK,IAAI,SAAS,EAAE,MAAM,SAAS,MAAM,SAAS;AAAA,IACrE,OAAO;AACH,gBAAU,SAAS;AAAA,IACvB;AAEA,UAAM,MAAgC;AAAA,MAClC,eAAe,EAAE,MAAM,GAAG,OAAO,YAAY,MAAM,QAAA;AAAA,MACnD,gBAAgB,EAAE,MAAM,GAAG,OAAO,aAAa,MAAM,QAAA;AAAA,MACrD,QAAQ,EAAE,MAAM,GAAG,OAAO,WAAW,MAAM,MAAA;AAAA,IAAM;AAErD,WAAO,IAAI,UAAU,KAAK,EAAE,MAAM,GAAG,OAAO,YAAY,MAAM,QAAA;AAAA,EAClE;AACJ;"}

package/light-information-VJbW0jbs.js

@@ -0,0 +1,19 @@
+const emitter = {
+  className: "LightInformationBlock",
+  emit(block, outputName, _stage, state, _ctx) {
+    state.usesLightsUbo = true;
+    const idxRaw = block.serialized.lightId;
+    const idx = typeof idxRaw === "number" ? idxRaw : 0;
+    const base = `nmeLights.lights[nli(${idx}u)]`;
+    const out = {
+      direction: { expr: `${base}.vLightData.xyz`, type: "vec3f" },
+      color: { expr: `${base}.vLightDiffuse.rgb`, type: "vec3f" },
+      intensity: { expr: `${base}.vLightDiffuse.a`, type: "f32" }
+    };
+    return out[outputName] ?? out.direction;
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=light-information-VJbW0jbs.js.map

package/light-information-VJbW0jbs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"light-information-VJbW0jbs.js","sources":["../src/material/node/blocks/light-information.ts"],"sourcesContent":["/** LightInformationBlock — exposes a specific light's direction / color / intensity.\n *\n *  BJS picks the light by index (serialized as `lightId` or picked default 0).\n *  The pipeline builder binds the scene's shared lights UBO under `nmeLights`\n *  (an array of `LightEntry` in `lightsUniforms`).\n */\n\nimport type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"LightInformationBlock\",\n    emit(block, outputName, _stage, state, _ctx) {\n        state.usesLightsUbo = true;\n        const idxRaw = block.serialized.lightId;\n        const idx = typeof idxRaw === \"number\" ? idxRaw : 0;\n        const base = `nmeLights.lights[nli(${idx}u)]`;\n        const out: Record<string, NodeExpr> = {\n            direction: { expr: `${base}.vLightData.xyz`, type: \"vec3f\" },\n            color: { expr: `${base}.vLightDiffuse.rgb`, type: \"vec3f\" },\n            intensity: { expr: `${base}.vLightDiffuse.a`, type: \"f32\" },\n        };\n        return out[outputName] ?? out.direction!;\n    },\n};\n"],"names":[],"mappings":"AASO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,QAAQ,OAAO,MAAM;AACzC,UAAM,gBAAgB;AACtB,UAAM,SAAS,MAAM,WAAW;AAChC,UAAM,MAAM,OAAO,WAAW,WAAW,SAAS;AAClD,UAAM,OAAO,wBAAwB,GAAG;AACxC,UAAM,MAAgC;AAAA,MAClC,WAAW,EAAE,MAAM,GAAG,IAAI,mBAAmB,MAAM,QAAA;AAAA,MACnD,OAAO,EAAE,MAAM,GAAG,IAAI,sBAAsB,MAAM,QAAA;AAAA,MAClD,WAAW,EAAE,MAAM,GAAG,IAAI,oBAAoB,MAAM,MAAA;AAAA,IAAM;AAE9D,WAAO,IAAI,UAAU,KAAK,IAAI;AAAA,EAClC;AACJ;"}

package/loop-block-Bb23EOMb.js

@@ -0,0 +1,71 @@
+import { aS as WGSL } from "./index-C8HOR2sB.js";
+function loopKey(stage, blockId) {
+  return `${stage}|${blockId}`;
+}
+function storageWritesForLoop(block, ctx) {
+  var _a;
+  const writes = [];
+  for (const candidate of ctx.graph.blocks.values()) {
+    if (candidate.className !== "StorageWriteBlock") {
+      continue;
+    }
+    const loopID = (_a = candidate.inputs.get("loopID")) == null ? void 0 : _a.source;
+    if ((loopID == null ? void 0 : loopID.blockId) === block.id && loopID.outputName === "loopID") {
+      writes.push(candidate);
+    }
+  }
+  return writes;
+}
+const emitter = {
+  className: "LoopBlock",
+  emit(block, outputName, stage, state, ctx) {
+    const active = state.loopVariables.get(loopKey(stage, block.id));
+    if (outputName === "index") {
+      if (!active) {
+        throw new Error(`LoopBlock "${block.name}": index can only be read while emitting the loop body`);
+      }
+      return { expr: `f32(${active.indexVar})`, type: "f32" };
+    }
+    if (outputName === "loopID") {
+      throw new Error(`LoopBlock "${block.name}": loopID can only be consumed by StorageReadBlock/StorageWriteBlock`);
+    }
+    if (outputName !== "output") {
+      throw new Error(`LoopBlock "${block.name}": unsupported output "${outputName}"`);
+    }
+    const initial = ctx.resolve(block, "input", stage, state);
+    const valueVar = ctx.temp(state, "loop");
+    const indexVar = ctx.temp(state, "loopIndex");
+    const body = stage === "vertex" ? state.vertex.body : state.fragment.body;
+    body.push(`var ${valueVar}: ${WGSL[initial.type]} = ${initial.expr};`);
+    const iterationsInput = block.inputs.get("iterations");
+    const iterations = (iterationsInput == null ? void 0 : iterationsInput.source) ? `i32(${ctx.cast(ctx.resolve(block, "iterations", stage, state), "f32").expr})` : String(Math.max(0, Math.floor(block.serialized["iterations"] ?? 4)));
+    body.push(`for (var ${indexVar} = 0; ${indexVar} < ${iterations}; ${indexVar} = ${indexVar} + 1) {`);
+    const key = loopKey(stage, block.id);
+    const previous = state.loopVariables.get(key);
+    const stageState = stage === "vertex" ? state.vertex : state.fragment;
+    const previousMemo = new Map(stageState.memo);
+    state.loopVariables.set(key, { valueVar, valueType: initial.type, indexVar });
+    try {
+      for (const write of storageWritesForLoop(block, ctx)) {
+        const value = ctx.cast(ctx.resolve(write, "value", stage, state), initial.type);
+        body.push(`${valueVar} = ${value.expr};`);
+      }
+    } finally {
+      stageState.memo.clear();
+      for (const [memoKey, memoValue] of previousMemo) {
+        stageState.memo.set(memoKey, memoValue);
+      }
+      if (previous) {
+        state.loopVariables.set(key, previous);
+      } else {
+        state.loopVariables.delete(key);
+      }
+    }
+    body.push("}");
+    return { expr: valueVar, type: initial.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=loop-block-Bb23EOMb.js.map

package/loop-block-Bb23EOMb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-block-Bb23EOMb.js","sources":["../src/material/node/blocks/loop-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeBlock, Stage } from \"../node-types.js\";\nimport { WGSL } from \"../node-types.js\";\n\nfunction loopKey(stage: Stage, blockId: number): string {\n    return `${stage}|${blockId}`;\n}\n\nfunction storageWritesForLoop(block: NodeBlock, ctx: Parameters<BlockEmitter[\"emit\"]>[4]): NodeBlock[] {\n    const writes: NodeBlock[] = [];\n    for (const candidate of ctx.graph.blocks.values()) {\n        if (candidate.className !== \"StorageWriteBlock\") {\n            continue;\n        }\n        const loopID = candidate.inputs.get(\"loopID\")?.source;\n        if (loopID?.blockId === block.id && loopID.outputName === \"loopID\") {\n            writes.push(candidate);\n        }\n    }\n    return writes;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"LoopBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        const active = state.loopVariables.get(loopKey(stage, block.id));\n        if (outputName === \"index\") {\n            if (!active) {\n                throw new Error(`LoopBlock \"${block.name}\": index can only be read while emitting the loop body`);\n            }\n            return { expr: `f32(${active.indexVar})`, type: \"f32\" };\n        }\n        if (outputName === \"loopID\") {\n            throw new Error(`LoopBlock \"${block.name}\": loopID can only be consumed by StorageReadBlock/StorageWriteBlock`);\n        }\n        if (outputName !== \"output\") {\n            throw new Error(`LoopBlock \"${block.name}\": unsupported output \"${outputName}\"`);\n        }\n\n        const initial = ctx.resolve(block, \"input\", stage, state);\n        const valueVar = ctx.temp(state, \"loop\");\n        const indexVar = ctx.temp(state, \"loopIndex\");\n        const body = stage === \"vertex\" ? state.vertex.body : state.fragment.body;\n        body.push(`var ${valueVar}: ${WGSL[initial.type]} = ${initial.expr};`);\n\n        const iterationsInput = block.inputs.get(\"iterations\");\n        const iterations = iterationsInput?.source\n            ? `i32(${ctx.cast(ctx.resolve(block, \"iterations\", stage, state), \"f32\").expr})`\n            : String(Math.max(0, Math.floor((block.serialized[\"iterations\"] as number | undefined) ?? 4)));\n\n        body.push(`for (var ${indexVar} = 0; ${indexVar} < ${iterations}; ${indexVar} = ${indexVar} + 1) {`);\n        const key = loopKey(stage, block.id);\n        const previous = state.loopVariables.get(key);\n        const stageState = stage === \"vertex\" ? state.vertex : state.fragment;\n        const previousMemo = new Map(stageState.memo);\n        state.loopVariables.set(key, { valueVar, valueType: initial.type, indexVar });\n        try {\n            for (const write of storageWritesForLoop(block, ctx)) {\n                const value = ctx.cast(ctx.resolve(write, \"value\", stage, state), initial.type);\n                body.push(`${valueVar} = ${value.expr};`);\n            }\n        } finally {\n            stageState.memo.clear();\n            for (const [memoKey, memoValue] of previousMemo) {\n                stageState.memo.set(memoKey, memoValue);\n            }\n            if (previous) {\n                state.loopVariables.set(key, previous);\n            } else {\n                state.loopVariables.delete(key);\n            }\n        }\n        body.push(\"}\");\n        return { expr: valueVar, type: initial.type };\n    },\n};\n"],"names":[],"mappings":";AAGA,SAAS,QAAQ,OAAc,SAAyB;AACpD,SAAO,GAAG,KAAK,IAAI,OAAO;AAC9B;AAEA,SAAS,qBAAqB,OAAkB,KAAuD;;AACnG,QAAM,SAAsB,CAAA;AAC5B,aAAW,aAAa,IAAI,MAAM,OAAO,UAAU;AAC/C,QAAI,UAAU,cAAc,qBAAqB;AAC7C;AAAA,IACJ;AACA,UAAM,UAAS,eAAU,OAAO,IAAI,QAAQ,MAA7B,mBAAgC;AAC/C,SAAI,iCAAQ,aAAY,MAAM,MAAM,OAAO,eAAe,UAAU;AAChE,aAAO,KAAK,SAAS;AAAA,IACzB;AAAA,EACJ;AACA,SAAO;AACX;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,SAAS,MAAM,cAAc,IAAI,QAAQ,OAAO,MAAM,EAAE,CAAC;AAC/D,QAAI,eAAe,SAAS;AACxB,UAAI,CAAC,QAAQ;AACT,cAAM,IAAI,MAAM,cAAc,MAAM,IAAI,wDAAwD;AAAA,MACpG;AACA,aAAO,EAAE,MAAM,OAAO,OAAO,QAAQ,KAAK,MAAM,MAAA;AAAA,IACpD;AACA,QAAI,eAAe,UAAU;AACzB,YAAM,IAAI,MAAM,cAAc,MAAM,IAAI,sEAAsE;AAAA,IAClH;AACA,QAAI,eAAe,UAAU;AACzB,YAAM,IAAI,MAAM,cAAc,MAAM,IAAI,0BAA0B,UAAU,GAAG;AAAA,IACnF;AAEA,UAAM,UAAU,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACxD,UAAM,WAAW,IAAI,KAAK,OAAO,MAAM;AACvC,UAAM,WAAW,IAAI,KAAK,OAAO,WAAW;AAC5C,UAAM,OAAO,UAAU,WAAW,MAAM,OAAO,OAAO,MAAM,SAAS;AACrE,SAAK,KAAK,OAAO,QAAQ,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,QAAQ,IAAI,GAAG;AAErE,UAAM,kBAAkB,MAAM,OAAO,IAAI,YAAY;AACrD,UAAM,cAAa,mDAAiB,UAC9B,OAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,cAAc,OAAO,KAAK,GAAG,KAAK,EAAE,IAAI,MAC3E,OAAO,KAAK,IAAI,GAAG,KAAK,MAAO,MAAM,WAAW,YAAY,KAA4B,CAAC,CAAC,CAAC;AAEjG,SAAK,KAAK,YAAY,QAAQ,SAAS,QAAQ,MAAM,UAAU,KAAK,QAAQ,MAAM,QAAQ,SAAS;AACnG,UAAM,MAAM,QAAQ,OAAO,MAAM,EAAE;AACnC,UAAM,WAAW,MAAM,cAAc,IAAI,GAAG;AAC5C,UAAM,aAAa,UAAU,WAAW,MAAM,SAAS,MAAM;AAC7D,UAAM,eAAe,IAAI,IAAI,WAAW,IAAI;AAC5C,UAAM,cAAc,IAAI,KAAK,EAAE,UAAU,WAAW,QAAQ,MAAM,UAAU;AAC5E,QAAI;AACA,iBAAW,SAAS,qBAAqB,OAAO,GAAG,GAAG;AAClD,cAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,QAAQ,IAAI;AAC9E,aAAK,KAAK,GAAG,QAAQ,MAAM,MAAM,IAAI,GAAG;AAAA,MAC5C;AAAA,IACJ,UAAA;AACI,iBAAW,KAAK,MAAA;AAChB,iBAAW,CAAC,SAAS,SAAS,KAAK,cAAc;AAC7C,mBAAW,KAAK,IAAI,SAAS,SAAS;AAAA,MAC1C;AACA,UAAI,UAAU;AACV,cAAM,cAAc,IAAI,KAAK,QAAQ;AAAA,MACzC,OAAO;AACH,cAAM,cAAc,OAAO,GAAG;AAAA,MAClC;AAAA,IACJ;AACA,SAAK,KAAK,GAAG;AACb,WAAO,EAAE,MAAM,UAAU,MAAM,QAAQ,KAAA;AAAA,EAC3C;AACJ;"}