@babylonjs/lite 0.1.1

package/view-direction-CWVucfnT.js

@@ -0,0 +1,12 @@
+const emitter = {
+  className: "ViewDirectionBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const wp = ctx.cast(ctx.resolve(block, "worldPosition", stage, state), "vec3f").expr;
+    const cp = ctx.cast(ctx.resolve(block, "cameraPosition", stage, state), "vec3f").expr;
+    return { expr: `normalize(${cp} - ${wp})`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=view-direction-CWVucfnT.js.map

package/view-direction-CWVucfnT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-direction-CWVucfnT.js","sources":["../src/material/node/blocks/view-direction.ts"],"sourcesContent":["/** ViewDirectionBlock — normalized direction from worldPos to cameraPosition.\n *\n *  Inputs:\n *    - `worldPosition`: vec3/vec4 — we take .xyz if vec4.\n *    - `cameraPosition`: vec3.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ViewDirectionBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const wp = ctx.cast(ctx.resolve(block, \"worldPosition\", stage, state), \"vec3f\").expr;\n        const cp = ctx.cast(ctx.resolve(block, \"cameraPosition\", stage, state), \"vec3f\").expr;\n        return { expr: `normalize(${cp} - ${wp})`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AASO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,iBAAiB,OAAO,KAAK,GAAG,OAAO,EAAE;AAChF,UAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,kBAAkB,OAAO,KAAK,GAAG,OAAO,EAAE;AACjF,WAAO,EAAE,MAAM,aAAa,EAAE,MAAM,EAAE,KAAK,MAAM,QAAA;AAAA,EACrD;AACJ;"}

package/voronoi-noise-block-iNQxa_Ls.js

@@ -0,0 +1,43 @@
+const emitter = {
+  className: "VoronoiNoiseBlock",
+  emit(block, outputName, stage, state, ctx) {
+    const seed = ctx.cast(ctx.resolve(block, "seed", stage, state), "vec2f");
+    const offset = ctx.cast(ctx.resolve(block, "offset", stage, state), "f32");
+    const density = ctx.cast(ctx.resolve(block, "density", stage, state), "f32");
+    state[stage].helpers.set(
+      "nme_voronoi",
+      `fn nme_voronoiRandom(pIn: vec2<f32>) -> vec2<f32> {
+let p = vec2<f32>(dot(pIn, vec2<f32>(127.1, 311.7)), dot(pIn, vec2<f32>(269.5, 183.3)));
+return fract(sin(p) * 18.5453);
+}
+fn nme_voronoi(seed: vec2<f32>, offset: f32, density: f32) -> vec2<f32> {
+let n = floor(seed * density);
+let f = fract(seed * density);
+var outValue = 0.0;
+var cells = 0.0;
+var m = vec3<f32>(8.0);
+for (var j = -1; j <= 1; j = j + 1) {
+for (var i = -1; i <= 1; i = i + 1) {
+let g = vec2<f32>(f32(i), f32(j));
+let o = nme_voronoiRandom(n + g);
+let r = g - f + (vec2<f32>(0.5) + 0.5 * sin(vec2<f32>(offset) + 6.2831 * o));
+let d = dot(r, r);
+if (d < m.x) {
+m = vec3<f32>(d, o);
+outValue = m.x;
+cells = m.y;
+}
+}
+}
+return vec2<f32>(outValue, cells);
+}`
+    );
+    const temp = ctx.temp(state, "voronoi");
+    state[stage].body.push(`let ${temp} = nme_voronoi(${seed.expr}, ${offset.expr}, ${density.expr});`);
+    return { expr: outputName === "cells" ? `${temp}.y` : `${temp}.x`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=voronoi-noise-block-iNQxa_Ls.js.map

package/voronoi-noise-block-iNQxa_Ls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"voronoi-noise-block-iNQxa_Ls.js","sources":["../src/material/node/blocks/voronoi-noise-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"VoronoiNoiseBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        const seed = ctx.cast(ctx.resolve(block, \"seed\", stage, state), \"vec2f\");\n        const offset = ctx.cast(ctx.resolve(block, \"offset\", stage, state), \"f32\");\n        const density = ctx.cast(ctx.resolve(block, \"density\", stage, state), \"f32\");\n        state[stage].helpers.set(\n            \"nme_voronoi\",\n            `fn nme_voronoiRandom(pIn: vec2<f32>) -> vec2<f32> {\nlet p = vec2<f32>(dot(pIn, vec2<f32>(127.1, 311.7)), dot(pIn, vec2<f32>(269.5, 183.3)));\nreturn fract(sin(p) * 18.5453);\n}\nfn nme_voronoi(seed: vec2<f32>, offset: f32, density: f32) -> vec2<f32> {\nlet n = floor(seed * density);\nlet f = fract(seed * density);\nvar outValue = 0.0;\nvar cells = 0.0;\nvar m = vec3<f32>(8.0);\nfor (var j = -1; j <= 1; j = j + 1) {\nfor (var i = -1; i <= 1; i = i + 1) {\nlet g = vec2<f32>(f32(i), f32(j));\nlet o = nme_voronoiRandom(n + g);\nlet r = g - f + (vec2<f32>(0.5) + 0.5 * sin(vec2<f32>(offset) + 6.2831 * o));\nlet d = dot(r, r);\nif (d < m.x) {\nm = vec3<f32>(d, o);\noutValue = m.x;\ncells = m.y;\n}\n}\n}\nreturn vec2<f32>(outValue, cells);\n}`\n        );\n        const temp = ctx.temp(state, \"voronoi\");\n        state[stage].body.push(`let ${temp} = nme_voronoi(${seed.expr}, ${offset.expr}, ${density.expr});`);\n        return { expr: outputName === \"cells\" ? `${temp}.y` : `${temp}.x`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,OAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK,GAAG,OAAO;AACvE,UAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,GAAG,KAAK;AACzE,UAAM,UAAU,IAAI,KAAK,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK,GAAG,KAAK;AAC3E,UAAM,KAAK,EAAE,QAAQ;AAAA,MACjB;AAAA,MACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AA0BJ,UAAM,OAAO,IAAI,KAAK,OAAO,SAAS;AACtC,UAAM,KAAK,EAAE,KAAK,KAAK,OAAO,IAAI,kBAAkB,KAAK,IAAI,KAAK,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI;AAClG,WAAO,EAAE,MAAM,eAAe,UAAU,GAAG,IAAI,OAAO,GAAG,IAAI,MAAM,MAAM,MAAA;AAAA,EAC7E;AACJ;"}

package/wave-block-CY_mk1ec.js

@@ -0,0 +1,41 @@
+function scalar(type, value) {
+  if (type === "f32") {
+    return value;
+  }
+  if (type === "vec2f") {
+    return `vec2<f32>(${value})`;
+  }
+  if (type === "vec3f") {
+    return `vec3<f32>(${value})`;
+  }
+  if (type === "vec4f") {
+    return `vec4<f32>(${value})`;
+  }
+  throw new Error(`NodeMaterial: WaveBlock does not support ${type}`);
+}
+const emitter = {
+  className: "WaveBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = ctx.resolve(block, "input", stage, state);
+    const v = input.expr;
+    const half = scalar(input.type, "0.5");
+    const one = scalar(input.type, "1.0");
+    const two = scalar(input.type, "2.0");
+    const rawKind = block.serialized.kind;
+    const kind = typeof rawKind === "number" ? rawKind : 0;
+    if (kind === 0) {
+      return { expr: `(${v} - floor(${half} + ${v}))`, type: input.type };
+    }
+    if (kind === 1) {
+      return { expr: `(${one} - ${two} * round(fract(${v})))`, type: input.type };
+    }
+    if (kind === 2) {
+      return { expr: `(${two} * abs(${two} * (${v} - floor(${half} + ${v}))) - ${one})`, type: input.type };
+    }
+    throw new Error(`NodeMaterial: unknown WaveBlock kind ${kind}`);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=wave-block-CY_mk1ec.js.map

package/wave-block-CY_mk1ec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-block-CY_mk1ec.js","sources":["../src/material/node/blocks/wave-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeValueType } from \"../node-types.js\";\n\nfunction scalar(type: NodeValueType, value: string): string {\n    if (type === \"f32\") {\n        return value;\n    }\n    if (type === \"vec2f\") {\n        return `vec2<f32>(${value})`;\n    }\n    if (type === \"vec3f\") {\n        return `vec3<f32>(${value})`;\n    }\n    if (type === \"vec4f\") {\n        return `vec4<f32>(${value})`;\n    }\n    throw new Error(`NodeMaterial: WaveBlock does not support ${type}`);\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"WaveBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = ctx.resolve(block, \"input\", stage, state);\n        const v = input.expr;\n        const half = scalar(input.type, \"0.5\");\n        const one = scalar(input.type, \"1.0\");\n        const two = scalar(input.type, \"2.0\");\n        const rawKind = block.serialized.kind;\n        const kind = typeof rawKind === \"number\" ? rawKind : 0;\n        if (kind === 0) {\n            return { expr: `(${v} - floor(${half} + ${v}))`, type: input.type };\n        }\n        if (kind === 1) {\n            return { expr: `(${one} - ${two} * round(fract(${v})))`, type: input.type };\n        }\n        if (kind === 2) {\n            return { expr: `(${two} * abs(${two} * (${v} - floor(${half} + ${v}))) - ${one})`, type: input.type };\n        }\n        throw new Error(`NodeMaterial: unknown WaveBlock kind ${kind}`);\n    },\n};\n"],"names":[],"mappings":"AAEA,SAAS,OAAO,MAAqB,OAAuB;AACxD,MAAI,SAAS,OAAO;AAChB,WAAO;AAAA,EACX;AACA,MAAI,SAAS,SAAS;AAClB,WAAO,aAAa,KAAK;AAAA,EAC7B;AACA,MAAI,SAAS,SAAS;AAClB,WAAO,aAAa,KAAK;AAAA,EAC7B;AACA,MAAI,SAAS,SAAS;AAClB,WAAO,aAAa,KAAK;AAAA,EAC7B;AACA,QAAM,IAAI,MAAM,4CAA4C,IAAI,EAAE;AACtE;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,IAAI,MAAM;AAChB,UAAM,OAAO,OAAO,MAAM,MAAM,KAAK;AACrC,UAAM,MAAM,OAAO,MAAM,MAAM,KAAK;AACpC,UAAM,MAAM,OAAO,MAAM,MAAM,KAAK;AACpC,UAAM,UAAU,MAAM,WAAW;AACjC,UAAM,OAAO,OAAO,YAAY,WAAW,UAAU;AACrD,QAAI,SAAS,GAAG;AACZ,aAAO,EAAE,MAAM,IAAI,CAAC,YAAY,IAAI,MAAM,CAAC,MAAM,MAAM,MAAM,KAAA;AAAA,IACjE;AACA,QAAI,SAAS,GAAG;AACZ,aAAO,EAAE,MAAM,IAAI,GAAG,MAAM,GAAG,kBAAkB,CAAC,OAAO,MAAM,MAAM,KAAA;AAAA,IACzE;AACA,QAAI,SAAS,GAAG;AACZ,aAAO,EAAE,MAAM,IAAI,GAAG,UAAU,GAAG,OAAO,CAAC,YAAY,IAAI,MAAM,CAAC,SAAS,GAAG,KAAK,MAAM,MAAM,KAAA;AAAA,IACnG;AACA,UAAM,IAAI,MAAM,wCAAwC,IAAI,EAAE;AAAA,EAClE;AACJ;"}

package/wgsl-helpers-DyzNzCeE.js

@@ -0,0 +1,48 @@
+const WGSL_PERTURB_NORMAL = `
+fn perturbNormal(vNormalW: vec3<f32>, positionW: vec3<f32>, uv: vec2<f32>, bumpScale: f32) -> vec3<f32> {
+let normalSample = textureSample(bT, bS, uv).rgb * 2.0 - 1.0;
+let N = normalize(vNormalW) * bumpScale;
+let dp1 = dpdx(positionW);
+let dp2 = -dpdy(positionW);
+let duv1 = dpdx(uv);
+let duv2 = -dpdy(uv);
+let dp2perp = cross(dp2, N);
+let dp1perp = cross(N, dp1);
+var tangent = dp2perp * duv1.x + dp1perp * duv2.x;
+var bitangent = dp2perp * duv1.y + dp1perp * duv2.y;
+let det = max(dot(tangent, tangent), dot(bitangent, bitangent));
+let invmax = select(inverseSqrt(det), 0.0, det == 0.0);
+let cotangentFrame = mat3x3<f32>(tangent * invmax, bitangent * invmax, N);
+return normalize(cotangentFrame * normalSample);
+}
+`;
+const WGSL_FOG = `
+const E_FOG: f32 = 2.71828;
+fn calcFogFactor(fogDistance: vec3<f32>) -> f32 {
+var fogCoeff: f32 = 1.0;
+let fogMode = scene.vFogInfos.x;
+let fogStart = scene.vFogInfos.y;
+let fogEnd = scene.vFogInfos.z;
+let fogDensity = scene.vFogInfos.w;
+let dist = length(fogDistance);
+if (fogMode == 3.0) { fogCoeff = (fogEnd - dist) / (fogEnd - fogStart); }
+else if (fogMode == 1.0) { fogCoeff = 1.0 / pow(E_FOG, dist * fogDensity); }
+else if (fogMode == 2.0) { fogCoeff = 1.0 / pow(E_FOG, dist * dist * fogDensity * fogDensity); }
+return clamp(fogCoeff, 0.0, 1.0);
+}
+`;
+const WGSL_DITHER = `
+fn dither(seed: vec2<f32>, varianceAmount: f32) -> f32 {
+let rand = fract(sin(dot(seed, vec2<f32>(12.9898, 78.233))) * 43758.5453);
+let normVariance = varianceAmount / 255.0;
+return mix(-normVariance, normVariance, rand);
+}
+`;
+const WGSL_NO_DITHER = "fn dither(a:vec2<f32>,b:f32)->f32{return 0.0;}";
+export {
+  WGSL_PERTURB_NORMAL as W,
+  WGSL_DITHER as a,
+  WGSL_NO_DITHER as b,
+  WGSL_FOG as c
+};
+//# sourceMappingURL=wgsl-helpers-DyzNzCeE.js.map

package/wgsl-helpers-DyzNzCeE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgsl-helpers-DyzNzCeE.js","sources":["../src/shader/wgsl-helpers.ts"],"sourcesContent":["/** Shared WGSL helper snippets used by both PBR and Standard material systems.\n *\n *  These are pure WGSL function strings — no bindings, no UBO declarations.\n *  Each material system wraps them with its own binding declarations. */\n\n/** Cotangent-frame bump mapping.\n *  Requires: `bT` (texture_2d) and `bS` (sampler) in scope. */\nexport const WGSL_PERTURB_NORMAL = `\nfn perturbNormal(vNormalW: vec3<f32>, positionW: vec3<f32>, uv: vec2<f32>, bumpScale: f32) -> vec3<f32> {\nlet normalSample = textureSample(bT, bS, uv).rgb * 2.0 - 1.0;\nlet N = normalize(vNormalW) * bumpScale;\nlet dp1 = dpdx(positionW);\nlet dp2 = -dpdy(positionW);\nlet duv1 = dpdx(uv);\nlet duv2 = -dpdy(uv);\nlet dp2perp = cross(dp2, N);\nlet dp1perp = cross(N, dp1);\nvar tangent = dp2perp * duv1.x + dp1perp * duv2.x;\nvar bitangent = dp2perp * duv1.y + dp1perp * duv2.y;\nlet det = max(dot(tangent, tangent), dot(bitangent, bitangent));\nlet invmax = select(inverseSqrt(det), 0.0, det == 0.0);\nlet cotangentFrame = mat3x3<f32>(tangent * invmax, bitangent * invmax, N);\nreturn normalize(cotangentFrame * normalSample);\n}\n`;\n\n/** ESM shadow helper functions.\n *  Requires: `shadowTex` (texture_2d), `shadowSampler` (sampler) in scope. */\nexport const WGSL_SHADOW_ESM = `\nfn computeFallOff(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {\nlet mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));\nreturn mix(value, 1.0, mask);\n}\nfn computeShadowWithESM(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, depthScale: f32, frustumEdgeFalloff: f32) -> f32 {\nlet clipSpace = posFromLight.xyz / posFromLight.w;\nlet uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\nif (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\nlet shadowPixelDepth = clamp(depthMetric, 0.0, 1.0);\nlet shadowMapSample = textureSampleLevel(shadowTex, shadowSampler, uv, 0.0).x;\nlet esm = 1.0 - clamp(exp(min(87.0, depthScale * shadowPixelDepth)) * shadowMapSample, 0.0, 1.0 - darkness);\nreturn computeFallOff(esm, clipSpace.xy, frustumEdgeFalloff);\n}\n`;\n\n/** Fog calculation helper.\n *  Requires: `scene.vFogInfos` (vec4) in scope. */\nexport const WGSL_FOG = `\nconst E_FOG: f32 = 2.71828;\nfn calcFogFactor(fogDistance: vec3<f32>) -> f32 {\nvar fogCoeff: f32 = 1.0;\nlet fogMode = scene.vFogInfos.x;\nlet fogStart = scene.vFogInfos.y;\nlet fogEnd = scene.vFogInfos.z;\nlet fogDensity = scene.vFogInfos.w;\nlet dist = length(fogDistance);\nif (fogMode == 3.0) { fogCoeff = (fogEnd - dist) / (fogEnd - fogStart); }\nelse if (fogMode == 1.0) { fogCoeff = 1.0 / pow(E_FOG, dist * fogDensity); }\nelse if (fogMode == 2.0) { fogCoeff = 1.0 / pow(E_FOG, dist * dist * fogDensity * fogDensity); }\nreturn clamp(fogCoeff, 0.0, 1.0);\n}\n`;\n\n/** Dither noise function.\n *  Pure math — no UBO dependency. */\nexport const WGSL_DITHER = `\nfn dither(seed: vec2<f32>, varianceAmount: f32) -> f32 {\nlet rand = fract(sin(dot(seed, vec2<f32>(12.9898, 78.233))) * 43758.5453);\nlet normVariance = varianceAmount / 255.0;\nreturn mix(-normVariance, normVariance, rand);\n}\n`;\n\n/** Noise-disabled replacement for shaders that still call dither(). */\nexport const WGSL_NO_DITHER = \"fn dither(a:vec2<f32>,b:f32)->f32{return 0.0;}\";\n"],"names":[],"mappings":"AAOO,MAAM,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuC5B,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBjB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASpB,MAAM,iBAAiB;"}

