@babylonjs/lite 0.1.1

package/_math-factory-C-QqW-Wi.js

@@ -0,0 +1,55 @@
+const RANK = {
+  f32: 1,
+  vec2f: 2,
+  vec3f: 3,
+  vec4f: 4,
+  mat4f: 0,
+  texture2d: 0,
+  textureCube: 0
+};
+const RANK_TYPE = { 1: "f32", 2: "vec2f", 3: "vec3f", 4: "vec4f" };
+function widerType(a, b) {
+  const ra = RANK[a] || 0;
+  const rb = RANK[b] || 0;
+  const r = Math.max(ra, rb);
+  if (!r) {
+    throw new Error(`NodeMaterial: cannot pick common numeric type from ${a} and ${b}`);
+  }
+  return RANK_TYPE[r];
+}
+function binaryEmitter(className, op, leftName = "left", rightName = "right") {
+  return {
+    className,
+    emit(block, _outputName, stage, state, ctx) {
+      const l = ctx.resolve(block, leftName, stage, state);
+      const r = ctx.resolve(block, rightName, stage, state);
+      const t = widerType(l.type, r.type);
+      const lc = ctx.cast(l, t).expr;
+      const rc = ctx.cast(r, t).expr;
+      return { expr: `(${op(lc, rc)})`, type: t };
+    }
+  };
+}
+function unaryEmitter(className, op, returnType, inputName = "input") {
+  return {
+    className,
+    emit(block, _outputName, stage, state, ctx) {
+      const v = ctx.resolve(block, inputName, stage, state);
+      return { expr: `(${op(v.expr)})`, type: v.type };
+    }
+  };
+}
+function formatFloat(n) {
+  if (!Number.isFinite(n)) {
+    return "0.0";
+  }
+  const s = n.toString();
+  return s.includes(".") || s.includes("e") ? s : `${s}.0`;
+}
+export {
+  binaryEmitter as b,
+  formatFloat as f,
+  unaryEmitter as u,
+  widerType as w
+};
+//# sourceMappingURL=_math-factory-C-QqW-Wi.js.map

package/_math-factory-C-QqW-Wi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_math-factory-C-QqW-Wi.js","sources":["../src/material/node/blocks/_math-factory.ts"],"sourcesContent":["/** Shared factories for NME math blocks.\n *\n *  Every block module uses these helpers to stay small — the registry still\n *  maps each BJS class name to its own dynamic import, so Rollup can emit one\n *  chunk per block. The factory code itself lands in a shared vendor chunk\n *  that is only pulled when at least one math block is used.\n */\n\nimport type { BlockEmitter, NodeBlock, NodeBuildState, NodeEmitContext, NodeValueType } from \"../node-types.js\";\n\ntype Rank = 1 | 2 | 3 | 4;\nconst RANK: Record<NodeValueType, Rank | 0> = {\n    f32: 1,\n    vec2f: 2,\n    vec3f: 3,\n    vec4f: 4,\n    mat4f: 0,\n    texture2d: 0,\n    textureCube: 0,\n};\nconst RANK_TYPE: Record<Rank, NodeValueType> = { 1: \"f32\", 2: \"vec2f\", 3: \"vec3f\", 4: \"vec4f\" };\n\n/** Pick the wider of two numeric NME types (`f32 < vec2 < vec3 < vec4`). */\nexport function widerType(a: NodeValueType, b: NodeValueType): NodeValueType {\n    const ra = RANK[a] || 0;\n    const rb = RANK[b] || 0;\n    const r = Math.max(ra, rb) as Rank;\n    if (!r) {\n        throw new Error(`NodeMaterial: cannot pick common numeric type from ${a} and ${b}`);\n    }\n    return RANK_TYPE[r];\n}\n\n/** Binary op whose output type = widerType(left, right). */\nexport function binaryEmitter(className: string, op: (l: string, r: string) => string, leftName = \"left\", rightName = \"right\"): BlockEmitter {\n    return {\n        className,\n        emit(block, _outputName, stage, state, ctx) {\n            const l = ctx.resolve(block, leftName, stage, state);\n            const r = ctx.resolve(block, rightName, stage, state);\n            const t = widerType(l.type, r.type);\n            const lc = ctx.cast(l, t).expr;\n            const rc = ctx.cast(r, t).expr;\n            return { expr: `(${op(lc, rc)})`, type: t };\n        },\n    };\n}\n\n/** Unary op — output type matches input. Optional `returnType` override. */\nexport function unaryEmitter(className: string, op: (v: string) => string, returnType?: NodeValueType, inputName = \"input\"): BlockEmitter {\n    return {\n        className,\n        emit(block, _outputName, stage, state, ctx) {\n            const v = ctx.resolve(block, inputName, stage, state);\n            return { expr: `(${op(v.expr)})`, type: returnType ?? v.type };\n        },\n    };\n}\n\n/** Resolve an input, or fall back to a serialized scalar literal on the block. */\nexport function resolveOrScalar(block: NodeBlock, inputName: string, fallbackKey: string, stage: Parameters<BlockEmitter[\"emit\"]>[2], state: NodeBuildState, ctx: NodeEmitContext) {\n    const input = block.inputs.get(inputName);\n    if (input?.source) {\n        return ctx.resolve(block, inputName, stage, state);\n    }\n    const raw = block.serialized[fallbackKey];\n    const n = typeof raw === \"number\" ? raw : 0;\n    return { expr: `${formatFloat(n)}`, type: \"f32\" as NodeValueType };\n}\n\nexport function formatFloat(n: number): string {\n    if (!Number.isFinite(n)) {\n        return \"0.0\";\n    }\n    const s = n.toString();\n    return s.includes(\".\") || s.includes(\"e\") ? s : `${s}.0`;\n}\n"],"names":[],"mappings":"AAWA,MAAM,OAAwC;AAAA,EAC1C,KAAK;AAAA,EACL,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP,WAAW;AAAA,EACX,aAAa;AACjB;AACA,MAAM,YAAyC,EAAE,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,QAAA;AAG/E,SAAS,UAAU,GAAkB,GAAiC;AACzE,QAAM,KAAK,KAAK,CAAC,KAAK;AACtB,QAAM,KAAK,KAAK,CAAC,KAAK;AACtB,QAAM,IAAI,KAAK,IAAI,IAAI,EAAE;AACzB,MAAI,CAAC,GAAG;AACJ,UAAM,IAAI,MAAM,sDAAsD,CAAC,QAAQ,CAAC,EAAE;AAAA,EACtF;AACA,SAAO,UAAU,CAAC;AACtB;AAGO,SAAS,cAAc,WAAmB,IAAsC,WAAW,QAAQ,YAAY,SAAuB;AACzI,SAAO;AAAA,IACH;AAAA,IACA,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,YAAM,IAAI,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK;AACnD,YAAM,IAAI,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK;AACpD,YAAM,IAAI,UAAU,EAAE,MAAM,EAAE,IAAI;AAClC,YAAM,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE;AAC1B,YAAM,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE;AAC1B,aAAO,EAAE,MAAM,IAAI,GAAG,IAAI,EAAE,CAAC,KAAK,MAAM,EAAA;AAAA,IAC5C;AAAA,EAAA;AAER;AAGO,SAAS,aAAa,WAAmB,IAA2B,YAA4B,YAAY,SAAuB;AACtI,SAAO;AAAA,IACH;AAAA,IACA,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,YAAM,IAAI,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK;AACpD,aAAO,EAAE,MAAM,IAAI,GAAG,EAAE,IAAI,CAAC,KAAK,MAAoB,EAAE,KAAA;AAAA,IAC5D;AAAA,EAAA;AAER;AAaO,SAAS,YAAY,GAAmB;AAC3C,MAAI,CAAC,OAAO,SAAS,CAAC,GAAG;AACrB,WAAO;AAAA,EACX;AACA,QAAM,IAAI,EAAE,SAAA;AACZ,SAAO,EAAE,SAAS,GAAG,KAAK,EAAE,SAAS,GAAG,IAAI,IAAI,GAAG,CAAC;AACxD;"}

package/add-block-CikX5gWy.js

@@ -0,0 +1,6 @@
+import { b as binaryEmitter } from "./_math-factory-C-QqW-Wi.js";
+const emitter = binaryEmitter("AddBlock", (l, r) => `${l} + ${r}`);
+export {
+  emitter
+};
+//# sourceMappingURL=add-block-CikX5gWy.js.map

