@babylonjs/lite 0.1.1

package/biplanar-block-DZnKuV81.js

@@ -0,0 +1,115 @@
+const OUTPUT = {
+  rgba: { swizzle: "", type: "vec4f" },
+  rgb: { swizzle: ".xyz", type: "vec3f" },
+  r: { swizzle: ".x", type: "f32" },
+  g: { swizzle: ".y", type: "f32" },
+  b: { swizzle: ".z", type: "f32" },
+  a: { swizzle: ".w", type: "f32" }
+};
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+function bindingName(block, inputName, ctx, fallback) {
+  const input = block.inputs.get(inputName);
+  if (input == null ? void 0 : input.source) {
+    const producer = ctx.graph.blocks.get(input.source.blockId);
+    return sanitize((producer == null ? void 0 : producer.name) || fallback);
+  }
+  return sanitize(fallback);
+}
+function ensureBinding(state, name) {
+  if (!state.textures.find((t) => t.name === name)) {
+    state.textures.push({ name, kind: "texture2d", texture: null });
+  }
+}
+function applyColorSpace(expr, outputName, convertToLinear, convertToGamma) {
+  if (!convertToLinear && !convertToGamma) {
+    return expr;
+  }
+  const power = convertToLinear ? "2.2" : "0.45454545";
+  if (outputName === "rgba") {
+    return `vec4<f32>(pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power})), ${expr}.w)`;
+  }
+  if (outputName === "rgb") {
+    return `pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power}))`;
+  }
+  if (outputName === "r" || outputName === "g" || outputName === "b") {
+    return `pow(max(${expr}${OUTPUT[outputName].swizzle}, 0.0), ${power})`;
+  }
+  return expr;
+}
+function emitBiPlanarSample(block, stage, state, ctx) {
+  var _a;
+  if (stage !== "fragment") {
+    throw new Error("BiPlanarBlock: texture projection is supported only in the fragment stage");
+  }
+  const stageState = state.fragment;
+  const memoKey = `_biplanar_${block.id}_sample`;
+  const memo = stageState.memo.get(memoKey);
+  if (memo) {
+    return memo;
+  }
+  const baseName = sanitize(block.name || `biPlanar${block.id}`);
+  const texX = bindingName(block, "source", ctx, baseName);
+  const texY = bindingName(block, "sourceY", ctx, texX);
+  ensureBinding(state, texX);
+  ensureBinding(state, texY);
+  const position = ctx.cast(ctx.resolve(block, "position", stage, state), "vec3f");
+  const normal = ctx.cast(ctx.resolve(block, "normal", stage, state), "vec3f");
+  const sharpness = ((_a = block.inputs.get("sharpness")) == null ? void 0 : _a.source) ? ctx.cast(ctx.resolve(block, "sharpness", stage, state), "f32").expr : "1.0";
+  const temp = ctx.temp(state, "bi");
+  const p = `_p${temp}`;
+  const dx = `_dx${temp}`;
+  const dy = `_dy${temp}`;
+  const n = `_n${temp}`;
+  const ma = `_ma${temp}`;
+  const mi = `_mi${temp}`;
+  const me = `_me${temp}`;
+  const x = `_x${temp}`;
+  const y = `_y${temp}`;
+  const w = `_w${temp}`;
+  const sample = `_sample${temp}`;
+  stageState.body.push(`let ${p} = ${position.expr};`);
+  stageState.body.push(`let ${dx} = dpdx(${p});`);
+  stageState.body.push(`let ${dy} = dpdy(${p});`);
+  stageState.body.push(`let ${n} = abs(${normal.expr});`);
+  stageState.body.push(`var ${ma}: vec3<i32>;`);
+  stageState.body.push(
+    `if (${n}.x > ${n}.y && ${n}.x > ${n}.z) { ${ma} = vec3<i32>(0, 1, 2); } else if (${n}.y > ${n}.z) { ${ma} = vec3<i32>(1, 2, 0); } else { ${ma} = vec3<i32>(2, 0, 1); }`
+  );
+  stageState.body.push(`var ${mi}: vec3<i32>;`);
+  stageState.body.push(
+    `if (${n}.x < ${n}.y && ${n}.x < ${n}.z) { ${mi} = vec3<i32>(0, 1, 2); } else if (${n}.y < ${n}.z) { ${mi} = vec3<i32>(1, 2, 0); } else { ${mi} = vec3<i32>(2, 0, 1); }`
+  );
+  stageState.body.push(`let ${me} = vec3<i32>(3, 3, 3) - ${mi} - ${ma};`);
+  stageState.body.push(
+    `let ${x} = textureSampleGrad(nodeTex_${texX}, nodeSamp_${texX}, vec2<f32>(${p}[${ma}.y], ${p}[${ma}.z]), vec2<f32>(${dx}[${ma}.y], ${dx}[${ma}.z]), vec2<f32>(${dy}[${ma}.y], ${dy}[${ma}.z]));`
+  );
+  stageState.body.push(
+    `let ${y} = textureSampleGrad(nodeTex_${texY}, nodeSamp_${texY}, vec2<f32>(${p}[${me}.y], ${p}[${me}.z]), vec2<f32>(${dx}[${me}.y], ${dx}[${me}.z]), vec2<f32>(${dy}[${me}.y], ${dy}[${me}.z]));`
+  );
+  stageState.body.push(`var ${w} = vec2<f32>(${n}[${ma}.x], ${n}[${me}.x]);`);
+  stageState.body.push(`${w} = clamp((${w} - vec2<f32>(0.5773)) / vec2<f32>(1.0 - 0.5773), vec2<f32>(0.0), vec2<f32>(1.0));`);
+  stageState.body.push(`${w} = pow(${w}, vec2<f32>(${sharpness} / 8.0));`);
+  stageState.body.push(`let ${sample} = (${x} * ${w}.x + ${y} * ${w}.y) / (${w}.x + ${w}.y);`);
+  const result = { expr: sample, type: "vec4f" };
+  stageState.memo.set(memoKey, result);
+  return result;
+}
+const emitter = {
+  className: "BiPlanarBlock",
+  emit(block, outputName, stage, state, ctx) {
+    if (outputName === "level") {
+      return { expr: "1.0", type: "f32" };
+    }
+    const sample = emitBiPlanarSample(block, stage, state, ctx);
+    const out = OUTPUT[outputName] ?? OUTPUT.rgba;
+    const serialized = block.serialized;
+    const converted = applyColorSpace(sample.expr, outputName, serialized.convertToLinearSpace === true, serialized.convertToGammaSpace === true);
+    return { expr: converted === sample.expr ? `${sample.expr}${out.swizzle}` : converted, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=biplanar-block-DZnKuV81.js.map

package/biplanar-block-DZnKuV81.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"biplanar-block-DZnKuV81.js","sources":["../src/material/node/blocks/biplanar-block.ts"],"sourcesContent":["/** BiPlanarBlock — two-axis variant of triplanar texture projection.\n *\n * Uses the Babylon.js/Iñigo Quilez biplanar method: choose major/median axes\n * from abs(normal), sample those projections with explicit position\n * derivatives, and blend with the shaped two-component weights.\n */\n\nimport type { BlockEmitter, NodeBlock, NodeBuildState, NodeEmitContext, NodeExpr, NodeValueType, Stage } from \"../node-types.js\";\n\nconst OUTPUT: Record<string, { swizzle: string; type: NodeValueType }> = {\n    rgba: { swizzle: \"\", type: \"vec4f\" },\n    rgb: { swizzle: \".xyz\", type: \"vec3f\" },\n    r: { swizzle: \".x\", type: \"f32\" },\n    g: { swizzle: \".y\", type: \"f32\" },\n    b: { swizzle: \".z\", type: \"f32\" },\n    a: { swizzle: \".w\", type: \"f32\" },\n};\n\nfunction sanitize(name: string): string {\n    return name.replace(/[^A-Za-z0-9_]/g, \"_\");\n}\n\nfunction bindingName(block: NodeBlock, inputName: string, ctx: NodeEmitContext, fallback: string): string {\n    const input = block.inputs.get(inputName);\n    if (input?.source) {\n        const producer = ctx.graph.blocks.get(input.source.blockId);\n        return sanitize(producer?.name || fallback);\n    }\n    return sanitize(fallback);\n}\n\nfunction ensureBinding(state: NodeBuildState, name: string): void {\n    if (!state.textures.find((t) => t.name === name)) {\n        state.textures.push({ name, kind: \"texture2d\", texture: null });\n    }\n}\n\nfunction applyColorSpace(expr: string, outputName: string, convertToLinear: boolean, convertToGamma: boolean): string {\n    if (!convertToLinear && !convertToGamma) {\n        return expr;\n    }\n    const power = convertToLinear ? \"2.2\" : \"0.45454545\";\n    if (outputName === \"rgba\") {\n        return `vec4<f32>(pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power})), ${expr}.w)`;\n    }\n    if (outputName === \"rgb\") {\n        return `pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power}))`;\n    }\n    if (outputName === \"r\" || outputName === \"g\" || outputName === \"b\") {\n        return `pow(max(${expr}${OUTPUT[outputName]!.swizzle}, 0.0), ${power})`;\n    }\n    return expr;\n}\n\nfunction emitBiPlanarSample(block: NodeBlock, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): NodeExpr {\n    if (stage !== \"fragment\") {\n        throw new Error(\"BiPlanarBlock: texture projection is supported only in the fragment stage\");\n    }\n\n    const stageState = state.fragment;\n    const memoKey = `_biplanar_${block.id}_sample`;\n    const memo = stageState.memo.get(memoKey);\n    if (memo) {\n        return memo;\n    }\n\n    const baseName = sanitize(block.name || `biPlanar${block.id}`);\n    const texX = bindingName(block, \"source\", ctx, baseName);\n    const texY = bindingName(block, \"sourceY\", ctx, texX);\n    ensureBinding(state, texX);\n    ensureBinding(state, texY);\n\n    const position = ctx.cast(ctx.resolve(block, \"position\", stage, state), \"vec3f\");\n    const normal = ctx.cast(ctx.resolve(block, \"normal\", stage, state), \"vec3f\");\n    const sharpness = block.inputs.get(\"sharpness\")?.source ? ctx.cast(ctx.resolve(block, \"sharpness\", stage, state), \"f32\").expr : \"1.0\";\n\n    const temp = ctx.temp(state, \"bi\");\n    const p = `_p${temp}`;\n    const dx = `_dx${temp}`;\n    const dy = `_dy${temp}`;\n    const n = `_n${temp}`;\n    const ma = `_ma${temp}`;\n    const mi = `_mi${temp}`;\n    const me = `_me${temp}`;\n    const x = `_x${temp}`;\n    const y = `_y${temp}`;\n    const w = `_w${temp}`;\n    const sample = `_sample${temp}`;\n\n    stageState.body.push(`let ${p} = ${position.expr};`);\n    stageState.body.push(`let ${dx} = dpdx(${p});`);\n    stageState.body.push(`let ${dy} = dpdy(${p});`);\n    stageState.body.push(`let ${n} = abs(${normal.expr});`);\n    stageState.body.push(`var ${ma}: vec3<i32>;`);\n    stageState.body.push(\n        `if (${n}.x > ${n}.y && ${n}.x > ${n}.z) { ${ma} = vec3<i32>(0, 1, 2); } else if (${n}.y > ${n}.z) { ${ma} = vec3<i32>(1, 2, 0); } else { ${ma} = vec3<i32>(2, 0, 1); }`\n    );\n    stageState.body.push(`var ${mi}: vec3<i32>;`);\n    stageState.body.push(\n        `if (${n}.x < ${n}.y && ${n}.x < ${n}.z) { ${mi} = vec3<i32>(0, 1, 2); } else if (${n}.y < ${n}.z) { ${mi} = vec3<i32>(1, 2, 0); } else { ${mi} = vec3<i32>(2, 0, 1); }`\n    );\n    stageState.body.push(`let ${me} = vec3<i32>(3, 3, 3) - ${mi} - ${ma};`);\n    stageState.body.push(\n        `let ${x} = textureSampleGrad(nodeTex_${texX}, nodeSamp_${texX}, vec2<f32>(${p}[${ma}.y], ${p}[${ma}.z]), vec2<f32>(${dx}[${ma}.y], ${dx}[${ma}.z]), vec2<f32>(${dy}[${ma}.y], ${dy}[${ma}.z]));`\n    );\n    stageState.body.push(\n        `let ${y} = textureSampleGrad(nodeTex_${texY}, nodeSamp_${texY}, vec2<f32>(${p}[${me}.y], ${p}[${me}.z]), vec2<f32>(${dx}[${me}.y], ${dx}[${me}.z]), vec2<f32>(${dy}[${me}.y], ${dy}[${me}.z]));`\n    );\n    stageState.body.push(`var ${w} = vec2<f32>(${n}[${ma}.x], ${n}[${me}.x]);`);\n    stageState.body.push(`${w} = clamp((${w} - vec2<f32>(0.5773)) / vec2<f32>(1.0 - 0.5773), vec2<f32>(0.0), vec2<f32>(1.0));`);\n    stageState.body.push(`${w} = pow(${w}, vec2<f32>(${sharpness} / 8.0));`);\n    stageState.body.push(`let ${sample} = (${x} * ${w}.x + ${y} * ${w}.y) / (${w}.x + ${w}.y);`);\n\n    const result = { expr: sample, type: \"vec4f\" } as const;\n    stageState.memo.set(memoKey, result);\n    return result;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"BiPlanarBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        if (outputName === \"level\") {\n            return { expr: \"1.0\", type: \"f32\" };\n        }\n        const sample = emitBiPlanarSample(block, stage, state, ctx);\n        const out = OUTPUT[outputName] ?? OUTPUT.rgba!;\n        const serialized = block.serialized as { convertToLinearSpace?: boolean; convertToGammaSpace?: boolean };\n        const converted = applyColorSpace(sample.expr, outputName, serialized.convertToLinearSpace === true, serialized.convertToGammaSpace === true);\n        return { expr: converted === sample.expr ? `${sample.expr}${out.swizzle}` : converted, type: out.type };\n    },\n};\n"],"names":[],"mappings":"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"}

package/bones-block-D6IhqUVV.js

@@ -0,0 +1,31 @@
+const HELPER_KEY = "nme_skinning";
+const HELPER_WGSL = `
+fn nme_skinningMatrix(indices: vec4<f32>, weights: vec4<f32>) -> mat4x4<f32> {
+    let i0 = u32(indices.x);
+    let i1 = u32(indices.y);
+    let i2 = u32(indices.z);
+    let i3 = u32(indices.w);
+    return nmeBones[i0] * weights.x
+         + nmeBones[i1] * weights.y
+         + nmeBones[i2] * weights.z
+         + nmeBones[i3] * weights.w;
+}
+`;
+const emitter = {
+  className: "BonesBlock",
+  stage: "vertex",
+  emit(block, _outputName, stage, state, ctx) {
+    const world = ctx.resolve(block, "world", stage, state);
+    if (!state.hasSkeleton) {
+      return world;
+    }
+    state.vertex.helpers.set(HELPER_KEY, HELPER_WGSL);
+    const indices = ctx.cast(ctx.resolve(block, "matricesIndices", stage, state), "vec4f").expr;
+    const weights = ctx.cast(ctx.resolve(block, "matricesWeights", stage, state), "vec4f").expr;
+    return { expr: `(${world.expr} * nme_skinningMatrix(${indices}, ${weights}))`, type: "mat4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=bones-block-D6IhqUVV.js.map

package/bones-block-D6IhqUVV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bones-block-D6IhqUVV.js","sources":["../src/material/node/blocks/bones-block.ts"],"sourcesContent":["/** BonesBlock — hardware skinning.\n *\n *  Inputs: matricesIndices, matricesWeights (+ optional extras for up to 8 bones\n *  per vertex), world (the model world matrix).\n *  Output: output (bone-skinned world matrix).\n *\n *  Scene sentinel: `nmeBones : array<mat4x4<f32>, N>` — provided by the skeleton\n *  bind group; the pipeline builder wires this when a BonesBlock is present.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nconst HELPER_KEY = \"nme_skinning\";\nconst HELPER_WGSL = `\nfn nme_skinningMatrix(indices: vec4<f32>, weights: vec4<f32>) -> mat4x4<f32> {\n    let i0 = u32(indices.x);\n    let i1 = u32(indices.y);\n    let i2 = u32(indices.z);\n    let i3 = u32(indices.w);\n    return nmeBones[i0] * weights.x\n         + nmeBones[i1] * weights.y\n         + nmeBones[i2] * weights.z\n         + nmeBones[i3] * weights.w;\n}\n`;\n\nexport const emitter: BlockEmitter = {\n    className: \"BonesBlock\",\n    stage: \"vertex\",\n    emit(block, _outputName, stage, state, ctx) {\n        const world = ctx.resolve(block, \"world\", stage, state);\n        if (!state.hasSkeleton) {\n            // No skeleton on any bound mesh — pass-through the world matrix.\n            return world;\n        }\n        state.vertex.helpers.set(HELPER_KEY, HELPER_WGSL);\n        const indices = ctx.cast(ctx.resolve(block, \"matricesIndices\", stage, state), \"vec4f\").expr;\n        const weights = ctx.cast(ctx.resolve(block, \"matricesWeights\", stage, state), \"vec4f\").expr;\n        return { expr: `(${world.expr} * nme_skinningMatrix(${indices}, ${weights}))`, type: \"mat4f\" };\n    },\n};\n"],"names":[],"mappings":"AAYA,MAAM,aAAa;AACnB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAab,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,QAAI,CAAC,MAAM,aAAa;AAEpB,aAAO;AAAA,IACX;AACA,UAAM,OAAO,QAAQ,IAAI,YAAY,WAAW;AAChD,UAAM,UAAU,IAAI,KAAK,IAAI,QAAQ,OAAO,mBAAmB,OAAO,KAAK,GAAG,OAAO,EAAE;AACvF,UAAM,UAAU,IAAI,KAAK,IAAI,QAAQ,OAAO,mBAAmB,OAAO,KAAK,GAAG,OAAO,EAAE;AACvF,WAAO,EAAE,MAAM,IAAI,MAAM,IAAI,yBAAyB,OAAO,KAAK,OAAO,MAAM,MAAM,QAAA;AAAA,EACzF;AACJ;"}

package/clamp-block-BdII67hT.js

@@ -0,0 +1,21 @@
+import { f as formatFloat } from "./_math-factory-C-QqW-Wi.js";
+import { aS as WGSL } from "./index-C8HOR2sB.js";
+const emitter = {
+  className: "ClampBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const value = ctx.resolve(block, "value", stage, state);
+    const minRaw = block.serialized.minimum;
+    const maxRaw = block.serialized.maximum;
+    const minScalar = typeof minRaw === "number" ? formatFloat(minRaw) : "0.0";
+    const maxScalar = typeof maxRaw === "number" ? formatFloat(maxRaw) : "1.0";
+    if (value.type === "f32") {
+      return { expr: `clamp(${value.expr}, ${minScalar}, ${maxScalar})`, type: value.type };
+    }
+    const t = WGSL[value.type];
+    return { expr: `clamp(${value.expr}, ${t}(${minScalar}), ${t}(${maxScalar}))`, type: value.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=clamp-block-BdII67hT.js.map

package/clamp-block-BdII67hT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp-block-BdII67hT.js","sources":["../src/material/node/blocks/clamp-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\nimport { formatFloat } from \"./_math-factory.js\";\nimport { WGSL } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ClampBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const value = ctx.resolve(block, \"value\", stage, state);\n        const minRaw = block.serialized.minimum;\n        const maxRaw = block.serialized.maximum;\n        const minScalar = typeof minRaw === \"number\" ? formatFloat(minRaw) : \"0.0\";\n        const maxScalar = typeof maxRaw === \"number\" ? formatFloat(maxRaw) : \"1.0\";\n        // WGSL clamp requires all three args to have matching types. Promote\n        // scalar bounds to the value's vector type when needed.\n        if (value.type === \"f32\") {\n            return { expr: `clamp(${value.expr}, ${minScalar}, ${maxScalar})`, type: value.type };\n        }\n        const t = WGSL[value.type];\n        return { expr: `clamp(${value.expr}, ${t}(${minScalar}), ${t}(${maxScalar}))`, type: value.type };\n    },\n};\n"],"names":[],"mappings":";;AAIO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,SAAS,MAAM,WAAW;AAChC,UAAM,SAAS,MAAM,WAAW;AAChC,UAAM,YAAY,OAAO,WAAW,WAAW,YAAY,MAAM,IAAI;AACrE,UAAM,YAAY,OAAO,WAAW,WAAW,YAAY,MAAM,IAAI;AAGrE,QAAI,MAAM,SAAS,OAAO;AACtB,aAAO,EAAE,MAAM,SAAS,MAAM,IAAI,KAAK,SAAS,KAAK,SAAS,KAAK,MAAM,MAAM,KAAA;AAAA,IACnF;AACA,UAAM,IAAI,KAAK,MAAM,IAAI;AACzB,WAAO,EAAE,MAAM,SAAS,MAAM,IAAI,KAAK,CAAC,IAAI,SAAS,MAAM,CAAC,IAAI,SAAS,MAAM,MAAM,MAAM,KAAA;AAAA,EAC/F;AACJ;"}

package/clearcoat-block-BGML4npi.js

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

package/clearcoat-block-BGML4npi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearcoat-block-BGML4npi.js","sources":["../src/material/node/blocks/clearcoat-block.ts"],"sourcesContent":["/** ClearCoatBlock — clear-coat layer marker for PBR-MR.\n *\n *  In the current Lite NME implementation the actual clear-coat math is\n *  performed inside `PBRMetallicRoughnessBlock` (which can address every\n *  ClearCoatBlock input directly via ctx.resolve). ClearCoatBlock therefore\n *  plays a marker role: it flips `state.usesClearcoat` so PBR-MR knows to\n *  emit the clear-coat code path, and exposes a vec3 placeholder output so\n *  any consumer wiring still type-checks. PBR-MR ignores the actual value;\n *  it only checks input connectivity and walks into this block to gather\n *  intensity / roughness / indexOfRefraction.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ClearCoatBlock\",\n    stage: \"fragment\",\n    emit(_block, _outputName, _stage, state, _ctx) {\n        state.usesClearcoat = true;\n        return { expr: `vec3<f32>(0.0)`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAcO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,OAAO,MAAM;AAC3C,UAAM,gBAAgB;AACtB,WAAO,EAAE,MAAM,kBAAkB,MAAM,QAAA;AAAA,EAC3C;AACJ;"}

package/clearcoat-fragment-LCiG98Rf.js

@@ -0,0 +1,256 @@
+import { av as PBR_HAS_CLEARCOAT, aw as PBR2_CC_INT_MAP, ax as PBR2_CC_ROUGH_MAP, ay as PBR2_CC_NORMAL_MAP, aq as PBR_HAS_METALLIC_REFLECTANCE_MAP, ar as PBR_HAS_REFLECTANCE_MAP, az as PBR2_CC_F0_REMAP_OFF } from "./index-C8HOR2sB.js";
+const STAGE_FRAGMENT = 2;
+const CC_HELPERS = `
+fn visibility_Kelemen(VdotH_kl: f32) -> f32 {
+return 0.25 / (VdotH_kl * VdotH_kl + 0.0000001);
+}
+fn getR0RemappedForClearCoat(f0_rc: vec3<f32>, ccA: f32, ccB: f32) -> vec3<f32> {
+let sf0 = sqrt(f0_rc);
+let num = ccA + ccB * sf0;
+let den = ccB + ccA * sf0;
+return saturate((num / den) * (num / den));
+}
+fn ccSchlick(f0: f32, cosTheta: f32) -> f32 {
+let t = 1.0 - cosTheta;
+let t2 = t * t;
+return f0 + (1.0 - f0) * (t2 * t2 * t);
+}
+`;
+const CC_INT_TEX = `material.ccParams.x * textureSample(ccIntensityTexture, ccIntensitySampler_, input.uv).r`;
+const CC_INT_PLAIN = `material.ccParams.x`;
+const CC_ROUGH_TEX = `clamp(material.ccParams.y * textureSample(ccRoughnessTexture, ccRoughnessSampler_, input.uv).g, 0.0, 1.0)`;
+const CC_ROUGH_PLAIN = `material.ccParams.y`;
+const CC_NORMAL_COMPUTE = `
+let cc_dp1 = dpdx(input.worldPos);
+let cc_dp2 = dpdy(input.worldPos);
+let cc_duv1 = dpdx(input.uv);
+let cc_duv2 = dpdy(input.uv);
+let cc_dp2perp = cross(cc_dp2, N_geom);
+let cc_dp1perp = cross(N_geom, cc_dp1);
+let cc_tFrame = cc_dp2perp * cc_duv1.x + cc_dp1perp * cc_duv2.x;
+let cc_bFrame = -(cc_dp2perp * cc_duv1.y + cc_dp1perp * cc_duv2.y);
+let cc_det = max(dot(cc_tFrame, cc_tFrame), dot(cc_bFrame, cc_bFrame));
+let cc_invmax = select(inverseSqrt(cc_det), 0.0, cc_det == 0.0);
+let cc_frame = mat3x3<f32>(cc_tFrame * cc_invmax, cc_bFrame * cc_invmax, N_geom);
+let ccNormSampleRaw = textureSample(ccNormalTexture, ccNormalSampler_, input.uv).rgb * 2.0 - 1.0;
+let ccNormScale = material.ccParams.z;
+var ccN = normalize(cc_frame * normalize(ccNormSampleRaw * vec3<f32>(ccNormScale, ccNormScale, 1.0)));
+`;
+function makeF0Remap(intensityExpr) {
+  return `
+{
+let ccInt_r = ${intensityExpr};
+let remappedF0 = getR0RemappedForClearCoat(colorF0, material.ccRefractionParams.z, material.ccRefractionParams.w);
+colorF0 = mix(colorF0, remappedF0, ccInt_r);
+}
+`;
+}
+function makeDirectMod(intensityExpr, roughnessExpr, hasNormalMap) {
+  const N = hasNormalMap ? "ccN" : "N_geom";
+  return `
+var ccDirectAttenuation = 1.0;
+var ccDirectSpecularTerm = vec3<f32>(0.0);
+{
+let ccInt_dl = ${intensityExpr};
+let ccRough_dl = ${roughnessExpr};
+let ccF0_dl = material.ccRefractionParams.x;
+let ccAlphaG_dl = ccRough_dl * ccRough_dl + 0.0005;
+let ccNdotL_dl = saturate(dot(${N}, L));
+let ccH_dl = normalize(V + L);
+let ccNdotH_dl = clamp(dot(${N}, ccH_dl), 0.0000001, 1.0);
+let ccVdotH_dl = saturate(dot(V, ccH_dl));
+let ccD_dl = distributionGGX(ccNdotH_dl, ccAlphaG_dl);
+let ccVis_dl = visibility_Kelemen(ccVdotH_dl);
+let ccFresnel_dl = ccSchlick(ccF0_dl, ccVdotH_dl);
+let ccTerm = ccFresnel_dl * ccD_dl * ccVis_dl * ccNdotL_dl;
+ccDirectSpecularTerm = vec3<f32>(ccTerm) * lightColor * lightAtten * material.directIntensity * ccInt_dl;
+ccDirectAttenuation = 1.0 - ccFresnel_dl * ccInt_dl;
+}
+`;
+}
+function makeIblMod(intensityExpr, roughnessExpr, hasNormalMap, hasSpecularAA, hasBaseNormalMap) {
+  const N = hasNormalMap ? "ccN" : "N_geom";
+  const alphaG = hasSpecularAA ? `let ccAlphaG_ibl_base = ccRough_ibl * ccRough_ibl + 0.0005;
+let cc_nDfdx_AA = dpdx(${N});
+let cc_nDfdy_AA = dpdy(${N});
+let cc_slopeSquare_AA = max(dot(cc_nDfdx_AA, cc_nDfdx_AA), dot(cc_nDfdy_AA, cc_nDfdy_AA));
+let ccAlphaG_ibl = ccAlphaG_ibl_base + sqrt(cc_slopeSquare_AA) * 0.75;` : `let ccAlphaG_ibl = ccRough_ibl * ccRough_ibl + 0.0005;`;
+  const ehoLine = hasBaseNormalMap ? `let ccEho_ibl = environmentHorizonOcclusion(-V, ${N}, N_geom);` : `let ccEho_ibl = 1.0;`;
+  return `
+{
+let ccInt_ibl = ${intensityExpr};
+let ccRough_ibl = ${roughnessExpr};
+let ccF0_ibl = material.ccRefractionParams.x;
+let ccR_raw = reflect(-V, ${N});
+let ccR_ibl = rotateY(ccR_raw, scene.envRotationY);
+let ccNdotV_ibl = abs(dot(${N}, V)) + 0.0000001;
+${alphaG}
+var ccSpecLod_ibl = log2(cubemapDim * ccAlphaG_ibl) * scene.vImageInfos.z;
+let ccEnvRadiance_ibl = textureSampleLevel(iblTexture, iblSampler, ccR_ibl, clamp(ccSpecLod_ibl, 0.0, maxLod)).rgb * material.environmentIntensity;
+let ccBrdf_ibl = textureSample(brdfLUT, brdfSampler_, vec2<f32>(ccNdotV_ibl, ccRough_ibl)).rgb;
+${ehoLine}
+let ccSpecEnvRefl = (vec3<f32>(ccF0_ibl) * ccBrdf_ibl.y + (vec3<f32>(1.0) - vec3<f32>(ccF0_ibl)) * ccBrdf_ibl.x) * ccInt_ibl * ccEho_ibl;
+let ccFresnelIBL = ccSchlick(ccF0_ibl, ccNdotV_ibl);
+let ccConservation_ibl = 1.0 - ccFresnelIBL * ccInt_ibl;
+let ccFinalRadiance_ibl = ccEnvRadiance_ibl * ccSpecEnvRefl;
+color = finalIrradiance * ccConservation_ibl
+      + finalRadianceScaled * ccConservation_ibl
+      + finalSpecularScaled * ccDirectAttenuation
+      + directDiffuse * ccDirectAttenuation
+      + ccDirectSpecularTerm
+      + ccFinalRadiance_ibl
+      + emissive;
+}
+`;
+}
+function makeNonIblMod(intensityExpr) {
+  return `
+{
+let ccF0_noIbl = material.ccRefractionParams.x;
+let ccInt_noIbl = ${intensityExpr};
+let ccFresnelNoIbl = ccSchlick(ccF0_noIbl, NdotV);
+let ccCons_noIbl = 1.0 - ccFresnelNoIbl * ccInt_noIbl;
+color = (color - emissive) * ccCons_noIbl + emissive + ccDirectSpecularTerm;
+}
+`;
+}
+function createClearcoatFragment(features, features2, hasIbl, hasBaseNormalMap, hasSpecularAA) {
+  if ((features & PBR_HAS_CLEARCOAT) === 0) {
+    return null;
+  }
+  const hasReflectance = (features & (PBR_HAS_METALLIC_REFLECTANCE_MAP | PBR_HAS_REFLECTANCE_MAP)) !== 0;
+  const hasIntensityMap = (features2 & PBR2_CC_INT_MAP) !== 0;
+  const hasRoughnessMap = (features2 & PBR2_CC_ROUGH_MAP) !== 0;
+  const hasNormalMap = (features2 & PBR2_CC_NORMAL_MAP) !== 0;
+  const disableF0Remap = (features2 & PBR2_CC_F0_REMAP_OFF) !== 0;
+  const intensityExpr = hasIntensityMap ? CC_INT_TEX : CC_INT_PLAIN;
+  const roughnessExpr = hasRoughnessMap ? CC_ROUGH_TEX : CC_ROUGH_PLAIN;
+  const slots = {
+    MF: disableF0Remap ? "" : makeF0Remap(intensityExpr),
+    AD: makeDirectMod(intensityExpr, roughnessExpr, hasNormalMap),
+    BL: `var ccDirectAttenuation = 1.0;
+var ccDirectSpecularTerm = vec3<f32>(0.0);`
+  };
+  if (hasNormalMap) {
+    slots.AC = CC_NORMAL_COMPUTE;
+  }
+  if (hasIbl) {
+    slots.AI = makeIblMod(intensityExpr, roughnessExpr, hasNormalMap, hasSpecularAA, hasBaseNormalMap);
+  } else {
+    slots.NI = makeNonIblMod(intensityExpr);
+  }
+  const deps = [];
+  if (hasIbl) {
+    deps.push("ibl");
+  }
+  if (hasReflectance) {
+    deps.push("reflectance");
+  }
+  const suffix = (hasIntensityMap ? "I" : "") + (hasRoughnessMap ? "R" : "") + (hasNormalMap ? "N" : "") + (disableF0Remap ? "X" : "") + (hasSpecularAA ? "A" : "") + (hasBaseNormalMap ? "B" : "");
+  const bindings = [];
+  if (hasIntensityMap) {
+    bindings.push(
+      { _name: "ccIntensityTexture", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "ccIntensitySampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+  }
+  if (hasRoughnessMap) {
+    bindings.push(
+      { _name: "ccRoughnessTexture", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "ccRoughnessSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+  }
+  if (hasNormalMap) {
+    bindings.push(
+      { _name: "ccNormalTexture", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "ccNormalSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+  }
+  return {
+    _id: suffix ? `clearcoat-${suffix}` : "clearcoat",
+    _dependencies: deps.length > 0 ? deps : void 0,
+    _uboFields: [
+      { _name: "ccParams", _type: "vec4<f32>" },
+      { _name: "ccRefractionParams", _type: "vec4<f32>" }
+    ],
+    _bindings: bindings,
+    _helperFunctions: CC_HELPERS,
+    _fragmentSlots: slots
+  };
+}
+function writeClearcoatUBO(data, material, offsets) {
+  const cc = material.clearCoat;
+  if (!(cc == null ? void 0 : cc.isEnabled) || !offsets.has("ccParams")) {
+    return;
+  }
+  const off = offsets.get("ccParams") / 4;
+  const ior = cc.indexOfRefraction ?? 1.5;
+  const a = 1 - ior;
+  const b = 1 + ior;
+  data[off] = cc.intensity ?? 1;
+  data[off + 1] = cc.roughness ?? 0;
+  data[off + 2] = cc.bumpTextureScale ?? 1;
+  data[off + 4] = Math.pow(-a / b, 2);
+  data[off + 5] = 1 / ior;
+  data[off + 6] = a;
+  data[off + 7] = b;
+}
+const CC_TEX = [
+  [PBR2_CC_INT_MAP, "texture"],
+  [PBR2_CC_ROUGH_MAP, "roughnessTexture"],
+  [PBR2_CC_NORMAL_MAP, "bumpTexture"]
+];
+const pbrExt = {
+  id: "clearcoat",
+  phase: "base-tex",
+  detect(mat) {
+    const cc = mat.clearCoat;
+    if (!(cc == null ? void 0 : cc.isEnabled)) {
+      return { f: 0, f2: 0 };
+    }
+    let f2 = 0;
+    for (const [flag, key] of CC_TEX) {
+      if (cc[key]) {
+        f2 |= flag;
+      }
+    }
+    if (cc.useF0Remap === false) {
+      f2 |= PBR2_CC_F0_REMAP_OFF;
+    }
+    return { f: PBR_HAS_CLEARCOAT, f2 };
+  },
+  frag: (ctx) => createClearcoatFragment(ctx._features, ctx._features2, ctx._hasIbl, ctx._hasAnyNormal, ctx._hasSpecularAA),
+  writeUbo: writeClearcoatUBO,
+  bind(ctx, entries, b) {
+    const cc = ctx._material.clearCoat;
+    if (!cc) {
+      return b;
+    }
+    for (const [flag, key] of CC_TEX) {
+      const tex = cc[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 cc = mat.clearCoat;
+    if (!cc) {
+      return;
+    }
+    for (const [, key] of CC_TEX) {
+      const tex = cc[key];
+      if (tex) {
+        t.push(tex);
+      }
+    }
+  }
+};
+export {
+  createClearcoatFragment,
+  pbrExt,
+  writeClearcoatUBO
+};
+//# sourceMappingURL=clearcoat-fragment-LCiG98Rf.js.map

package/clearcoat-fragment-LCiG98Rf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearcoat-fragment-LCiG98Rf.js","sources":["../src/material/pbr/fragments/clearcoat-fragment.ts"],"sourcesContent":["/**\n * Clearcoat Fragment\n *\n * Adds a glossy transparent top layer (like car paint or lacquered surfaces).\n * Only bundled when a scene uses PbrMaterialProps.clearCoat.\n *\n * Math follows BJS PBRClearCoatConfiguration:\n *  - F0 from IOR: ((1-ior)/(1+ior))^2\n *  - F0 remap: base F0 adjusted for coat/base interface\n *  - Direct: GGX + Kelemen visibility + Schlick fresnel\n *  - IBL: Jones analytical BRDF (not BRDF LUT)\n *  - Conservation: base layer attenuated by (1 - fresnel * intensity)\n *\n * Supports glTF KHR_materials_clearcoat textures:\n *  - clearcoatTexture (R channel multiplies intensity)\n *  - clearcoatRoughnessTexture (G channel multiplies roughness)\n *  - clearcoatNormalTexture (tangent-space normal, perturbs coat normal)\n */\n\nimport type { ShaderFragment, BindingDecl } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps, ClearCoatProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport {\n    PBR_HAS_CLEARCOAT,\n    PBR_HAS_METALLIC_REFLECTANCE_MAP,\n    PBR_HAS_REFLECTANCE_MAP,\n    PBR2_CC_INT_MAP,\n    PBR2_CC_ROUGH_MAP,\n    PBR2_CC_NORMAL_MAP,\n    PBR2_CC_F0_REMAP_OFF,\n} from \"../pbr-flag-bits.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\nconst CC_HELPERS = `\nfn visibility_Kelemen(VdotH_kl: f32) -> f32 {\nreturn 0.25 / (VdotH_kl * VdotH_kl + 0.0000001);\n}\nfn getR0RemappedForClearCoat(f0_rc: vec3<f32>, ccA: f32, ccB: f32) -> vec3<f32> {\nlet sf0 = sqrt(f0_rc);\nlet num = ccA + ccB * sf0;\nlet den = ccB + ccA * sf0;\nreturn saturate((num / den) * (num / den));\n}\nfn ccSchlick(f0: f32, cosTheta: f32) -> f32 {\nlet t = 1.0 - cosTheta;\nlet t2 = t * t;\nreturn f0 + (1.0 - f0) * (t2 * t2 * t);\n}\n`;\n\nconst CC_INT_TEX = `material.ccParams.x * textureSample(ccIntensityTexture, ccIntensitySampler_, input.uv).r`;\nconst CC_INT_PLAIN = `material.ccParams.x`;\nconst CC_ROUGH_TEX = `clamp(material.ccParams.y * textureSample(ccRoughnessTexture, ccRoughnessSampler_, input.uv).g, 0.0, 1.0)`;\nconst CC_ROUGH_PLAIN = `material.ccParams.y`;\n\n// WGSL fragment: coat-layer normal. Computes ccN (coat world-space normal)\n// using a locally-derived cotangent frame from world-position and UV derivatives.\n// Emitted in /*AC*/ so ccN is in scope for direct + IBL blocks.\nconst CC_NORMAL_COMPUTE = `\nlet cc_dp1 = dpdx(input.worldPos);\nlet cc_dp2 = dpdy(input.worldPos);\nlet cc_duv1 = dpdx(input.uv);\nlet cc_duv2 = dpdy(input.uv);\nlet cc_dp2perp = cross(cc_dp2, N_geom);\nlet cc_dp1perp = cross(N_geom, cc_dp1);\nlet cc_tFrame = cc_dp2perp * cc_duv1.x + cc_dp1perp * cc_duv2.x;\nlet cc_bFrame = -(cc_dp2perp * cc_duv1.y + cc_dp1perp * cc_duv2.y);\nlet cc_det = max(dot(cc_tFrame, cc_tFrame), dot(cc_bFrame, cc_bFrame));\nlet cc_invmax = select(inverseSqrt(cc_det), 0.0, cc_det == 0.0);\nlet cc_frame = mat3x3<f32>(cc_tFrame * cc_invmax, cc_bFrame * cc_invmax, N_geom);\nlet ccNormSampleRaw = textureSample(ccNormalTexture, ccNormalSampler_, input.uv).rgb * 2.0 - 1.0;\nlet ccNormScale = material.ccParams.z;\nvar ccN = normalize(cc_frame * normalize(ccNormSampleRaw * vec3<f32>(ccNormScale, ccNormScale, 1.0)));\n`;\n\nfunction makeF0Remap(intensityExpr: string): string {\n    return `\n{\nlet ccInt_r = ${intensityExpr};\nlet remappedF0 = getR0RemappedForClearCoat(colorF0, material.ccRefractionParams.z, material.ccRefractionParams.w);\ncolorF0 = mix(colorF0, remappedF0, ccInt_r);\n}\n`;\n}\n\nfunction makeDirectMod(intensityExpr: string, roughnessExpr: string, hasNormalMap: boolean): string {\n    const N = hasNormalMap ? \"ccN\" : \"N_geom\";\n    return `\nvar ccDirectAttenuation = 1.0;\nvar ccDirectSpecularTerm = vec3<f32>(0.0);\n{\nlet ccInt_dl = ${intensityExpr};\nlet ccRough_dl = ${roughnessExpr};\nlet ccF0_dl = material.ccRefractionParams.x;\nlet ccAlphaG_dl = ccRough_dl * ccRough_dl + 0.0005;\nlet ccNdotL_dl = saturate(dot(${N}, L));\nlet ccH_dl = normalize(V + L);\nlet ccNdotH_dl = clamp(dot(${N}, ccH_dl), 0.0000001, 1.0);\nlet ccVdotH_dl = saturate(dot(V, ccH_dl));\nlet ccD_dl = distributionGGX(ccNdotH_dl, ccAlphaG_dl);\nlet ccVis_dl = visibility_Kelemen(ccVdotH_dl);\nlet ccFresnel_dl = ccSchlick(ccF0_dl, ccVdotH_dl);\nlet ccTerm = ccFresnel_dl * ccD_dl * ccVis_dl * ccNdotL_dl;\nccDirectSpecularTerm = vec3<f32>(ccTerm) * lightColor * lightAtten * material.directIntensity * ccInt_dl;\nccDirectAttenuation = 1.0 - ccFresnel_dl * ccInt_dl;\n}\n`;\n}\n\nfunction makeIblMod(intensityExpr: string, roughnessExpr: string, hasNormalMap: boolean, hasSpecularAA: boolean, hasBaseNormalMap: boolean): string {\n    const N = hasNormalMap ? \"ccN\" : \"N_geom\";\n    const alphaG = hasSpecularAA\n        ? `let ccAlphaG_ibl_base = ccRough_ibl * ccRough_ibl + 0.0005;\nlet cc_nDfdx_AA = dpdx(${N});\nlet cc_nDfdy_AA = dpdy(${N});\nlet cc_slopeSquare_AA = max(dot(cc_nDfdx_AA, cc_nDfdx_AA), dot(cc_nDfdy_AA, cc_nDfdy_AA));\nlet ccAlphaG_ibl = ccAlphaG_ibl_base + sqrt(cc_slopeSquare_AA) * 0.75;`\n        : `let ccAlphaG_ibl = ccRough_ibl * ccRough_ibl + 0.0005;`;\n    const ehoLine = hasBaseNormalMap ? `let ccEho_ibl = environmentHorizonOcclusion(-V, ${N}, N_geom);` : `let ccEho_ibl = 1.0;`;\n    return `\n{\nlet ccInt_ibl = ${intensityExpr};\nlet ccRough_ibl = ${roughnessExpr};\nlet ccF0_ibl = material.ccRefractionParams.x;\nlet ccR_raw = reflect(-V, ${N});\nlet ccR_ibl = rotateY(ccR_raw, scene.envRotationY);\nlet ccNdotV_ibl = abs(dot(${N}, V)) + 0.0000001;\n${alphaG}\nvar ccSpecLod_ibl = log2(cubemapDim * ccAlphaG_ibl) * scene.vImageInfos.z;\nlet ccEnvRadiance_ibl = textureSampleLevel(iblTexture, iblSampler, ccR_ibl, clamp(ccSpecLod_ibl, 0.0, maxLod)).rgb * material.environmentIntensity;\nlet ccBrdf_ibl = textureSample(brdfLUT, brdfSampler_, vec2<f32>(ccNdotV_ibl, ccRough_ibl)).rgb;\n${ehoLine}\nlet ccSpecEnvRefl = (vec3<f32>(ccF0_ibl) * ccBrdf_ibl.y + (vec3<f32>(1.0) - vec3<f32>(ccF0_ibl)) * ccBrdf_ibl.x) * ccInt_ibl * ccEho_ibl;\nlet ccFresnelIBL = ccSchlick(ccF0_ibl, ccNdotV_ibl);\nlet ccConservation_ibl = 1.0 - ccFresnelIBL * ccInt_ibl;\nlet ccFinalRadiance_ibl = ccEnvRadiance_ibl * ccSpecEnvRefl;\ncolor = finalIrradiance * ccConservation_ibl\n      + finalRadianceScaled * ccConservation_ibl\n      + finalSpecularScaled * ccDirectAttenuation\n      + directDiffuse * ccDirectAttenuation\n      + ccDirectSpecularTerm\n      + ccFinalRadiance_ibl\n      + emissive;\n}\n`;\n}\n\nfunction makeNonIblMod(intensityExpr: string): string {\n    return `\n{\nlet ccF0_noIbl = material.ccRefractionParams.x;\nlet ccInt_noIbl = ${intensityExpr};\nlet ccFresnelNoIbl = ccSchlick(ccF0_noIbl, NdotV);\nlet ccCons_noIbl = 1.0 - ccFresnelNoIbl * ccInt_noIbl;\ncolor = (color - emissive) * ccCons_noIbl + emissive + ccDirectSpecularTerm;\n}\n`;\n}\n\nexport function createClearcoatFragment(features: number, features2: number, hasIbl: boolean, hasBaseNormalMap: boolean, hasSpecularAA: boolean): ShaderFragment | null {\n    if ((features & PBR_HAS_CLEARCOAT) === 0) {\n        return null;\n    }\n    const hasReflectance = (features & (PBR_HAS_METALLIC_REFLECTANCE_MAP | PBR_HAS_REFLECTANCE_MAP)) !== 0;\n    const hasIntensityMap = (features2 & PBR2_CC_INT_MAP) !== 0;\n    const hasRoughnessMap = (features2 & PBR2_CC_ROUGH_MAP) !== 0;\n    const hasNormalMap = (features2 & PBR2_CC_NORMAL_MAP) !== 0;\n    const disableF0Remap = (features2 & PBR2_CC_F0_REMAP_OFF) !== 0;\n    const intensityExpr = hasIntensityMap ? CC_INT_TEX : CC_INT_PLAIN;\n    const roughnessExpr = hasRoughnessMap ? CC_ROUGH_TEX : CC_ROUGH_PLAIN;\n    const slots: Partial<Record<string, string>> = {\n        MF: disableF0Remap ? \"\" : makeF0Remap(intensityExpr),\n        AD: makeDirectMod(intensityExpr, roughnessExpr, hasNormalMap),\n        BL: `var ccDirectAttenuation = 1.0;\\nvar ccDirectSpecularTerm = vec3<f32>(0.0);`,\n    };\n    if (hasNormalMap) {\n        slots.AC = CC_NORMAL_COMPUTE;\n    }\n    // AI and NI are mutually exclusive — only one path runs\n    if (hasIbl) {\n        slots.AI = makeIblMod(intensityExpr, roughnessExpr, hasNormalMap, hasSpecularAA, hasBaseNormalMap);\n    } else {\n        slots.NI = makeNonIblMod(intensityExpr);\n    }\n    const deps: string[] = [];\n    if (hasIbl) {\n        deps.push(\"ibl\");\n    }\n    if (hasReflectance) {\n        deps.push(\"reflectance\");\n    }\n    // Fragment id varies with texture config so shader-composer's fragmentKey\n    // (and downstream pipeline cache) distinguishes variants.\n    const suffix =\n        (hasIntensityMap ? \"I\" : \"\") +\n        (hasRoughnessMap ? \"R\" : \"\") +\n        (hasNormalMap ? \"N\" : \"\") +\n        (disableF0Remap ? \"X\" : \"\") +\n        (hasSpecularAA ? \"A\" : \"\") +\n        (hasBaseNormalMap ? \"B\" : \"\");\n    const bindings: BindingDecl[] = [];\n    if (hasIntensityMap) {\n        bindings.push(\n            { _name: \"ccIntensityTexture\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"ccIntensitySampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n    }\n    if (hasRoughnessMap) {\n        bindings.push(\n            { _name: \"ccRoughnessTexture\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"ccRoughnessSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n    }\n    if (hasNormalMap) {\n        bindings.push(\n            { _name: \"ccNormalTexture\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"ccNormalSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n    }\n\n    return {\n        _id: suffix ? `clearcoat-${suffix}` : \"clearcoat\",\n        _dependencies: deps.length > 0 ? deps : undefined,\n\n        _uboFields: [\n            { _name: \"ccParams\", _type: \"vec4<f32>\" },\n            { _name: \"ccRefractionParams\", _type: \"vec4<f32>\" },\n        ],\n\n        _bindings: bindings,\n\n        _helperFunctions: CC_HELPERS,\n\n        _fragmentSlots: slots,\n    };\n}\n\n/** Write the clearcoat material-UBO slice (ccParams + ccParams2). */\nexport function writeClearcoatUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    const cc = material.clearCoat as ClearCoatProps | undefined;\n    if (!cc?.isEnabled || !offsets.has(\"ccParams\")) {\n        return;\n    }\n    const off = offsets.get(\"ccParams\")! / 4;\n    const ior = cc.indexOfRefraction ?? 1.5;\n    const a = 1 - ior;\n    const b = 1 + ior;\n    data[off] = cc.intensity ?? 1.0;\n    data[off + 1] = cc.roughness ?? 0.0;\n    data[off + 2] = cc.bumpTextureScale ?? 1.0;\n    data[off + 4] = Math.pow(-a / b, 2);\n    data[off + 5] = 1 / ior;\n    data[off + 6] = a;\n    data[off + 7] = b;\n}\n\nconst CC_TEX: ReadonlyArray<readonly [number, \"texture\" | \"roughnessTexture\" | \"bumpTexture\"]> = [\n    [PBR2_CC_INT_MAP, \"texture\"],\n    [PBR2_CC_ROUGH_MAP, \"roughnessTexture\"],\n    [PBR2_CC_NORMAL_MAP, \"bumpTexture\"],\n];\n\n/** Clearcoat PBR extension (group 1, base-tex phase). */\nexport const pbrExt: PbrExt = {\n    id: \"clearcoat\",\n    phase: \"base-tex\",\n    detect(mat) {\n        const cc = (mat as PbrMaterialProps).clearCoat as ClearCoatProps | undefined;\n        if (!cc?.isEnabled) {\n            return { f: 0, f2: 0 };\n        }\n        let f2 = 0;\n        for (const [flag, key] of CC_TEX) {\n            if (cc[key]) {\n                f2 |= flag;\n            }\n        }\n        if (cc.useF0Remap === false) {\n            f2 |= PBR2_CC_F0_REMAP_OFF;\n        }\n        return { f: PBR_HAS_CLEARCOAT, f2 };\n    },\n    frag: (ctx) => createClearcoatFragment(ctx._features, ctx._features2, ctx._hasIbl, ctx._hasAnyNormal, ctx._hasSpecularAA),\n    writeUbo: writeClearcoatUBO as PbrExt[\"writeUbo\"],\n    bind(ctx, entries, b) {\n        const cc = (ctx._material as PbrMaterialProps).clearCoat as ClearCoatProps | undefined;\n        if (!cc) {\n            return b;\n        }\n        for (const [flag, key] of CC_TEX) {\n            const tex = cc[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 cc = (mat as PbrMaterialProps).clearCoat;\n        if (!cc) {\n            return;\n        }\n        for (const [, key] of CC_TEX) {\n            const tex = cc[key];\n            if (tex) {\n                t.push(tex);\n            }\n        }\n    },\n};\n"],"names":[],"mappings":"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"}

package/clip-planes-block-BPfFJrbf.js

@@ -0,0 +1,26 @@
+const emitter = {
+  className: "ClipPlanesBlock",
+  stage: "vertex",
+  sideEffect: true,
+  emit(block, _outputName, _stage, state, ctx) {
+    state.usesClipPlanes = true;
+    const memoKey = `_clip_${block.id}`;
+    if (!state.vertex.memo.has(memoKey)) {
+      const worldPosition = ctx.cast(ctx.resolve(block, "worldPosition", "vertex", state), "vec4f");
+      if (!state.varyings.find((v) => v._name === "vClipDistance")) {
+        state.varyings.push({ _name: "vClipDistance", _type: "f32" });
+      }
+      state.vertex.body.push(`out.vClipDistance = dot(${worldPosition.expr}, sceneU.clipPlane);`);
+      state.vertex.memo.set(memoKey, { expr: "out.vClipDistance", type: "f32" });
+    }
+    if (!state.fragment.memo.has(memoKey)) {
+      state.fragment.body.push(`if (in.vClipDistance > 0.0) { discard; }`);
+      state.fragment.memo.set(memoKey, { expr: "in.vClipDistance", type: "f32" });
+    }
+    return { expr: "0.0", type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=clip-planes-block-BPfFJrbf.js.map

package/clip-planes-block-BPfFJrbf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip-planes-block-BPfFJrbf.js","sources":["../src/material/node/blocks/clip-planes-block.ts"],"sourcesContent":["/** ClipPlanesBlock — scene clip-plane discard.\n *\n * Supports Babylon.js' first scene/material clip plane. The block consumes a\n * world-space position, writes the signed clip distance in the vertex stage, and\n * discards fragments with a positive distance, matching BJS' WGSL include.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ClipPlanesBlock\",\n    stage: \"vertex\",\n    sideEffect: true,\n    emit(block, _outputName, _stage, state, ctx) {\n        state.usesClipPlanes = true;\n        const memoKey = `_clip_${block.id}`;\n        if (!state.vertex.memo.has(memoKey)) {\n            const worldPosition = ctx.cast(ctx.resolve(block, \"worldPosition\", \"vertex\", state), \"vec4f\");\n            if (!state.varyings.find((v) => v._name === \"vClipDistance\")) {\n                state.varyings.push({ _name: \"vClipDistance\", _type: \"f32\" });\n            }\n            state.vertex.body.push(`out.vClipDistance = dot(${worldPosition.expr}, sceneU.clipPlane);`);\n            state.vertex.memo.set(memoKey, { expr: \"out.vClipDistance\", type: \"f32\" });\n        }\n        if (!state.fragment.memo.has(memoKey)) {\n            state.fragment.body.push(`if (in.vClipDistance > 0.0) { discard; }`);\n            state.fragment.memo.set(memoKey, { expr: \"in.vClipDistance\", type: \"f32\" });\n        }\n        return { expr: \"0.0\", type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AASO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,KAAK,OAAO,aAAa,QAAQ,OAAO,KAAK;AACzC,UAAM,iBAAiB;AACvB,UAAM,UAAU,SAAS,MAAM,EAAE;AACjC,QAAI,CAAC,MAAM,OAAO,KAAK,IAAI,OAAO,GAAG;AACjC,YAAM,gBAAgB,IAAI,KAAK,IAAI,QAAQ,OAAO,iBAAiB,UAAU,KAAK,GAAG,OAAO;AAC5F,UAAI,CAAC,MAAM,SAAS,KAAK,CAAC,MAAM,EAAE,UAAU,eAAe,GAAG;AAC1D,cAAM,SAAS,KAAK,EAAE,OAAO,iBAAiB,OAAO,OAAO;AAAA,MAChE;AACA,YAAM,OAAO,KAAK,KAAK,2BAA2B,cAAc,IAAI,sBAAsB;AAC1F,YAAM,OAAO,KAAK,IAAI,SAAS,EAAE,MAAM,qBAAqB,MAAM,OAAO;AAAA,IAC7E;AACA,QAAI,CAAC,MAAM,SAAS,KAAK,IAAI,OAAO,GAAG;AACnC,YAAM,SAAS,KAAK,KAAK,0CAA0C;AACnE,YAAM,SAAS,KAAK,IAAI,SAAS,EAAE,MAAM,oBAAoB,MAAM,OAAO;AAAA,IAC9E;AACA,WAAO,EAAE,MAAM,OAAO,MAAM,MAAA;AAAA,EAChC;AACJ;"}

package/cloud-block-BeVrangc.js

@@ -0,0 +1,90 @@
+function optional(block, inputName, stage, state, ctx) {
+  const input = block.inputs.get(inputName);
+  return (input == null ? void 0 : input.source) ? ctx.resolve(block, inputName, stage, state) : null;
+}
+function scalarOffset(block, inputName, stage, state, ctx) {
+  const value = optional(block, inputName, stage, state, ctx);
+  return value ? ctx.cast(value, "f32").expr : null;
+}
+const emitter = {
+  className: "CloudBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const seed = ctx.resolve(block, "seed", stage, state);
+    if (seed.type !== "vec2f" && seed.type !== "vec3f") {
+      throw new Error(`NodeMaterial: CloudBlock requires vec2 or vec3 seed; got ${seed.type}`);
+    }
+    state[stage].helpers.set(
+      "nme_cloudNoise",
+      `fn nme_cloudRandom(p: f32) -> f32 {
+var temp = fract(p * 0.011);
+temp *= temp + 7.5;
+temp *= temp + temp;
+return fract(temp);
+}
+fn nme_cloudNoise2(x: vec2<f32>, chaos: vec2<f32>) -> f32 {
+let stepv = chaos * vec2<f32>(75.0, 120.0) + vec2<f32>(75.0, 120.0);
+let i = floor(x);
+let f = fract(x);
+let n = dot(i, stepv);
+let u = f * f * (vec2<f32>(3.0) - 2.0 * f);
+return mix(mix(nme_cloudRandom(n + dot(stepv, vec2<f32>(0.0, 0.0))), nme_cloudRandom(n + dot(stepv, vec2<f32>(1.0, 0.0))), u.x), mix(nme_cloudRandom(n + dot(stepv, vec2<f32>(0.0, 1.0))), nme_cloudRandom(n + dot(stepv, vec2<f32>(1.0, 1.0))), u.x), u.y);
+}
+fn nme_cloudNoise3(x: vec3<f32>, chaos: vec3<f32>) -> f32 {
+let stepv = chaos * vec3<f32>(60.0, 120.0, 75.0) + vec3<f32>(60.0, 120.0, 75.0);
+let i = floor(x);
+let f = fract(x);
+let n = dot(i, stepv);
+let u = f * f * (vec3<f32>(3.0) - 2.0 * f);
+return mix(mix(mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 0.0, 0.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 0.0, 0.0))), u.x), mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 1.0, 0.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 1.0, 0.0))), u.x), u.y), mix(mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 0.0, 1.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 0.0, 1.0))), u.x), mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 1.0, 1.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 1.0, 1.0))), u.x), u.y), u.z);
+}`
+    );
+    const octaves = Math.max(0, Math.trunc(typeof block.serialized.octaves === "number" ? block.serialized.octaves : 6));
+    const helperKey = `nme_cloudFbm_${octaves}`;
+    state[stage].helpers.set(
+      helperKey,
+      `fn nme_cloudFbm2_${octaves}(st: vec2<f32>, chaos: vec2<f32>) -> f32 {
+var value = 0.0;
+var amplitude = 0.5;
+var tempST = st;
+for (var i = 0; i < ${octaves}; i = i + 1) {
+value += amplitude * nme_cloudNoise2(tempST, chaos);
+tempST *= 2.0;
+amplitude *= 0.5;
+}
+return value;
+}
+fn nme_cloudFbm3_${octaves}(x: vec3<f32>, chaos: vec3<f32>) -> f32 {
+var value = 0.0;
+var amplitude = 0.5;
+var tempX = x;
+for (var i = 0; i < ${octaves}; i = i + 1) {
+value += amplitude * nme_cloudNoise3(tempX, chaos);
+tempX *= 2.0;
+amplitude *= 0.5;
+}
+return value;
+}`
+    );
+    const st = ctx.temp(state, "cloudSeed");
+    state[stage].body.push(`var ${st}: ${seed.type === "vec2f" ? "vec2<f32>" : "vec3<f32>"} = ${seed.expr};`);
+    const offsetX = scalarOffset(block, "offsetX", stage, state, ctx);
+    const offsetY = scalarOffset(block, "offsetY", stage, state, ctx);
+    const offsetZ = scalarOffset(block, "offsetZ", stage, state, ctx);
+    if (offsetX) {
+      state[stage].body.push(`${st}.x += 0.1 * ${offsetX};`);
+    }
+    if (offsetY) {
+      state[stage].body.push(`${st}.y += 0.1 * ${offsetY};`);
+    }
+    if (offsetZ && seed.type === "vec3f") {
+      state[stage].body.push(`${st}.z += 0.1 * ${offsetZ};`);
+    }
+    const chaos = optional(block, "chaos", stage, state, ctx);
+    const chaosExpr = chaos ? ctx.cast(chaos, seed.type).expr : seed.type === "vec2f" ? "vec2<f32>(0.0, 0.0)" : "vec3<f32>(0.0, 0.0, 0.0)";
+    return { expr: seed.type === "vec2f" ? `nme_cloudFbm2_${octaves}(${st}, ${chaosExpr})` : `nme_cloudFbm3_${octaves}(${st}, ${chaosExpr})`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=cloud-block-BeVrangc.js.map