package/worley-noise-3d-block-CyR2-k4s.js

@@ -0,0 +1,58 @@
+const emitter = {
+  className: "WorleyNoise3DBlock",
+  emit(block, outputName, stage, state, ctx) {
+    const seed = ctx.cast(ctx.resolve(block, "seed", stage, state), "vec3f");
+    const jitter = ctx.cast(ctx.resolve(block, "jitter", stage, state), "f32");
+    const manhattan = block.serialized.manhattanDistance === true ? "true" : "false";
+    state[stage].helpers.set(
+      "nme_worley3D",
+      `fn nme_worleyPermuteScalar(x: f32) -> f32 {
+return ((34.0 * x + 1.0) * x) - floor(((34.0 * x + 1.0) * x) / 289.0) * 289.0;
+}
+fn nme_worleyDistance(x: f32, y: f32, z: f32, manhattanDistance: bool) -> f32 {
+return select(x * x + y * y + z * z, abs(x) + abs(y) + abs(z), manhattanDistance);
+}
+fn nme_worley(P: vec3<f32>, jitter: f32, manhattanDistance: bool) -> vec2<f32> {
+let K = 0.142857142857;
+let Ko = 0.428571428571;
+let K2 = 0.020408163265306;
+let Kz = 0.166666666667;
+let Kzo = 0.416666666667;
+let Pi = floor(P) - floor(floor(P) / 289.0) * 289.0;
+let Pf = fract(P) - vec3<f32>(0.5);
+var d1 = 100000.0;
+var d2 = 100000.0;
+for (var zi = -1; zi <= 1; zi = zi + 1) {
+for (var yi = -1; yi <= 1; yi = yi + 1) {
+for (var xi = -1; xi <= 1; xi = xi + 1) {
+let p0 = nme_worleyPermuteScalar(Pi.x + f32(xi));
+let p1 = nme_worleyPermuteScalar(p0 + Pi.y + f32(yi));
+let p2 = nme_worleyPermuteScalar(p1 + Pi.z + f32(zi));
+let ox = fract(p2 * K) - Ko;
+let oy = (floor(p2 * K) - floor(floor(p2 * K) / 7.0) * 7.0) * K - Ko;
+let oz = floor(p2 * K2) * Kz - Kzo;
+let dx = Pf.x - f32(xi) + jitter * ox;
+let dy = Pf.y - f32(yi) + jitter * oy;
+let dz = Pf.z - f32(zi) + jitter * oz;
+let d = nme_worleyDistance(dx, dy, dz, manhattanDistance);
+if (d < d1) {
+d2 = d1;
+d1 = d;
+} else if (d < d2) {
+d2 = d;
+}
+}
+}
+}
+return sqrt(vec2<f32>(d1, d2));
+}`
+    );
+    const temp = ctx.temp(state, "worley");
+    state[stage].body.push(`let ${temp} = nme_worley(${seed.expr}, ${jitter.expr}, ${manhattan});`);
+    return { expr: outputName === "y" ? `${temp}.y` : outputName === "output" ? temp : `${temp}.x`, type: outputName === "output" ? "vec2f" : "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=worley-noise-3d-block-CyR2-k4s.js.map

package/worley-noise-3d-block-CyR2-k4s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worley-noise-3d-block-CyR2-k4s.js","sources":["../src/material/node/blocks/worley-noise-3d-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"WorleyNoise3DBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        const seed = ctx.cast(ctx.resolve(block, \"seed\", stage, state), \"vec3f\");\n        const jitter = ctx.cast(ctx.resolve(block, \"jitter\", stage, state), \"f32\");\n        const manhattan = block.serialized.manhattanDistance === true ? \"true\" : \"false\";\n        state[stage].helpers.set(\n            \"nme_worley3D\",\n            `fn nme_worleyPermuteScalar(x: f32) -> f32 {\nreturn ((34.0 * x + 1.0) * x) - floor(((34.0 * x + 1.0) * x) / 289.0) * 289.0;\n}\nfn nme_worleyDistance(x: f32, y: f32, z: f32, manhattanDistance: bool) -> f32 {\nreturn select(x * x + y * y + z * z, abs(x) + abs(y) + abs(z), manhattanDistance);\n}\nfn nme_worley(P: vec3<f32>, jitter: f32, manhattanDistance: bool) -> vec2<f32> {\nlet K = 0.142857142857;\nlet Ko = 0.428571428571;\nlet K2 = 0.020408163265306;\nlet Kz = 0.166666666667;\nlet Kzo = 0.416666666667;\nlet Pi = floor(P) - floor(floor(P) / 289.0) * 289.0;\nlet Pf = fract(P) - vec3<f32>(0.5);\nvar d1 = 100000.0;\nvar d2 = 100000.0;\nfor (var zi = -1; zi <= 1; zi = zi + 1) {\nfor (var yi = -1; yi <= 1; yi = yi + 1) {\nfor (var xi = -1; xi <= 1; xi = xi + 1) {\nlet p0 = nme_worleyPermuteScalar(Pi.x + f32(xi));\nlet p1 = nme_worleyPermuteScalar(p0 + Pi.y + f32(yi));\nlet p2 = nme_worleyPermuteScalar(p1 + Pi.z + f32(zi));\nlet ox = fract(p2 * K) - Ko;\nlet oy = (floor(p2 * K) - floor(floor(p2 * K) / 7.0) * 7.0) * K - Ko;\nlet oz = floor(p2 * K2) * Kz - Kzo;\nlet dx = Pf.x - f32(xi) + jitter * ox;\nlet dy = Pf.y - f32(yi) + jitter * oy;\nlet dz = Pf.z - f32(zi) + jitter * oz;\nlet d = nme_worleyDistance(dx, dy, dz, manhattanDistance);\nif (d < d1) {\nd2 = d1;\nd1 = d;\n} else if (d < d2) {\nd2 = d;\n}\n}\n}\n}\nreturn sqrt(vec2<f32>(d1, d2));\n}`\n        );\n        const temp = ctx.temp(state, \"worley\");\n        state[stage].body.push(`let ${temp} = nme_worley(${seed.expr}, ${jitter.expr}, ${manhattan});`);\n        return { expr: outputName === \"y\" ? `${temp}.y` : outputName === \"output\" ? temp : `${temp}.x`, type: outputName === \"output\" ? \"vec2f\" : \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,OAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK,GAAG,OAAO;AACvE,UAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,GAAG,KAAK;AACzE,UAAM,YAAY,MAAM,WAAW,sBAAsB,OAAO,SAAS;AACzE,UAAM,KAAK,EAAE,QAAQ;AAAA,MACjB;AAAA,MACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AAyCJ,UAAM,OAAO,IAAI,KAAK,OAAO,QAAQ;AACrC,UAAM,KAAK,EAAE,KAAK,KAAK,OAAO,IAAI,iBAAiB,KAAK,IAAI,KAAK,OAAO,IAAI,KAAK,SAAS,IAAI;AAC9F,WAAO,EAAE,MAAM,eAAe,MAAM,GAAG,IAAI,OAAO,eAAe,WAAW,OAAO,GAAG,IAAI,MAAM,MAAM,eAAe,WAAW,UAAU,MAAA;AAAA,EAC9I;AACJ;"}