package/add-block-CikX5gWy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-block-CikX5gWy.js","sources":["../src/material/node/blocks/add-block.ts"],"sourcesContent":["import { binaryEmitter } from \"./_math-factory.js\";\nexport const emitter = binaryEmitter(\"AddBlock\", (l, r) => `${l} + ${r}`);\n"],"names":[],"mappings":";AACO,MAAM,UAAU,cAAc,YAAY,CAAC,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC,EAAE;"}

package/alpha-test-fragment-CUiHCw7W.js

@@ -0,0 +1,22 @@
+import { ap as PBR_HAS_ALPHA_TEST } from "./index-C8HOR2sB.js";
+const pbrExt = {
+  id: "alpha-test",
+  phase: "fragment",
+  frag(ctx) {
+    return ctx._features & PBR_HAS_ALPHA_TEST ? {
+      _id: "alpha-test",
+      _uboFields: [{ _name: "alphaCutOff", _type: "f32" }],
+      _fragmentSlots: { AT: `if(alpha*material.materialAlpha<material.alphaCutOff){discard;}` }
+    } : null;
+  },
+  writeUbo(data, mat, offsets) {
+    const off = offsets.get("alphaCutOff");
+    if (off !== void 0) {
+      data[off / 4] = mat.alphaCutOff ?? 0;
+    }
+  }
+};
+export {
+  pbrExt
+};
+//# sourceMappingURL=alpha-test-fragment-CUiHCw7W.js.map

package/alpha-test-fragment-CUiHCw7W.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alpha-test-fragment-CUiHCw7W.js","sources":["../src/material/pbr/fragments/alpha-test-fragment.ts"],"sourcesContent":["import type { PbrMaterialProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR_HAS_ALPHA_TEST } from \"../pbr-flag-bits.js\";\n\nexport const pbrExt: PbrExt = {\n    id: \"alpha-test\",\n    phase: \"fragment\",\n    frag(ctx) {\n        return ctx._features & PBR_HAS_ALPHA_TEST\n            ? {\n                  _id: \"alpha-test\",\n                  _uboFields: [{ _name: \"alphaCutOff\", _type: \"f32\" }],\n                  _fragmentSlots: { AT: `if(alpha*material.materialAlpha<material.alphaCutOff){discard;}` },\n              }\n            : null;\n    },\n    writeUbo(data, mat, offsets) {\n        const off = offsets.get(\"alphaCutOff\");\n        if (off !== undefined) {\n            data[off / 4] = (mat as PbrMaterialProps).alphaCutOff ?? 0;\n        }\n    },\n};\n"],"names":[],"mappings":";AAIO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,KAAK,KAAK;AACN,WAAO,IAAI,YAAY,qBACjB;AAAA,MACI,KAAK;AAAA,MACL,YAAY,CAAC,EAAE,OAAO,eAAe,OAAO,OAAO;AAAA,MACnD,gBAAgB,EAAE,IAAI,kEAAA;AAAA,IAAkE,IAE5F;AAAA,EACV;AAAA,EACA,SAAS,MAAM,KAAK,SAAS;AACzB,UAAM,MAAM,QAAQ,IAAI,aAAa;AACrC,QAAI,QAAQ,QAAW;AACnB,WAAK,MAAM,CAAC,IAAK,IAAyB,eAAe;AAAA,IAC7D;AAAA,EACJ;AACJ;"}

package/ambient-occlusion-block-DForhWL3.js

@@ -0,0 +1,77 @@
+const HELPER_KEY = "nme_ambientOcclusion";
+const HELPER_WGSL = `
+fn nme_aoNormalFromDepth(depthTex: texture_2d<f32>, depthSamp: sampler, depth: f32, coords: vec2<f32>, radius: f32) -> vec3<f32> {
+    let offset1 = vec2<f32>(0.0, radius);
+    let offset2 = vec2<f32>(radius, 0.0);
+    let depth1 = textureSampleLevel(depthTex, depthSamp, coords + offset1, 0.0).r;
+    let depth2 = textureSampleLevel(depthTex, depthSamp, coords + offset2, 0.0).r;
+    let p1 = vec3<f32>(offset1, depth1 - depth);
+    let p2 = vec3<f32>(offset2, depth2 - depth);
+    var normal = cross(p1, p2);
+    normal.z = -normal.z;
+    return normalize(normal);
+}
+
+fn nme_aoRandom(uv: vec2<f32>) -> vec3<f32> {
+    let x = fract(sin(dot(uv, vec2<f32>(12.9898, 78.233))) * 43758.5453);
+    let y = fract(sin(dot(uv, vec2<f32>(39.3468, 11.135))) * 24634.6345);
+    let z = fract(sin(dot(uv, vec2<f32>(73.156, 52.235))) * 12414.2347);
+    return normalize(vec3<f32>(x, y, z));
+}
+
+fn nme_computeAo(depthTex: texture_2d<f32>, depthSamp: sampler, fragCoord: vec4<f32>, screenSize: vec2<f32>, radius: f32, area: f32, fallOff: f32) -> f32 {
+    let uv = fragCoord.xy / screenSize;
+    let random = nme_aoRandom(uv * 4.0);
+    let depth = textureSampleLevel(depthTex, depthSamp, uv, 0.0).r;
+    let position = vec3<f32>(uv, depth);
+    let normal = nme_aoNormalFromDepth(depthTex, depthSamp, depth, uv, radius);
+    let radiusDepth = radius / depth;
+    let sampleSphere = array<vec3<f32>, 16>(
+        vec3<f32>(0.5381, 0.1856, -0.4319), vec3<f32>(0.1379, 0.2486, 0.4430), vec3<f32>(0.3371, 0.5679, -0.0057), vec3<f32>(-0.6999, -0.0451, -0.0019),
+        vec3<f32>(0.0689, -0.1598, -0.8547), vec3<f32>(0.0560, 0.0069, -0.1843), vec3<f32>(-0.0146, 0.1402, 0.0762), vec3<f32>(0.0100, -0.1924, -0.0344),
+        vec3<f32>(-0.3577, -0.5301, -0.4358), vec3<f32>(-0.3169, 0.1063, 0.0158), vec3<f32>(0.0103, -0.5869, 0.0046), vec3<f32>(-0.0897, -0.4940, 0.3287),
+        vec3<f32>(0.7119, -0.0154, -0.0918), vec3<f32>(-0.0533, 0.0596, -0.5411), vec3<f32>(0.0352, -0.0631, 0.5460), vec3<f32>(-0.4776, 0.2847, -0.0271)
+    );
+    var occlusion = 0.0;
+    for (var i = 0; i < 16; i = i + 1) {
+        let ray = radiusDepth * reflect(sampleSphere[i], random);
+        let hemiRay = position + sign(dot(ray, normal)) * ray;
+        let occlusionDepth = textureSample(depthTex, depthSamp, clamp(hemiRay.xy, vec2<f32>(0.001), vec2<f32>(0.999))).r;
+        let difference = depth - occlusionDepth;
+        occlusion += step(fallOff, difference) * (1.0 - smoothstep(fallOff, area, difference));
+    }
+    return clamp(1.0 - occlusion / 16.0, 0.0, 1.0);
+}
+`;
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+function num(value, fallback) {
+  return typeof value === "number" ? `${value}` : `${fallback}`;
+}
+const emitter = {
+  className: "AmbientOcclusionBlock",
+  stage: "fragment",
+  emit(block, _outputName, stage, state, ctx) {
+    var _a;
+    const source = (_a = block.inputs.get("source")) == null ? void 0 : _a.source;
+    if (!source) {
+      throw new Error(`NodeMaterial: AmbientOcclusionBlock "${block.name}" requires an ImageSourceBlock source`);
+    }
+    const producer = ctx.graph.blocks.get(source.blockId);
+    const bindingName = sanitize((producer == null ? void 0 : producer.name) || `ao${block.id}`);
+    if (!state.textures.find((t) => t.name === bindingName)) {
+      state.textures.push({ name: bindingName, kind: "texture2d", texture: null });
+    }
+    state.fragment.helpers.set(HELPER_KEY, HELPER_WGSL);
+    const screenSize = ctx.cast(ctx.resolve(block, "screenSize", stage, state), "vec2f").expr;
+    return {
+      expr: `nme_computeAo(nodeTex_${bindingName}, nodeSamp_${bindingName}, _NME_FRAG_COORD_, ${screenSize}, ${num(block.serialized.radius, 1e-4)}, ${num(block.serialized.area, 75e-4)}, ${num(block.serialized.fallOff, 1e-6)})`,
+      type: "f32"
+    };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=ambient-occlusion-block-DForhWL3.js.map

package/ambient-occlusion-block-DForhWL3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-occlusion-block-DForhWL3.js","sources":["../src/material/node/blocks/ambient-occlusion-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nconst HELPER_KEY = \"nme_ambientOcclusion\";\nconst HELPER_WGSL = `\nfn nme_aoNormalFromDepth(depthTex: texture_2d<f32>, depthSamp: sampler, depth: f32, coords: vec2<f32>, radius: f32) -> vec3<f32> {\n    let offset1 = vec2<f32>(0.0, radius);\n    let offset2 = vec2<f32>(radius, 0.0);\n    let depth1 = textureSampleLevel(depthTex, depthSamp, coords + offset1, 0.0).r;\n    let depth2 = textureSampleLevel(depthTex, depthSamp, coords + offset2, 0.0).r;\n    let p1 = vec3<f32>(offset1, depth1 - depth);\n    let p2 = vec3<f32>(offset2, depth2 - depth);\n    var normal = cross(p1, p2);\n    normal.z = -normal.z;\n    return normalize(normal);\n}\n\nfn nme_aoRandom(uv: vec2<f32>) -> vec3<f32> {\n    let x = fract(sin(dot(uv, vec2<f32>(12.9898, 78.233))) * 43758.5453);\n    let y = fract(sin(dot(uv, vec2<f32>(39.3468, 11.135))) * 24634.6345);\n    let z = fract(sin(dot(uv, vec2<f32>(73.156, 52.235))) * 12414.2347);\n    return normalize(vec3<f32>(x, y, z));\n}\n\nfn nme_computeAo(depthTex: texture_2d<f32>, depthSamp: sampler, fragCoord: vec4<f32>, screenSize: vec2<f32>, radius: f32, area: f32, fallOff: f32) -> f32 {\n    let uv = fragCoord.xy / screenSize;\n    let random = nme_aoRandom(uv * 4.0);\n    let depth = textureSampleLevel(depthTex, depthSamp, uv, 0.0).r;\n    let position = vec3<f32>(uv, depth);\n    let normal = nme_aoNormalFromDepth(depthTex, depthSamp, depth, uv, radius);\n    let radiusDepth = radius / depth;\n    let sampleSphere = array<vec3<f32>, 16>(\n        vec3<f32>(0.5381, 0.1856, -0.4319), vec3<f32>(0.1379, 0.2486, 0.4430), vec3<f32>(0.3371, 0.5679, -0.0057), vec3<f32>(-0.6999, -0.0451, -0.0019),\n        vec3<f32>(0.0689, -0.1598, -0.8547), vec3<f32>(0.0560, 0.0069, -0.1843), vec3<f32>(-0.0146, 0.1402, 0.0762), vec3<f32>(0.0100, -0.1924, -0.0344),\n        vec3<f32>(-0.3577, -0.5301, -0.4358), vec3<f32>(-0.3169, 0.1063, 0.0158), vec3<f32>(0.0103, -0.5869, 0.0046), vec3<f32>(-0.0897, -0.4940, 0.3287),\n        vec3<f32>(0.7119, -0.0154, -0.0918), vec3<f32>(-0.0533, 0.0596, -0.5411), vec3<f32>(0.0352, -0.0631, 0.5460), vec3<f32>(-0.4776, 0.2847, -0.0271)\n    );\n    var occlusion = 0.0;\n    for (var i = 0; i < 16; i = i + 1) {\n        let ray = radiusDepth * reflect(sampleSphere[i], random);\n        let hemiRay = position + sign(dot(ray, normal)) * ray;\n        let occlusionDepth = textureSample(depthTex, depthSamp, clamp(hemiRay.xy, vec2<f32>(0.001), vec2<f32>(0.999))).r;\n        let difference = depth - occlusionDepth;\n        occlusion += step(fallOff, difference) * (1.0 - smoothstep(fallOff, area, difference));\n    }\n    return clamp(1.0 - occlusion / 16.0, 0.0, 1.0);\n}\n`;\n\nfunction sanitize(name: string): string {\n    return name.replace(/[^A-Za-z0-9_]/g, \"_\");\n}\n\nfunction num(value: unknown, fallback: number): string {\n    return typeof value === \"number\" ? `${value}` : `${fallback}`;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"AmbientOcclusionBlock\",\n    stage: \"fragment\",\n    emit(block, _outputName, stage, state, ctx): NodeExpr {\n        const source = block.inputs.get(\"source\")?.source;\n        if (!source) {\n            throw new Error(`NodeMaterial: AmbientOcclusionBlock \"${block.name}\" requires an ImageSourceBlock source`);\n        }\n        const producer = ctx.graph.blocks.get(source.blockId);\n        const bindingName = sanitize(producer?.name || `ao${block.id}`);\n        if (!state.textures.find((t) => t.name === bindingName)) {\n            state.textures.push({ name: bindingName, kind: \"texture2d\", texture: null });\n        }\n        state.fragment.helpers.set(HELPER_KEY, HELPER_WGSL);\n        const screenSize = ctx.cast(ctx.resolve(block, \"screenSize\", stage, state), \"vec2f\").expr;\n        return {\n            expr: `nme_computeAo(nodeTex_${bindingName}, nodeSamp_${bindingName}, _NME_FRAG_COORD_, ${screenSize}, ${num(block.serialized.radius, 0.0001)}, ${num(block.serialized.area, 0.0075)}, ${num(block.serialized.fallOff, 0.000001)})`,\n            type: \"f32\",\n        };\n    },\n};\n"],"names":[],"mappings":"AAEA,MAAM,aAAa;AACnB,MAAM,cAAc;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;AA6CpB,SAAS,SAAS,MAAsB;AACpC,SAAO,KAAK,QAAQ,kBAAkB,GAAG;AAC7C;AAEA,SAAS,IAAI,OAAgB,UAA0B;AACnD,SAAO,OAAO,UAAU,WAAW,GAAG,KAAK,KAAK,GAAG,QAAQ;AAC/D;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,OAAO,OAAO,KAAe;AAzD1D;AA0DQ,UAAM,UAAS,WAAM,OAAO,IAAI,QAAQ,MAAzB,mBAA4B;AAC3C,QAAI,CAAC,QAAQ;AACT,YAAM,IAAI,MAAM,wCAAwC,MAAM,IAAI,uCAAuC;AAAA,IAC7G;AACA,UAAM,WAAW,IAAI,MAAM,OAAO,IAAI,OAAO,OAAO;AACpD,UAAM,cAAc,UAAS,qCAAU,SAAQ,KAAK,MAAM,EAAE,EAAE;AAC9D,QAAI,CAAC,MAAM,SAAS,KAAK,CAAC,MAAM,EAAE,SAAS,WAAW,GAAG;AACrD,YAAM,SAAS,KAAK,EAAE,MAAM,aAAa,MAAM,aAAa,SAAS,MAAM;AAAA,IAC/E;AACA,UAAM,SAAS,QAAQ,IAAI,YAAY,WAAW;AAClD,UAAM,aAAa,IAAI,KAAK,IAAI,QAAQ,OAAO,cAAc,OAAO,KAAK,GAAG,OAAO,EAAE;AACrF,WAAO;AAAA,MACH,MAAM,yBAAyB,WAAW,cAAc,WAAW,uBAAuB,UAAU,KAAK,IAAI,MAAM,WAAW,QAAQ,IAAM,CAAC,KAAK,IAAI,MAAM,WAAW,MAAM,KAAM,CAAC,KAAK,IAAI,MAAM,WAAW,SAAS,IAAQ,CAAC;AAAA,MAChO,MAAM;AAAA,IAAA;AAAA,EAEd;AACJ;"}

package/anisotropy-block-D5fXH_OY.js

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

package/anisotropy-block-D5fXH_OY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anisotropy-block-D5fXH_OY.js","sources":["../src/material/node/blocks/anisotropy-block.ts"],"sourcesContent":["/** AnisotropyBlock — passthrough marker.\n *\n *  All anisotropic GGX math (alphaT/alphaB, anisotropic Burley D, anisotropic\n *  Smith visibility, bent-normal env reflection) is implemented inside\n *  PBRMetallicRoughnessBlock, which walks into the connected AnisotropyBlock\n *  to read its inputs (intensity, direction, uv).\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"AnisotropyBlock\",\n    stage: \"fragment\",\n    emit(_block, _outputName, _stage, state, _ctx) {\n        state.usesAnisotropy = true;\n        return { expr: `vec3<f32>(0.0)`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAUO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,OAAO,MAAM;AAC3C,UAAM,iBAAiB;AACvB,WAAO,EAAE,MAAM,kBAAkB,MAAM,QAAA;AAAA,EAC3C;AACJ;"}

package/anisotropy-fragment-HgasXS7l.js

@@ -0,0 +1,89 @@
+const ANISO_BRDF_FUNCTIONS = `
+const RECIPROCAL_PI: f32 = 0.3183098861837907;
+fn getAnisotropicRoughness(alphaG: f32, anisotropy: f32) -> vec2<f32> {
+let aT = max(mix(alphaG, 1.0, anisotropy * anisotropy), 0.0005);
+let aB = max(alphaG, 0.0005);
+return vec2<f32>(aT, aB);
+}
+fn D_GGX_Anisotropic(NdotH: f32, TdotH: f32, BdotH: f32, alphaTB: vec2<f32>) -> f32 {
+let a2 = alphaTB.x * alphaTB.y;
+let v = vec3<f32>(alphaTB.y * TdotH, alphaTB.x * BdotH, a2 * NdotH);
+let v2 = dot(v, v);
+let w2 = a2 / v2;
+return a2 * w2 * w2 * RECIPROCAL_PI;
+}
+fn V_GGXCorrelated_Anisotropic(NdotL: f32, NdotV: f32, TdotV: f32, BdotV: f32, TdotL: f32, BdotL: f32, alphaTB: vec2<f32>) -> f32 {
+let lambdaV = NdotL * length(vec3<f32>(alphaTB.x * TdotV, alphaTB.y * BdotV, NdotV));
+let lambdaL = NdotV * length(vec3<f32>(alphaTB.x * TdotL, alphaTB.y * BdotL, NdotL));
+return 0.5 / (lambdaV + lambdaL);
+}
+`;
+function makeAnisotropyTBBlock(hasNormal) {
+  if (hasNormal) {
+    return `var anisoT = normalize(input.worldTangent);
+var anisoB = normalize(input.worldBitangent);
+{
+let anisoDir = normalize(vec2<f32>(material.anisotropyParams.y, material.anisotropyParams.z));
+anisoT = normalize(anisoT * anisoDir.x + anisoB * anisoDir.y);
+anisoB = normalize(cross(N, anisoT));
+}`;
+  }
+  return `var anisoT: vec3<f32>;
+var anisoB: vec3<f32>;
+{
+let aniso_dp1 = dpdx(input.worldPos);
+let aniso_dp2 = -dpdy(input.worldPos);
+let aniso_duv1 = dpdx(input.uv);
+let aniso_duv2 = -dpdy(input.uv);
+let aniso_dp2perp = cross(aniso_dp2, N);
+let aniso_dp1perp = cross(N, aniso_dp1);
+var aniso_t = aniso_dp2perp * aniso_duv1.x + aniso_dp1perp * aniso_duv2.x;
+var aniso_b = aniso_dp2perp * aniso_duv1.y + aniso_dp1perp * aniso_duv2.y;
+let aniso_det = max(dot(aniso_t, aniso_t), dot(aniso_b, aniso_b));
+let aniso_inv = select(inverseSqrt(aniso_det), 0.0, aniso_det == 0.0);
+aniso_t *= aniso_inv;
+aniso_b *= aniso_inv;
+let aniso_tn = normalize(aniso_t);
+let aniso_bn = normalize(aniso_b);
+let anisoTBN = mat3x3<f32>(aniso_tn, aniso_bn, N);
+let anisoDir = vec3<f32>(material.anisotropyParams.y, material.anisotropyParams.z, 0.0);
+anisoT = normalize(anisoTBN * anisoDir);
+anisoB = normalize(cross(anisoTBN[2], anisoT));
+}`;
+}
+const ANISO_DIRECT_DG = `let aniso_alphaTB = getAnisotropicRoughness(directAlphaG, material.anisotropyParams.x);
+let dl_TdotH = dot(anisoT, H); let dl_BdotH = dot(anisoB, H);
+let dl_TdotV = dot(anisoT, V); let dl_BdotV = dot(anisoB, V);
+let dl_TdotL = dot(anisoT, L); let dl_BdotL = dot(anisoB, L);
+let D = D_GGX_Anisotropic(NdotH, dl_TdotH, dl_BdotH, aniso_alphaTB);
+let G = V_GGXCorrelated_Anisotropic(NdotL, NdotV, dl_TdotV, dl_BdotV, dl_TdotL, dl_BdotL, aniso_alphaTB);`;
+const ANISO_BENT_NORMAL = `let anisoIntensity = material.anisotropyParams.x;
+var anisoBentNormal = cross(anisoB, V);
+anisoBentNormal = normalize(cross(anisoBentNormal, anisoB));
+let anisoSq = 1.0 - anisoIntensity * (1.0 - roughness);
+let anisoA = anisoSq * anisoSq * anisoSq * anisoSq;
+anisoBentNormal = normalize(mix(anisoBentNormal, N, anisoA));
+let R_raw = reflect(-V, anisoBentNormal);`;
+const pbrExt = {
+  id: "anisotropy",
+  phase: "fragment",
+  writeUbo(data, material, offsets) {
+    const aniso = material.anisotropy;
+    if (!(aniso == null ? void 0 : aniso.isEnabled) || !offsets.has("anisotropyParams")) {
+      return;
+    }
+    const off = offsets.get("anisotropyParams") / 4;
+    const dir = aniso.direction ?? [1, 0];
+    data[off] = aniso.intensity ?? 1;
+    data[off + 1] = dir[0];
+    data[off + 2] = dir[1];
+  }
+};
+export {
+  ANISO_BENT_NORMAL,
+  ANISO_BRDF_FUNCTIONS,
+  ANISO_DIRECT_DG,
+  makeAnisotropyTBBlock,
+  pbrExt
+};
+//# sourceMappingURL=anisotropy-fragment-HgasXS7l.js.map

package/anisotropy-fragment-HgasXS7l.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anisotropy-fragment-HgasXS7l.js","sources":["../src/material/pbr/fragments/anisotropy-fragment.ts"],"sourcesContent":["/**\n * Anisotropy PBR Template Extension\n *\n * Provides WGSL strings for anisotropic BRDF and tangent frame computation.\n * Dynamically imported only when a scene uses PBR anisotropy, keeping\n * non-anisotropy PBR bundles lean.\n */\n\nimport type { PbrMaterialProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\n\nexport const ANISO_BRDF_FUNCTIONS = `\nconst RECIPROCAL_PI: f32 = 0.3183098861837907;\nfn getAnisotropicRoughness(alphaG: f32, anisotropy: f32) -> vec2<f32> {\nlet aT = max(mix(alphaG, 1.0, anisotropy * anisotropy), 0.0005);\nlet aB = max(alphaG, 0.0005);\nreturn vec2<f32>(aT, aB);\n}\nfn D_GGX_Anisotropic(NdotH: f32, TdotH: f32, BdotH: f32, alphaTB: vec2<f32>) -> f32 {\nlet a2 = alphaTB.x * alphaTB.y;\nlet v = vec3<f32>(alphaTB.y * TdotH, alphaTB.x * BdotH, a2 * NdotH);\nlet v2 = dot(v, v);\nlet w2 = a2 / v2;\nreturn a2 * w2 * w2 * RECIPROCAL_PI;\n}\nfn V_GGXCorrelated_Anisotropic(NdotL: f32, NdotV: f32, TdotV: f32, BdotV: f32, TdotL: f32, BdotL: f32, alphaTB: vec2<f32>) -> f32 {\nlet lambdaV = NdotL * length(vec3<f32>(alphaTB.x * TdotV, alphaTB.y * BdotV, NdotV));\nlet lambdaL = NdotV * length(vec3<f32>(alphaTB.x * TdotL, alphaTB.y * BdotL, NdotL));\nreturn 0.5 / (lambdaV + lambdaL);\n}\n`;\n\n/** Generate anisotropy tangent/bitangent computation block for the given normal mode. */\nexport function makeAnisotropyTBBlock(hasNormal: boolean): string {\n    if (hasNormal) {\n        return `var anisoT = normalize(input.worldTangent);\nvar anisoB = normalize(input.worldBitangent);\n{\nlet anisoDir = normalize(vec2<f32>(material.anisotropyParams.y, material.anisotropyParams.z));\nanisoT = normalize(anisoT * anisoDir.x + anisoB * anisoDir.y);\nanisoB = normalize(cross(N, anisoT));\n}`;\n    }\n    // Cotangent frame from UV screen-space derivatives — matches BJS cotangent_frame()\n    // BJS negates dpdy via (-yFactor_) where yFactor_=1 in WebGPU\n    return `var anisoT: vec3<f32>;\nvar anisoB: vec3<f32>;\n{\nlet aniso_dp1 = dpdx(input.worldPos);\nlet aniso_dp2 = -dpdy(input.worldPos);\nlet aniso_duv1 = dpdx(input.uv);\nlet aniso_duv2 = -dpdy(input.uv);\nlet aniso_dp2perp = cross(aniso_dp2, N);\nlet aniso_dp1perp = cross(N, aniso_dp1);\nvar aniso_t = aniso_dp2perp * aniso_duv1.x + aniso_dp1perp * aniso_duv2.x;\nvar aniso_b = aniso_dp2perp * aniso_duv1.y + aniso_dp1perp * aniso_duv2.y;\nlet aniso_det = max(dot(aniso_t, aniso_t), dot(aniso_b, aniso_b));\nlet aniso_inv = select(inverseSqrt(aniso_det), 0.0, aniso_det == 0.0);\naniso_t *= aniso_inv;\naniso_b *= aniso_inv;\nlet aniso_tn = normalize(aniso_t);\nlet aniso_bn = normalize(aniso_b);\nlet anisoTBN = mat3x3<f32>(aniso_tn, aniso_bn, N);\nlet anisoDir = vec3<f32>(material.anisotropyParams.y, material.anisotropyParams.z, 0.0);\nanisoT = normalize(anisoTBN * anisoDir);\nanisoB = normalize(cross(anisoTBN[2], anisoT));\n}`;\n}\n\n/** Anisotropic D/G replacement for single-light direct lighting. */\nexport const ANISO_DIRECT_DG = `let aniso_alphaTB = getAnisotropicRoughness(directAlphaG, material.anisotropyParams.x);\nlet dl_TdotH = dot(anisoT, H); let dl_BdotH = dot(anisoB, H);\nlet dl_TdotV = dot(anisoT, V); let dl_BdotV = dot(anisoB, V);\nlet dl_TdotL = dot(anisoT, L); let dl_BdotL = dot(anisoB, L);\nlet D = D_GGX_Anisotropic(NdotH, dl_TdotH, dl_BdotH, aniso_alphaTB);\nlet G = V_GGXCorrelated_Anisotropic(NdotL, NdotV, dl_TdotV, dl_BdotV, dl_TdotL, dl_BdotL, aniso_alphaTB);`;\n\n/** IBL bent normal computation for anisotropic reflection. */\nexport const ANISO_BENT_NORMAL = `let anisoIntensity = material.anisotropyParams.x;\nvar anisoBentNormal = cross(anisoB, V);\nanisoBentNormal = normalize(cross(anisoBentNormal, anisoB));\nlet anisoSq = 1.0 - anisoIntensity * (1.0 - roughness);\nlet anisoA = anisoSq * anisoSq * anisoSq * anisoSq;\nanisoBentNormal = normalize(mix(anisoBentNormal, N, anisoA));\nlet R_raw = reflect(-V, anisoBentNormal);`;\n\n/** Anisotropy extension — template-only (contributes no ShaderFragment or bindings);\n *  present solely to write its material-UBO slice through the unified ext registry. */\nexport const pbrExt: PbrExt = {\n    id: \"anisotropy\",\n    phase: \"fragment\",\n    writeUbo(data: Float32Array, material: unknown, offsets: ReadonlyMap<string, number>): void {\n        const aniso = (material as PbrMaterialProps).anisotropy;\n        if (!aniso?.isEnabled || !offsets.has(\"anisotropyParams\")) {\n            return;\n        }\n        const off = offsets.get(\"anisotropyParams\")! / 4;\n        const dir = aniso.direction ?? [1, 0];\n        data[off] = aniso.intensity ?? 1.0;\n        data[off + 1] = dir[0]!;\n        data[off + 2] = dir[1]!;\n    },\n};\n"],"names":[],"mappings":"AAWO,MAAM,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsB7B,SAAS,sBAAsB,WAA4B;AAC9D,MAAI,WAAW;AACX,WAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOX;AAGA,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBX;AAGO,MAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAQxB,MAAM,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAU1B,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,SAAS,MAAoB,UAAmB,SAA4C;AACxF,UAAM,QAAS,SAA8B;AAC7C,QAAI,EAAC,+BAAO,cAAa,CAAC,QAAQ,IAAI,kBAAkB,GAAG;AACvD;AAAA,IACJ;AACA,UAAM,MAAM,QAAQ,IAAI,kBAAkB,IAAK;AAC/C,UAAM,MAAM,MAAM,aAAa,CAAC,GAAG,CAAC;AACpC,SAAK,GAAG,IAAI,MAAM,aAAa;AAC/B,SAAK,MAAM,CAAC,IAAI,IAAI,CAAC;AACrB,SAAK,MAAM,CAAC,IAAI,IAAI,CAAC;AAAA,EACzB;AACJ;"}

package/arc-tan2-block-d8sWt_x0.js

@@ -0,0 +1,12 @@
+const emitter = {
+  className: "ArcTan2Block",
+  emit(block, _outputName, stage, state, ctx) {
+    const x = ctx.cast(ctx.resolve(block, "x", stage, state), "f32").expr;
+    const y = ctx.cast(ctx.resolve(block, "y", stage, state), "f32").expr;
+    return { expr: `atan2(${x}, ${y})`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=arc-tan2-block-d8sWt_x0.js.map

package/arc-tan2-block-d8sWt_x0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arc-tan2-block-d8sWt_x0.js","sources":["../src/material/node/blocks/arc-tan2-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ArcTan2Block\",\n    emit(block, _outputName, stage, state, ctx) {\n        const x = ctx.cast(ctx.resolve(block, \"x\", stage, state), \"f32\").expr;\n        const y = ctx.cast(ctx.resolve(block, \"y\", stage, state), \"f32\").expr;\n        return { expr: `atan2(${x}, ${y})`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,IAAI,IAAI,KAAK,IAAI,QAAQ,OAAO,KAAK,OAAO,KAAK,GAAG,KAAK,EAAE;AACjE,UAAM,IAAI,IAAI,KAAK,IAAI,QAAQ,OAAO,KAAK,OAAO,KAAK,GAAG,KAAK,EAAE;AACjE,WAAO,EAAE,MAAM,SAAS,CAAC,KAAK,CAAC,KAAK,MAAM,MAAA;AAAA,EAC9C;AACJ;"}

package/assets/splat-sort-worker-Crg3CaCc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splat-sort-worker-Crg3CaCc.js","sources":["../src/loader-splat/splat-sort-worker.ts"],"sourcesContent":["/** Splat sort worker.\n *\n *  Vite import: `import SortWorker from './splat-sort-worker.ts?worker&inline'`.\n *  The `?worker&inline` query keeps the bundled worker JS embedded as a base-64\n *  blob in the splat scene chunk — it adds zero bytes to any other scene\n *  because the whole `loader-splat/` module is dynamic-imported.\n *\n *  Protocol\n *  --------\n *  Init (once):  `{ p: Float32Array, n: number }`\n *                — buffer is transferred and retained on the worker side.\n *                — positions are in mesh-LOCAL space (stride 3, xyz per splat).\n *  Sort  (N×):   `{ m: Float32Array(16), f: Float32Array(3), c: Float32Array(3), d: BigInt64Array }`\n *                — depthMix is round-tripped via transferable; layout is\n *                  high-32 bits = packed depth (then bit-inverted), low-32 bits = splat index.\n *                  After sort, low-32 bits give the back-to-front order.\n *\n *  Depth recipe (mirrors BJS `_CreateWorker`)\n *  ------------------------------------------\n *  Per-frame the main thread sends the mesh's world matrix, the camera's\n *  world-space forward vector and the camera's world-space position. The\n *  worker collapses these into 4 scalars (a, b, c, d) such that\n *     depth = a*localX + b*localY + c*localZ + d\n *           = cameraForward · (world · localPos - cameraPosition).\n *  This is more robust than the previous `10000 - dot(view-row, pos)` recipe:\n *    - it accounts for non-identity world matrices (BJS Lite previously ignored them);\n *    - it has no magic reference value, so it doesn't lose precision when\n *      depths are large or wrap signs when depths exceed the reference;\n *    - the back-to-front order is produced by bit-inverting the high 32 bits\n *      of each i64 slot (`~indices[2j+1]`) instead of subtracting depths from\n *      a constant — this preserves the full float precision range. */\n\nlet positions: Float32Array | null = null;\nlet vertexCount = 0;\n\nself.onmessage = (e: MessageEvent) => {\n    const data = e.data as {\n        p?: Float32Array;\n        n?: number;\n        m?: Float32Array;\n        f?: Float32Array;\n        c?: Float32Array;\n        d?: BigInt64Array;\n    };\n\n    if (data.p) {\n        positions = data.p;\n        vertexCount = data.n ?? 0;\n        return;\n    }\n\n    if (!positions || !data.m || !data.f || !data.c || !data.d) {\n        return;\n    }\n\n    const m = data.m;\n    const cf = data.f;\n    const cp = data.c;\n    const depthMix = data.d;\n    const indices = new Uint32Array(depthMix.buffer);\n    const floatMix = new Float32Array(depthMix.buffer);\n\n    // Collapse cameraForward · (world · localPos - cameraPos) into (a*x + b*y + c*z + d).\n    // Lite column-major: world's column k lives at indices [4k, 4k+1, 4k+2, 4k+3]\n    // (the 4th row is always [0,0,0,1] for an affine matrix, so we skip m[3,7,11,15]).\n    const camDot = cf[0]! * cp[0]! + cf[1]! * cp[1]! + cf[2]! * cp[2]!;\n    const a = cf[0]! * m[0]! + cf[1]! * m[1]! + cf[2]! * m[2]!;\n    const b = cf[0]! * m[4]! + cf[1]! * m[5]! + cf[2]! * m[6]!;\n    const c = cf[0]! * m[8]! + cf[1]! * m[9]! + cf[2]! * m[10]!;\n    const d = cf[0]! * m[12]! + cf[1]! * m[13]! + cf[2]! * m[14]! - camDot;\n\n    for (let j = 0; j < vertexCount; j++) {\n        indices[2 * j] = j;\n        floatMix[2 * j + 1] = a * positions[3 * j]! + b * positions[3 * j + 1]! + c * positions[3 * j + 2]! + d;\n        // Bit-invert the high 32 bits (where the depth float lives) so that\n        // BigInt64Array.sort() yields back-to-front order without subtracting\n        // depths from a constant (which would cap range and erode precision).\n        indices[2 * j + 1] = ~indices[2 * j + 1]!;\n    }\n\n    depthMix.sort();\n\n    (self as unknown as { postMessage: (m: unknown, t?: Transferable[]) => void }).postMessage({ d: depthMix }, [depthMix.buffer]);\n};\n"],"names":[],"mappings":";;AAgCA,MAAI,YAAiC;AACrC,MAAI,cAAc;AAElB,OAAK,YAAY,CAAC,MAAoB;AAClC,UAAM,OAAO,EAAE;AASf,QAAI,KAAK,GAAG;AACR,kBAAY,KAAK;AACjB,oBAAc,KAAK,KAAK;AACxB;AAAA,IACJ;AAEA,QAAI,CAAC,aAAa,CAAC,KAAK,KAAK,CAAC,KAAK,KAAK,CAAC,KAAK,KAAK,CAAC,KAAK,GAAG;AACxD;AAAA,IACJ;AAEA,UAAM,IAAI,KAAK;AACf,UAAM,KAAK,KAAK;AAChB,UAAM,KAAK,KAAK;AAChB,UAAM,WAAW,KAAK;AACtB,UAAM,UAAU,IAAI,YAAY,SAAS,MAAM;AAC/C,UAAM,WAAW,IAAI,aAAa,SAAS,MAAM;AAKjD,UAAM,SAAS,GAAG,CAAC,IAAK,GAAG,CAAC,IAAK,GAAG,CAAC,IAAK,GAAG,CAAC,IAAK,GAAG,CAAC,IAAK,GAAG,CAAC;AAChE,UAAM,IAAI,GAAG,CAAC,IAAK,EAAE,CAAC,IAAK,GAAG,CAAC,IAAK,EAAE,CAAC,IAAK,GAAG,CAAC,IAAK,EAAE,CAAC;AACxD,UAAM,IAAI,GAAG,CAAC,IAAK,EAAE,CAAC,IAAK,GAAG,CAAC,IAAK,EAAE,CAAC,IAAK,GAAG,CAAC,IAAK,EAAE,CAAC;AACxD,UAAM,IAAI,GAAG,CAAC,IAAK,EAAE,CAAC,IAAK,GAAG,CAAC,IAAK,EAAE,CAAC,IAAK,GAAG,CAAC,IAAK,EAAE,EAAE;AACzD,UAAM,IAAI,GAAG,CAAC,IAAK,EAAE,EAAE,IAAK,GAAG,CAAC,IAAK,EAAE,EAAE,IAAK,GAAG,CAAC,IAAK,EAAE,EAAE,IAAK;AAEhE,aAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AAClC,cAAQ,IAAI,CAAC,IAAI;AACjB,eAAS,IAAI,IAAI,CAAC,IAAI,IAAI,UAAU,IAAI,CAAC,IAAK,IAAI,UAAU,IAAI,IAAI,CAAC,IAAK,IAAI,UAAU,IAAI,IAAI,CAAC,IAAK;AAItG,cAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC;AAAA,IAC3C;AAEA,aAAS,KAAA;AAER,SAA8E,YAAY,EAAE,GAAG,YAAY,CAAC,SAAS,MAAM,CAAC;AAAA,EACjI;;"}

package/background-dds-skybox-yHTqabU3.js

@@ -0,0 +1,221 @@
+import { e as createMappedBuffer, aO as getOrCreateSampler, aY as createUniformBuffer, aW as SCENE_UBO_WGSL } from "./index-C8HOR2sB.js";
+import { a as WGSL_DITHER, b as WGSL_NO_DITHER } from "./wgsl-helpers-DyzNzCeE.js";
+import { c as createCubemapSkyboxMaterial } from "./cubemap-skybox-material-DvXMVc4k.js";
+const ddsSkyboxVertSrc = "// DDS Skybox Vertex Shader — standard world transform.\n// positionUVW uses local position for cube direction lookup.\n\nstruct MeshUniforms {\n  world: mat4x4<f32>,\n};\n\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n\nstruct VertexOutput {\n  @builtin(position) clipPos: vec4<f32>,\n  @location(0) positionUVW: vec3<f32>,\n  @location(1) positionW: vec3<f32>,\n};\n\n@vertex\nfn main(@location(0) position: vec3<f32>) -> VertexOutput {\n  var output: VertexOutput;\n  output.positionUVW = position;\n  let worldPos = (mesh.world * vec4<f32>(position, 1.0)).xyz;\n  output.positionW = worldPos;\n  output.clipPos = scene.viewProjection * vec4<f32>(worldPos, 1.0);\n  return output;\n}\n";
+const ddsSkyboxFragSrc = "// DDS Cube Skybox Fragment Shader — samples DDS cube texture with BJS image processing.\n// Used by scenes that load backgroundSkybox.dds (createDefaultEnvironment).\n// Pipeline: exposure → Reinhard tonemap → gamma → contrast → dither.\n\nstruct MeshUniforms {\n  world: mat4x4<f32>,\n  primaryColor: vec3<f32>,\n  exposureLinear: f32,\n  contrast: f32,\n  _pad1: f32,\n  _pad2: f32,\n  _pad3: f32,\n};\n\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n@group(1) @binding(1) var envCubemap: texture_cube<f32>;\n@group(1) @binding(2) var envSampler: sampler;\n\nstruct FragmentInput {\n  @location(0) positionUVW: vec3<f32>,\n  @location(1) positionW: vec3<f32>,\n};\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n  let dir = normalize(input.positionUVW);\n  var color = textureSampleLevel(envCubemap, envSampler, dir, 0.0).rgb;\n\n  // BJS BackgroundMaterial: colorBase = reflectionColor.rgb * primaryColor.rgb\n  color *= mesh.primaryColor;\n\n  if (scene.vImageInfos.w >= 0.0) {\n    // Exposure\n    color *= mesh.exposureLinear;\n    // Reinhard tonemap (matches BJS toneMappingType 0)\n    color = 1.0 - exp2(-1.590579 * color);\n    // Gamma\n    color = pow(color, vec3<f32>(1.0 / 2.2));\n    color = saturate(color);\n\n    // Contrast\n    let highContrast = color * color * (3.0 - 2.0 * color);\n    color = mix(color, highContrast, mesh.contrast - 1.0);\n\n    // Dithering (enableNoise=true, variance=0.5)\n    color = color + vec3<f32>(dither(input.positionW.xy, 0.5));\n    color = max(color, vec3<f32>(0.0));\n  }\n\n  return vec4<f32>(color, 1.0);\n}\n";
+const SKY_DDS_UNIFORM_SIZE = 96;
+const DEFAULT_SKY_URL = "https://assets.babylonjs.com/core/environments/backgroundSkybox.dds";
+function createSkyboxBuffers(engine, S) {
+  const positions = new Float32Array([
+    S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    S,
+    S,
+    S,
+    S,
+    S,
+    S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    S,
+    S,
+    S,
+    S,
+    -S,
+    S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    S,
+    -S,
+    S,
+    -S,
+    S,
+    S,
+    -S,
+    S,
+    S,
+    S,
+    S,
+    -S,
+    S,
+    S,
+    -S,
+    -S,
+    -S,
+    -S,
+    -S,
+    -S,
+    -S,
+    S
+  ]);
+  const indices = new Uint16Array([
+    2,
+    1,
+    0,
+    3,
+    2,
+    0,
+    6,
+    5,
+    4,
+    7,
+    6,
+    4,
+    10,
+    9,
+    8,
+    11,
+    10,
+    8,
+    14,
+    13,
+    12,
+    15,
+    14,
+    12,
+    18,
+    17,
+    16,
+    19,
+    18,
+    16,
+    22,
+    21,
+    20,
+    23,
+    22,
+    20
+  ]);
+  return {
+    posBuffer: createMappedBuffer(engine, positions, GPUBufferUsage.VERTEX),
+    idxBuffer: createMappedBuffer(engine, indices, GPUBufferUsage.INDEX),
+    idxCount: 36
+  };
+}
+function buildSkyboxWorldMatrix(rootPosition) {
+  const world = new Float32Array(16);
+  world[0] = 1;
+  world[5] = 1;
+  world[10] = 1;
+  world[15] = 1;
+  world[12] = rootPosition[0];
+  world[13] = rootPosition[1];
+  world[14] = rootPosition[2];
+  return world;
+}
+async function buildDdsSkyboxRenderable(scene, skyHalfSize, rootPosition, primaryColor, skyboxTextureUrl, enableNoise = true) {
+  const engine = scene.engine;
+  const skyboxWorld = buildSkyboxWorldMatrix(rootPosition);
+  const skyBufs = createSkyboxBuffers(engine, skyHalfSize);
+  const { cubeView, sampler } = await loadDdsCube(engine, skyboxTextureUrl ?? DEFAULT_SKY_URL);
+  const fragCode = SCENE_UBO_WGSL + (enableNoise ? WGSL_DITHER : WGSL_NO_DITHER) + ddsSkyboxFragSrc;
+  const mat = createCubemapSkyboxMaterial(enableNoise ? "skybox-dds" : "skybox-dds0", SCENE_UBO_WGSL + ddsSkyboxVertSrc, fragCode);
+  const ubo = createDdsMeshUBO(engine, skyboxWorld, primaryColor, scene.imageProcessing.exposure, scene.imageProcessing.contrast);
+  const bindGroup = mat.createBindGroup(engine, ubo, cubeView, sampler);
+  const r = {
+    order: 0,
+    isTransparent: false,
+    bind(eng, sig) {
+      return {
+        renderable: r,
+        pipeline: mat.getPipeline(eng, sig),
+        draw(pass) {
+          pass.setBindGroup(1, bindGroup);
+          pass.setVertexBuffer(0, skyBufs.posBuffer);
+          pass.setIndexBuffer(skyBufs.idxBuffer, "uint16");
+          pass.drawIndexed(skyBufs.idxCount);
+          return 1;
+        }
+      };
+    }
+  };
+  return r;
+}
+function createDdsMeshUBO(engine, world, primaryColor, exposureLinear, contrast) {
+  const data = new Float32Array(SKY_DDS_UNIFORM_SIZE / 4);
+  data.set(world, 0);
+  data[16] = primaryColor[0];
+  data[17] = primaryColor[1];
+  data[18] = primaryColor[2];
+  data[19] = exposureLinear;
+  data[20] = contrast;
+  return createUniformBuffer(engine, data);
+}
+async function loadDdsCube(engine, url) {
+  const device = engine._device;
+  const buf = await (await fetch(url)).arrayBuffer();
+  const header = new Int32Array(buf, 0, 32);
+  const width = header[3];
+  const height = header[4];
+  const mipCount = Math.max(header[7], 1);
+  const dataOffset = header[21] === 808540228 ? 128 + 20 : 128;
+  const raw = new Uint8Array(buf, dataOffset);
+  const fmt = "rgba16float";
+  const tex = device.createTexture({
+    size: [width, height, 6],
+    format: fmt,
+    mipLevelCount: mipCount,
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+    dimension: "2d"
+  });
+  let offset = 0;
+  for (let face = 0; face < 6; face++) {
+    for (let m = 0; m < mipCount; m++) {
+      const s = Math.max(width >> m, 1);
+      device.queue.writeTexture(
+        { texture: tex, origin: { x: 0, y: 0, z: face }, mipLevel: m },
+        raw.buffer,
+        { offset: raw.byteOffset + offset, bytesPerRow: s * 8 },
+        { width: s, height: s }
+      );
+      offset += s * s * 8;
+    }
+  }
+  const cubeView = tex.createView({ dimension: "cube" });
+  const sampler = getOrCreateSampler(engine, {
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+    maxAnisotropy: 4
+  });
+  return { cubeView, sampler };
+}
+export {
+  buildDdsSkyboxRenderable
+};
+//# sourceMappingURL=background-dds-skybox-yHTqabU3.js.map

package/background-dds-skybox-yHTqabU3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-dds-skybox-yHTqabU3.js","sources":["../shaders/skybox-dds.vertex.wgsl?raw","../shaders/skybox-dds.fragment.wgsl?raw","../src/material/pbr/background-dds-skybox.ts"],"sourcesContent":["export default \"// DDS Skybox Vertex Shader — standard world transform.\\n// positionUVW uses local position for cube direction lookup.\\n\\nstruct MeshUniforms {\\n  world: mat4x4<f32>,\\n};\\n\\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\\n\\nstruct VertexOutput {\\n  @builtin(position) clipPos: vec4<f32>,\\n  @location(0) positionUVW: vec3<f32>,\\n  @location(1) positionW: vec3<f32>,\\n};\\n\\n@vertex\\nfn main(@location(0) position: vec3<f32>) -> VertexOutput {\\n  var output: VertexOutput;\\n  output.positionUVW = position;\\n  let worldPos = (mesh.world * vec4<f32>(position, 1.0)).xyz;\\n  output.positionW = worldPos;\\n  output.clipPos = scene.viewProjection * vec4<f32>(worldPos, 1.0);\\n  return output;\\n}\\n\"","export default \"// DDS Cube Skybox Fragment Shader — samples DDS cube texture with BJS image processing.\\n// Used by scenes that load backgroundSkybox.dds (createDefaultEnvironment).\\n// Pipeline: exposure → Reinhard tonemap → gamma → contrast → dither.\\n\\nstruct MeshUniforms {\\n  world: mat4x4<f32>,\\n  primaryColor: vec3<f32>,\\n  exposureLinear: f32,\\n  contrast: f32,\\n  _pad1: f32,\\n  _pad2: f32,\\n  _pad3: f32,\\n};\\n\\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\\n@group(1) @binding(1) var envCubemap: texture_cube<f32>;\\n@group(1) @binding(2) var envSampler: sampler;\\n\\nstruct FragmentInput {\\n  @location(0) positionUVW: vec3<f32>,\\n  @location(1) positionW: vec3<f32>,\\n};\\n\\n@fragment\\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\\n  let dir = normalize(input.positionUVW);\\n  var color = textureSampleLevel(envCubemap, envSampler, dir, 0.0).rgb;\\n\\n  // BJS BackgroundMaterial: colorBase = reflectionColor.rgb * primaryColor.rgb\\n  color *= mesh.primaryColor;\\n\\n  if (scene.vImageInfos.w >= 0.0) {\\n    // Exposure\\n    color *= mesh.exposureLinear;\\n    // Reinhard tonemap (matches BJS toneMappingType 0)\\n    color = 1.0 - exp2(-1.590579 * color);\\n    // Gamma\\n    color = pow(color, vec3<f32>(1.0 / 2.2));\\n    color = saturate(color);\\n\\n    // Contrast\\n    let highContrast = color * color * (3.0 - 2.0 * color);\\n    color = mix(color, highContrast, mesh.contrast - 1.0);\\n\\n    // Dithering (enableNoise=true, variance=0.5)\\n    color = color + vec3<f32>(dither(input.positionW.xy, 0.5));\\n    color = max(color, vec3<f32>(0.0));\\n  }\\n\\n  return vec4<f32>(color, 1.0);\\n}\\n\"","/** DDS cube skybox — lazy-loaded only when skyboxUrl ends with .dds.\n *  Loads backgroundSkybox.dds and renders it with BJS image processing. */\n\nimport type { SceneContext } from \"../../scene/scene.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { Mat4 } from \"../../math/types.js\";\nimport type { Renderable } from \"../../render/renderable.js\";\nimport { getOrCreateSampler } from \"../../resource/gpu-pool.js\";\nimport { createMappedBuffer, createUniformBuffer } from \"../../resource/gpu-buffers.js\";\nimport { WGSL_DITHER, WGSL_NO_DITHER } from \"../../shader/wgsl-helpers.js\";\nimport { SCENE_UBO_WGSL } from \"../../shader/scene-uniforms.js\";\nimport { createCubemapSkyboxMaterial } from \"./cubemap-skybox-material.js\";\nimport ddsSkyboxVertSrc from \"../../../shaders/skybox-dds.vertex.wgsl?raw\";\nimport ddsSkyboxFragSrc from \"../../../shaders/skybox-dds.fragment.wgsl?raw\";\n\nconst SKY_DDS_UNIFORM_SIZE = 96;\nconst DEFAULT_SKY_URL = \"https://assets.babylonjs.com/core/environments/backgroundSkybox.dds\";\n\nfunction createSkyboxBuffers(engine: EngineContext, S: number): { posBuffer: GPUBuffer; idxBuffer: GPUBuffer; idxCount: number } {\n    // prettier-ignore\n    const positions = new Float32Array([\n     S,-S, S, -S,-S, S, -S, S, S,  S, S, S,\n     S, S,-S, -S, S,-S, -S,-S,-S,  S,-S,-S,\n     S, S,-S,  S,-S,-S,  S,-S, S,  S, S, S,\n    -S, S, S, -S,-S, S, -S,-S,-S, -S, S,-S,\n    -S, S, S, -S, S,-S,  S, S,-S,  S, S, S,\n     S,-S, S,  S,-S,-S, -S,-S,-S, -S,-S, S,\n  ]);\n    // prettier-ignore\n    const indices = new Uint16Array([\n     2, 1, 0,  3, 2, 0,   6, 5, 4,  7, 6, 4,\n    10, 9, 8, 11,10, 8,  14,13,12, 15,14,12,\n    18,17,16, 19,18,16,  22,21,20, 23,22,20,\n  ]);\n    return {\n        posBuffer: createMappedBuffer(engine, positions, GPUBufferUsage.VERTEX),\n        idxBuffer: createMappedBuffer(engine, indices, GPUBufferUsage.INDEX),\n        idxCount: 36,\n    };\n}\n\nfunction buildSkyboxWorldMatrix(rootPosition: [number, number, number]): Mat4 {\n    const world = new Float32Array(16) as Mat4;\n    world[0] = 1;\n    world[5] = 1;\n    world[10] = 1;\n    world[15] = 1;\n    world[12] = rootPosition[0];\n    world[13] = rootPosition[1];\n    world[14] = rootPosition[2];\n    return world;\n}\n\n/** Build a DDS cube skybox as a complete Renderable (order 0). */\nexport async function buildDdsSkyboxRenderable(\n    scene: SceneContext,\n    skyHalfSize: number,\n    rootPosition: [number, number, number],\n    primaryColor: [number, number, number],\n    skyboxTextureUrl?: string,\n    enableNoise = true\n): Promise<Renderable> {\n    const engine = scene.engine;\n\n    const skyboxWorld = buildSkyboxWorldMatrix(rootPosition);\n\n    const skyBufs = createSkyboxBuffers(engine, skyHalfSize);\n    const { cubeView, sampler } = await loadDdsCube(engine, skyboxTextureUrl ?? DEFAULT_SKY_URL);\n\n    const fragCode = SCENE_UBO_WGSL + (enableNoise ? WGSL_DITHER : WGSL_NO_DITHER) + ddsSkyboxFragSrc;\n    const mat = createCubemapSkyboxMaterial(enableNoise ? \"skybox-dds\" : \"skybox-dds0\", SCENE_UBO_WGSL + ddsSkyboxVertSrc, fragCode);\n    const ubo = createDdsMeshUBO(engine, skyboxWorld, primaryColor, scene.imageProcessing.exposure, scene.imageProcessing.contrast);\n    const bindGroup = mat.createBindGroup(engine, ubo, cubeView, sampler);\n\n    const r: Renderable = {\n        order: 0,\n        isTransparent: false,\n        bind(eng, sig) {\n            return {\n                renderable: r,\n                pipeline: mat.getPipeline(eng as EngineContext, sig),\n                draw(pass) {\n                    pass.setBindGroup(1, bindGroup);\n                    pass.setVertexBuffer(0, skyBufs.posBuffer);\n                    pass.setIndexBuffer(skyBufs.idxBuffer, \"uint16\");\n                    pass.drawIndexed(skyBufs.idxCount);\n                    return 1;\n                },\n            };\n        },\n    };\n    return r;\n}\n\n// ─── DDS Skybox UBO ──────────────────────────────────────────────────────────\n\nfunction createDdsMeshUBO(engine: EngineContext, world: Float32Array, primaryColor: [number, number, number], exposureLinear: number, contrast: number): GPUBuffer {\n    const data = new Float32Array(SKY_DDS_UNIFORM_SIZE / 4);\n    data.set(world, 0);\n    data[16] = primaryColor[0];\n    data[17] = primaryColor[1];\n    data[18] = primaryColor[2];\n    data[19] = exposureLinear;\n    data[20] = contrast;\n    return createUniformBuffer(engine, data);\n}\n\n// ─── DDS Cube Texture Loader ─────────────────────────────────────────────────\n\n/** Load a DDS cube texture (rgba16float) and return a cube texture view + sampler.\n *  Uploads only mip 0 from the DDS file and generates remaining mipmaps on the\n *  GPU so that cube face edges blend seamlessly — matching BJS's behaviour. */\nasync function loadDdsCube(engine: EngineContext, url: string): Promise<{ cubeView: GPUTextureView; sampler: GPUSampler }> {\n    const device = engine._device;\n    const buf = await (await fetch(url)).arrayBuffer();\n    const header = new Int32Array(buf, 0, 32);\n    const width = header[3]!;\n    const height = header[4]!;\n    const mipCount = Math.max(header[7]!, 1);\n\n    // DDS pixel format offset 76..107 — for rgba16float, FourCC = 'DX10'\n    // DDS_HEADER_DX10 at byte 128: dxgiFormat, resourceDimension, miscFlag, arraySize, etc.\n    // For cube: miscFlag has RESOURCE_MISC_TEXTURECUBE (0x4), arraySize = 1 (6 faces in data)\n    const dataOffset = header[21] === 0x30315844 /* 'DX10' */ ? 128 + 20 : 128;\n    const raw = new Uint8Array(buf, dataOffset);\n\n    const fmt: GPUTextureFormat = \"rgba16float\";\n    const tex = device.createTexture({\n        size: [width, height, 6],\n        format: fmt,\n        mipLevelCount: mipCount,\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,\n        dimension: \"2d\",\n    });\n\n    // Upload all mip levels for each face from the DDS (face-major layout).\n    // Even though the skybox shader samples mip 0 explicitly, uploading all\n    // mips avoids the need for GPU-side mipmap generation.\n    let offset = 0;\n    for (let face = 0; face < 6; face++) {\n        for (let m = 0; m < mipCount; m++) {\n            const s = Math.max(width >> m, 1);\n            device.queue.writeTexture(\n                { texture: tex, origin: { x: 0, y: 0, z: face }, mipLevel: m },\n                raw.buffer,\n                { offset: raw.byteOffset + offset, bytesPerRow: s * 8 },\n                { width: s, height: s }\n            );\n            offset += s * s * 8;\n        }\n    }\n\n    const cubeView = tex.createView({ dimension: \"cube\" });\n    const sampler = getOrCreateSampler(engine, {\n        magFilter: \"linear\",\n        minFilter: \"linear\",\n        mipmapFilter: \"linear\",\n        addressModeU: \"clamp-to-edge\",\n        addressModeV: \"clamp-to-edge\",\n        addressModeW: \"clamp-to-edge\",\n        maxAnisotropy: 4,\n    });\n\n    return { cubeView, sampler };\n}\n"],"names":[],"mappings":"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"}