@babylonjs/lite 0.1.1

package/refraction-dispersion-wgsl-DdQCyyO1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refraction-dispersion-wgsl-DdQCyyO1.js","sources":["../src/material/pbr/fragments/refraction-dispersion-wgsl.ts"],"sourcesContent":["// Chromatic-dispersion refracted-environment sample (KHR_materials_dispersion).\n//\n// A pure data module: the per-RGB 3-ray WGSL is dynamically imported only by\n// scenes that actually use dispersion (see pbr-refraction.ts), so it ships in\n// no other transmission scene's bundle. The string is injected into the\n// refraction fragment factory (makeRefractionRttExt) rather than mutating any\n// shared module state, keeping shader generation scene-isolated.\n//\n// Splits the refracted ray into per-RGB index-of-refraction offsets, matching\n// BJS pbrBlockSubSurface: realIOR=1/eta, spread=0.04*dispersion*(realIOR-1),\n// iors=[1/(realIOR-spread), eta, 1/(realIOR+spread)].\n\n/** Per-RGB chromatic-dispersion refracted-environment sample WGSL, injected into\n *  the refraction fragment when a scene contains a dispersive transmissive material. */\nexport const DISPERSION_SAMPLE_WGSL = `let eta=material.refractionParams.y;\nlet realIOR=1.0/eta;\nlet spread=0.04*material.volumeParams.w*(realIOR-1.0);\nlet etaR=1.0/(realIOR-spread);\nlet etaB=1.0/(realIOR+spread);\nlet cpR=scene.viewProjection*vec4<f32>(input.worldPos+refract(-V,N,etaR)*th,1.0);\nlet cpG=scene.viewProjection*vec4<f32>(input.worldPos+refract(-V,N,eta)*th,1.0);\nlet cpB=scene.viewProjection*vec4<f32>(input.worldPos+refract(-V,N,etaB)*th,1.0);\nlet uvR=(cpR.xy/cpR.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);\nlet uvG=(cpG.xy/cpG.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);\nlet uvB=(cpB.xy/cpB.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);\nlet er=vec3<f32>(textureSampleLevel(refractionTexture,refractionSampler_,uvR,lv).r,textureSampleLevel(refractionTexture,refractionSampler_,uvG,lv).g,textureSampleLevel(refractionTexture,refractionSampler_,uvB,lv).b)*material.environmentIntensity;`;\n"],"names":[],"mappings":"AAcO,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;"}

package/remap-block-DxK1W1vp.js

@@ -0,0 +1,27 @@
+import { f as formatFloat } from "./_math-factory-C-QqW-Wi.js";
+function resolveOrSerialized(block, inputName, serializedKey, fallback, stage, state, ctx) {
+  const input = block.inputs.get(inputName);
+  if (input == null ? void 0 : input.source) {
+    return ctx.cast(ctx.resolve(block, inputName, stage, state), "f32").expr;
+  }
+  const raw = block.serialized[serializedKey];
+  return formatFloat(typeof raw === "number" ? raw : fallback);
+}
+const emitter = {
+  className: "RemapBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = ctx.resolve(block, "input", stage, state);
+    const sMin = resolveOrSerialized(block, "sourceMin", "sourceRange.x", -1, stage, state, ctx);
+    const sMax = resolveOrSerialized(block, "sourceMax", "sourceRange.y", 1, stage, state, ctx);
+    const tMin = resolveOrSerialized(block, "targetMin", "targetRange.x", 0, stage, state, ctx);
+    const tMax = resolveOrSerialized(block, "targetMax", "targetRange.y", 1, stage, state, ctx);
+    return {
+      expr: `(${tMin} + (${input.expr} - ${sMin}) * (${tMax} - ${tMin}) / (${sMax} - ${sMin}))`,
+      type: input.type
+    };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=remap-block-DxK1W1vp.js.map

package/remap-block-DxK1W1vp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remap-block-DxK1W1vp.js","sources":["../src/material/node/blocks/remap-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\nimport { formatFloat } from \"./_math-factory.js\";\n\nfunction resolveOrSerialized(\n    block: Parameters<BlockEmitter[\"emit\"]>[0],\n    inputName: string,\n    serializedKey: string,\n    fallback: number,\n    stage: Parameters<BlockEmitter[\"emit\"]>[2],\n    state: Parameters<BlockEmitter[\"emit\"]>[3],\n    ctx: Parameters<BlockEmitter[\"emit\"]>[4]\n): string {\n    const input = block.inputs.get(inputName);\n    if (input?.source) {\n        return ctx.cast(ctx.resolve(block, inputName, stage, state), \"f32\").expr;\n    }\n    const raw = block.serialized[serializedKey];\n    return formatFloat(typeof raw === \"number\" ? raw : fallback);\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"RemapBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = ctx.resolve(block, \"input\", stage, state);\n        const sMin = resolveOrSerialized(block, \"sourceMin\", \"sourceRange.x\", -1, stage, state, ctx);\n        const sMax = resolveOrSerialized(block, \"sourceMax\", \"sourceRange.y\", 1, stage, state, ctx);\n        const tMin = resolveOrSerialized(block, \"targetMin\", \"targetRange.x\", 0, stage, state, ctx);\n        const tMax = resolveOrSerialized(block, \"targetMax\", \"targetRange.y\", 1, stage, state, ctx);\n        // t + (v - s0) * (t1 - t0) / (s1 - s0)\n        return {\n            expr: `(${tMin} + (${input.expr} - ${sMin}) * (${tMax} - ${tMin}) / (${sMax} - ${sMin}))`,\n            type: input.type,\n        };\n    },\n};\n"],"names":[],"mappings":";AAGA,SAAS,oBACL,OACA,WACA,eACA,UACA,OACA,OACA,KACM;AACN,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,MAAI,+BAAO,QAAQ;AACf,WAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK,GAAG,KAAK,EAAE;AAAA,EACxE;AACA,QAAM,MAAM,MAAM,WAAW,aAAa;AAC1C,SAAO,YAAY,OAAO,QAAQ,WAAW,MAAM,QAAQ;AAC/D;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,OAAO,oBAAoB,OAAO,aAAa,iBAAiB,IAAI,OAAO,OAAO,GAAG;AAC3F,UAAM,OAAO,oBAAoB,OAAO,aAAa,iBAAiB,GAAG,OAAO,OAAO,GAAG;AAC1F,UAAM,OAAO,oBAAoB,OAAO,aAAa,iBAAiB,GAAG,OAAO,OAAO,GAAG;AAC1F,UAAM,OAAO,oBAAoB,OAAO,aAAa,iBAAiB,GAAG,OAAO,OAAO,GAAG;AAE1F,WAAO;AAAA,MACH,MAAM,IAAI,IAAI,OAAO,MAAM,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM,IAAI;AAAA,MACrF,MAAM,MAAM;AAAA,IAAA;AAAA,EAEpB;AACJ;"}

package/replace-color-block-1m--hiru.js

@@ -0,0 +1,17 @@
+const emitter = {
+  className: "ReplaceColorBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const value = ctx.resolve(block, "value", stage, state);
+    if (value.type === "f32" || value.type === "mat4f" || value.type === "texture2d" || value.type === "textureCube") {
+      throw new Error(`NodeMaterial: ReplaceColorBlock requires a vector/color value; got ${value.type}`);
+    }
+    const reference = ctx.cast(ctx.resolve(block, "reference", stage, state), value.type).expr;
+    const distance = ctx.cast(ctx.resolve(block, "distance", stage, state), "f32").expr;
+    const replacement = ctx.cast(ctx.resolve(block, "replacement", stage, state), value.type).expr;
+    return { expr: `select(${value.expr}, ${replacement}, length(${value.expr} - ${reference}) < ${distance})`, type: value.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=replace-color-block-1m--hiru.js.map

package/replace-color-block-1m--hiru.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-color-block-1m--hiru.js","sources":["../src/material/node/blocks/replace-color-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ReplaceColorBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const value = ctx.resolve(block, \"value\", stage, state);\n        if (value.type === \"f32\" || value.type === \"mat4f\" || value.type === \"texture2d\" || value.type === \"textureCube\") {\n            throw new Error(`NodeMaterial: ReplaceColorBlock requires a vector/color value; got ${value.type}`);\n        }\n        const reference = ctx.cast(ctx.resolve(block, \"reference\", stage, state), value.type).expr;\n        const distance = ctx.cast(ctx.resolve(block, \"distance\", stage, state), \"f32\").expr;\n        const replacement = ctx.cast(ctx.resolve(block, \"replacement\", stage, state), value.type).expr;\n        return { expr: `select(${value.expr}, ${replacement}, length(${value.expr} - ${reference}) < ${distance})`, type: value.type };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,QAAI,MAAM,SAAS,SAAS,MAAM,SAAS,WAAW,MAAM,SAAS,eAAe,MAAM,SAAS,eAAe;AAC9G,YAAM,IAAI,MAAM,sEAAsE,MAAM,IAAI,EAAE;AAAA,IACtG;AACA,UAAM,YAAY,IAAI,KAAK,IAAI,QAAQ,OAAO,aAAa,OAAO,KAAK,GAAG,MAAM,IAAI,EAAE;AACtF,UAAM,WAAW,IAAI,KAAK,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,GAAG,KAAK,EAAE;AAC/E,UAAM,cAAc,IAAI,KAAK,IAAI,QAAQ,OAAO,eAAe,OAAO,KAAK,GAAG,MAAM,IAAI,EAAE;AAC1F,WAAO,EAAE,MAAM,UAAU,MAAM,IAAI,KAAK,WAAW,YAAY,MAAM,IAAI,MAAM,SAAS,OAAO,QAAQ,KAAK,MAAM,MAAM,KAAA;AAAA,EAC5H;AACJ;"}

package/rgbd-decode-DCvzUYeI.js

@@ -0,0 +1,110 @@
+const WGSL = `override f:bool=false;@group(0)@binding(0)var t:texture_2d<f32>;@group(0)@binding(1)var o:texture_storage_2d<rgba16float,write>;@compute @workgroup_size(8,8)fn main(@builtin(global_invocation_id)g:vec3u){let d=textureDimensions(t);if(any(g.xy>=d)){return;}let c=textureLoad(t,vec2u(g.x,select(g.y,d.y-1u-g.y,f)),0);textureStore(o,g.xy,vec4f(pow(c.rgb,vec3f(2.2))/max(c.a,1.0/255.0),1));}`;
+let _device = null;
+let _module = null;
+let _noFlip = null;
+let _flip = null;
+function getPipeline(device, flipY) {
+  if (device !== _device) {
+    _device = device;
+    _module = device.createShaderModule({ code: WGSL });
+    _noFlip = null;
+    _flip = null;
+  }
+  const slot = flipY ? _flip : _noFlip;
+  if (slot) {
+    return slot;
+  }
+  const p = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: _module, entryPoint: "main", constants: { f: flipY ? 1 : 0 } }
+  });
+  if (flipY) {
+    _flip = p;
+  } else {
+    _noFlip = p;
+  }
+  return p;
+}
+function makeBindGroup(device, pipeline, inView, outView) {
+  return device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: inView },
+      { binding: 1, resource: outView }
+    ]
+  });
+}
+function encodeDispatch(encoder, pipeline, bg, w, h) {
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bg);
+  pass.dispatchWorkgroups(Math.ceil(w / 8), Math.ceil(h / 8));
+  pass.end();
+}
+function decodeBrdfPng(engine, image) {
+  const device = engine._device;
+  const pipeline = getPipeline(device, false);
+  const w = image.width;
+  const h = image.height;
+  const inputTex = device.createTexture({
+    size: { width: w, height: h },
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+  });
+  device.queue.copyExternalImageToTexture({ source: image, flipY: false }, { texture: inputTex, premultipliedAlpha: false }, { width: w, height: h });
+  const texture = device.createTexture({
+    size: { width: w, height: h },
+    format: "rgba16float",
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING
+  });
+  const bg = makeBindGroup(device, pipeline, inputTex.createView(), texture.createView());
+  const enc = device.createCommandEncoder();
+  encodeDispatch(enc, pipeline, bg, w, h);
+  device.queue.submit([enc.finish()]);
+  inputTex.destroy();
+  return texture;
+}
+function uploadCubemapRGBD(engine, images, width, mipCount) {
+  const device = engine._device;
+  const pipeline = getPipeline(device, true);
+  const texture = device.createTexture({
+    size: { width, height: width, depthOrArrayLayers: 6 },
+    format: "rgba16float",
+    mipLevelCount: mipCount,
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
+    dimension: "2d"
+  });
+  for (let mip = 0; mip < mipCount; mip++) {
+    const mipSize = Math.max(1, width >> mip);
+    const inputTex = device.createTexture({
+      size: { width: mipSize, height: mipSize },
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    const outputTex = device.createTexture({
+      size: { width: mipSize, height: mipSize },
+      format: "rgba16float",
+      usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC
+    });
+    const bindGroup = makeBindGroup(device, pipeline, inputTex.createView(), outputTex.createView());
+    for (let face = 0; face < 6; face++) {
+      const idx = mip * 6 + face;
+      if (idx >= images.length) {
+        break;
+      }
+      device.queue.copyExternalImageToTexture({ source: images[idx], flipY: false }, { texture: inputTex, premultipliedAlpha: false }, { width: mipSize, height: mipSize });
+      const encoder = device.createCommandEncoder();
+      encodeDispatch(encoder, pipeline, bindGroup, mipSize, mipSize);
+      encoder.copyTextureToTexture({ texture: outputTex }, { texture, origin: { x: 0, y: 0, z: face }, mipLevel: mip }, { width: mipSize, height: mipSize });
+      device.queue.submit([encoder.finish()]);
+    }
+    inputTex.destroy();
+    outputTex.destroy();
+  }
+  return texture;
+}
+export {
+  decodeBrdfPng,
+  uploadCubemapRGBD
+};
+//# sourceMappingURL=rgbd-decode-DCvzUYeI.js.map

package/rgbd-decode-DCvzUYeI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgbd-decode-DCvzUYeI.js","sources":["../src/loader-env/rgbd-decode.ts"],"sourcesContent":["/** RGBD decoder — decodes Babylon BRDF PNG and .env cubemap faces into rgba16float. */\n\nimport type { EngineContext } from \"../engine/engine.js\";\n\nconst WGSL = `override f:bool=false;@group(0)@binding(0)var t:texture_2d<f32>;@group(0)@binding(1)var o:texture_storage_2d<rgba16float,write>;@compute @workgroup_size(8,8)fn main(@builtin(global_invocation_id)g:vec3u){let d=textureDimensions(t);if(any(g.xy>=d)){return;}let c=textureLoad(t,vec2u(g.x,select(g.y,d.y-1u-g.y,f)),0);textureStore(o,g.xy,vec4f(pow(c.rgb,vec3f(2.2))/max(c.a,1.0/255.0),1));}`;\n\nlet _device: GPUDevice | null = null;\nlet _module: GPUShaderModule | null = null;\nlet _noFlip: GPUComputePipeline | null = null;\nlet _flip: GPUComputePipeline | null = null;\n\nfunction getPipeline(device: GPUDevice, flipY: boolean): GPUComputePipeline {\n    if (device !== _device) {\n        _device = device;\n        _module = device.createShaderModule({ code: WGSL });\n        _noFlip = null;\n        _flip = null;\n    }\n    const slot = flipY ? _flip : _noFlip;\n    if (slot) {\n        return slot;\n    }\n    const p = device.createComputePipeline({\n        layout: \"auto\",\n        compute: { module: _module!, entryPoint: \"main\", constants: { f: flipY ? 1 : 0 } },\n    });\n    if (flipY) {\n        _flip = p;\n    } else {\n        _noFlip = p;\n    }\n    return p;\n}\n\nfunction makeBindGroup(device: GPUDevice, pipeline: GPUComputePipeline, inView: GPUTextureView, outView: GPUTextureView): GPUBindGroup {\n    return device.createBindGroup({\n        layout: pipeline.getBindGroupLayout(0),\n        entries: [\n            { binding: 0, resource: inView },\n            { binding: 1, resource: outView },\n        ],\n    });\n}\n\nfunction encodeDispatch(encoder: GPUCommandEncoder, pipeline: GPUComputePipeline, bg: GPUBindGroup, w: number, h: number): void {\n    const pass = encoder.beginComputePass();\n    pass.setPipeline(pipeline);\n    pass.setBindGroup(0, bg);\n    pass.dispatchWorkgroups(Math.ceil(w / 8), Math.ceil(h / 8));\n    pass.end();\n}\n\n/** Decode a single RGBD PNG (e.g. BRDF LUT) `->` rgba16float 2D texture. No Y-flip. */\nexport function decodeBrdfPng(engine: EngineContext, image: ImageBitmap): GPUTexture {\n    const device = engine._device;\n    const pipeline = getPipeline(device, false);\n    const w = image.width;\n    const h = image.height;\n    const inputTex = device.createTexture({\n        size: { width: w, height: h },\n        format: \"rgba8unorm\",\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,\n    });\n    device.queue.copyExternalImageToTexture({ source: image, flipY: false }, { texture: inputTex, premultipliedAlpha: false }, { width: w, height: h });\n    const texture = device.createTexture({\n        size: { width: w, height: h },\n        format: \"rgba16float\",\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,\n    });\n    const bg = makeBindGroup(device, pipeline, inputTex.createView(), texture.createView());\n    const enc = device.createCommandEncoder();\n    encodeDispatch(enc, pipeline, bg, w, h);\n    device.queue.submit([enc.finish()]);\n    inputTex.destroy();\n    return texture;\n}\n\n/** Decode and upload a RGBD cubemap (6 faces × N mips) → rgba16float cube texture.\n *  Y-flipped on read (BJS uploads cubemap faces with invertY=true). */\nexport function uploadCubemapRGBD(engine: EngineContext, images: ImageBitmap[], width: number, mipCount: number): GPUTexture {\n    const device = engine._device;\n    const pipeline = getPipeline(device, true);\n\n    const texture = device.createTexture({\n        size: { width, height: width, depthOrArrayLayers: 6 },\n        format: \"rgba16float\",\n        mipLevelCount: mipCount,\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,\n        dimension: \"2d\",\n    });\n\n    for (let mip = 0; mip < mipCount; mip++) {\n        const mipSize = Math.max(1, width >> mip);\n\n        const inputTex = device.createTexture({\n            size: { width: mipSize, height: mipSize },\n            format: \"rgba8unorm\",\n            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,\n        });\n\n        const outputTex = device.createTexture({\n            size: { width: mipSize, height: mipSize },\n            format: \"rgba16float\",\n            usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC,\n        });\n\n        const bindGroup = makeBindGroup(device, pipeline, inputTex.createView(), outputTex.createView());\n\n        for (let face = 0; face < 6; face++) {\n            const idx = mip * 6 + face;\n            if (idx >= images.length) {\n                break;\n            }\n\n            device.queue.copyExternalImageToTexture({ source: images[idx]!, flipY: false }, { texture: inputTex, premultipliedAlpha: false }, { width: mipSize, height: mipSize });\n\n            const encoder = device.createCommandEncoder();\n            encodeDispatch(encoder, pipeline, bindGroup, mipSize, mipSize);\n            encoder.copyTextureToTexture({ texture: outputTex }, { texture, origin: { x: 0, y: 0, z: face }, mipLevel: mip }, { width: mipSize, height: mipSize });\n\n            // One submit per face ensures sequential hazards on the reused input/output.\n            device.queue.submit([encoder.finish()]);\n        }\n\n        inputTex.destroy();\n        outputTex.destroy();\n    }\n\n    return texture;\n}\n"],"names":[],"mappings":"AAIA,MAAM,OAAO;AAEb,IAAI,UAA4B;AAChC,IAAI,UAAkC;AACtC,IAAI,UAAqC;AACzC,IAAI,QAAmC;AAEvC,SAAS,YAAY,QAAmB,OAAoC;AACxE,MAAI,WAAW,SAAS;AACpB,cAAU;AACV,cAAU,OAAO,mBAAmB,EAAE,MAAM,MAAM;AAClD,cAAU;AACV,YAAQ;AAAA,EACZ;AACA,QAAM,OAAO,QAAQ,QAAQ;AAC7B,MAAI,MAAM;AACN,WAAO;AAAA,EACX;AACA,QAAM,IAAI,OAAO,sBAAsB;AAAA,IACnC,QAAQ;AAAA,IACR,SAAS,EAAE,QAAQ,SAAU,YAAY,QAAQ,WAAW,EAAE,GAAG,QAAQ,IAAI,EAAA,EAAE;AAAA,EAAE,CACpF;AACD,MAAI,OAAO;AACP,YAAQ;AAAA,EACZ,OAAO;AACH,cAAU;AAAA,EACd;AACA,SAAO;AACX;AAEA,SAAS,cAAc,QAAmB,UAA8B,QAAwB,SAAuC;AACnI,SAAO,OAAO,gBAAgB;AAAA,IAC1B,QAAQ,SAAS,mBAAmB,CAAC;AAAA,IACrC,SAAS;AAAA,MACL,EAAE,SAAS,GAAG,UAAU,OAAA;AAAA,MACxB,EAAE,SAAS,GAAG,UAAU,QAAA;AAAA,IAAQ;AAAA,EACpC,CACH;AACL;AAEA,SAAS,eAAe,SAA4B,UAA8B,IAAkB,GAAW,GAAiB;AAC5H,QAAM,OAAO,QAAQ,iBAAA;AACrB,OAAK,YAAY,QAAQ;AACzB,OAAK,aAAa,GAAG,EAAE;AACvB,OAAK,mBAAmB,KAAK,KAAK,IAAI,CAAC,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC;AAC1D,OAAK,IAAA;AACT;AAGO,SAAS,cAAc,QAAuB,OAAgC;AACjF,QAAM,SAAS,OAAO;AACtB,QAAM,WAAW,YAAY,QAAQ,KAAK;AAC1C,QAAM,IAAI,MAAM;AAChB,QAAM,IAAI,MAAM;AAChB,QAAM,WAAW,OAAO,cAAc;AAAA,IAClC,MAAM,EAAE,OAAO,GAAG,QAAQ,EAAA;AAAA,IAC1B,QAAQ;AAAA,IACR,OAAO,gBAAgB,kBAAkB,gBAAgB,WAAW,gBAAgB;AAAA,EAAA,CACvF;AACD,SAAO,MAAM,2BAA2B,EAAE,QAAQ,OAAO,OAAO,SAAS,EAAE,SAAS,UAAU,oBAAoB,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG;AAClJ,QAAM,UAAU,OAAO,cAAc;AAAA,IACjC,MAAM,EAAE,OAAO,GAAG,QAAQ,EAAA;AAAA,IAC1B,QAAQ;AAAA,IACR,OAAO,gBAAgB,kBAAkB,gBAAgB;AAAA,EAAA,CAC5D;AACD,QAAM,KAAK,cAAc,QAAQ,UAAU,SAAS,WAAA,GAAc,QAAQ,YAAY;AACtF,QAAM,MAAM,OAAO,qBAAA;AACnB,iBAAe,KAAK,UAAU,IAAI,GAAG,CAAC;AACtC,SAAO,MAAM,OAAO,CAAC,IAAI,OAAA,CAAQ,CAAC;AAClC,WAAS,QAAA;AACT,SAAO;AACX;AAIO,SAAS,kBAAkB,QAAuB,QAAuB,OAAe,UAA8B;AACzH,QAAM,SAAS,OAAO;AACtB,QAAM,WAAW,YAAY,QAAQ,IAAI;AAEzC,QAAM,UAAU,OAAO,cAAc;AAAA,IACjC,MAAM,EAAE,OAAO,QAAQ,OAAO,oBAAoB,EAAA;AAAA,IAClD,QAAQ;AAAA,IACR,eAAe;AAAA,IACf,OAAO,gBAAgB,kBAAkB,gBAAgB,WAAW,gBAAgB,WAAW,gBAAgB;AAAA,IAC/G,WAAW;AAAA,EAAA,CACd;AAED,WAAS,MAAM,GAAG,MAAM,UAAU,OAAO;AACrC,UAAM,UAAU,KAAK,IAAI,GAAG,SAAS,GAAG;AAExC,UAAM,WAAW,OAAO,cAAc;AAAA,MAClC,MAAM,EAAE,OAAO,SAAS,QAAQ,QAAA;AAAA,MAChC,QAAQ;AAAA,MACR,OAAO,gBAAgB,kBAAkB,gBAAgB,WAAW,gBAAgB;AAAA,IAAA,CACvF;AAED,UAAM,YAAY,OAAO,cAAc;AAAA,MACnC,MAAM,EAAE,OAAO,SAAS,QAAQ,QAAA;AAAA,MAChC,QAAQ;AAAA,MACR,OAAO,gBAAgB,kBAAkB,gBAAgB;AAAA,IAAA,CAC5D;AAED,UAAM,YAAY,cAAc,QAAQ,UAAU,SAAS,WAAA,GAAc,UAAU,YAAY;AAE/F,aAAS,OAAO,GAAG,OAAO,GAAG,QAAQ;AACjC,YAAM,MAAM,MAAM,IAAI;AACtB,UAAI,OAAO,OAAO,QAAQ;AACtB;AAAA,MACJ;AAEA,aAAO,MAAM,2BAA2B,EAAE,QAAQ,OAAO,GAAG,GAAI,OAAO,MAAA,GAAS,EAAE,SAAS,UAAU,oBAAoB,MAAA,GAAS,EAAE,OAAO,SAAS,QAAQ,SAAS;AAErK,YAAM,UAAU,OAAO,qBAAA;AACvB,qBAAe,SAAS,UAAU,WAAW,SAAS,OAAO;AAC7D,cAAQ,qBAAqB,EAAE,SAAS,UAAA,GAAa,EAAE,SAAS,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,QAAQ,UAAU,IAAA,GAAO,EAAE,OAAO,SAAS,QAAQ,SAAS;AAGrJ,aAAO,MAAM,OAAO,CAAC,QAAQ,OAAA,CAAQ,CAAC;AAAA,IAC1C;AAEA,aAAS,QAAA;AACT,cAAU,QAAA;AAAA,EACd;AAEA,SAAO;AACX;"}

package/rotate2d-block-nEe1N2MJ.js

@@ -0,0 +1,15 @@
+const emitter = {
+  className: "Rotate2dBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = ctx.cast(ctx.resolve(block, "input", stage, state), "vec2f");
+    const angle = ctx.cast(ctx.resolve(block, "angle", stage, state), "f32");
+    return {
+      expr: `vec2<f32>(cos(${angle.expr}) * (${input.expr}).x - sin(${angle.expr}) * (${input.expr}).y, sin(${angle.expr}) * (${input.expr}).x + cos(${angle.expr}) * (${input.expr}).y)`,
+      type: "vec2f"
+    };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=rotate2d-block-nEe1N2MJ.js.map

package/rotate2d-block-nEe1N2MJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotate2d-block-nEe1N2MJ.js","sources":["../src/material/node/blocks/rotate2d-block.ts"],"sourcesContent":["/** Rotate2dBlock — rotates a vec2 by angle radians around the origin. */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"Rotate2dBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = ctx.cast(ctx.resolve(block, \"input\", stage, state), \"vec2f\");\n        const angle = ctx.cast(ctx.resolve(block, \"angle\", stage, state), \"f32\");\n        return {\n            expr: `vec2<f32>(cos(${angle.expr}) * (${input.expr}).x - sin(${angle.expr}) * (${input.expr}).y, sin(${angle.expr}) * (${input.expr}).x + cos(${angle.expr}) * (${input.expr}).y)`,\n            type: \"vec2f\",\n        };\n    },\n};\n"],"names":[],"mappings":"AAIO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,OAAO;AACzE,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,KAAK;AACvE,WAAO;AAAA,MACH,MAAM,iBAAiB,MAAM,IAAI,QAAQ,MAAM,IAAI,aAAa,MAAM,IAAI,QAAQ,MAAM,IAAI,YAAY,MAAM,IAAI,QAAQ,MAAM,IAAI,aAAa,MAAM,IAAI,QAAQ,MAAM,IAAI;AAAA,MAC7K,MAAM;AAAA,IAAA;AAAA,EAEd;AACJ;"}

package/scale-block-C5Z8159G.js

@@ -0,0 +1,13 @@
+const emitter = {
+  className: "ScaleBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = ctx.resolve(block, "input", stage, state);
+    const factor = ctx.resolve(block, "factor", stage, state);
+    const fc = ctx.cast(factor, "f32").expr;
+    return { expr: `(${input.expr} * ${fc})`, type: input.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=scale-block-C5Z8159G.js.map

package/scale-block-C5Z8159G.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale-block-C5Z8159G.js","sources":["../src/material/node/blocks/scale-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ScaleBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = ctx.resolve(block, \"input\", stage, state);\n        const factor = ctx.resolve(block, \"factor\", stage, state);\n        // factor is always scalar in BJS\n        const fc = ctx.cast(factor, \"f32\").expr;\n        return { expr: `(${input.expr} * ${fc})`, type: input.type };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,SAAS,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK;AAExD,UAAM,KAAK,IAAI,KAAK,QAAQ,KAAK,EAAE;AACnC,WAAO,EAAE,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,KAAK,MAAM,MAAM,KAAA;AAAA,EAC1D;AACJ;"}

package/scene-material-swap-C2ykv55W.js

@@ -0,0 +1,34 @@
+function processMaterialSwaps(scene) {
+  const q = scene._materialSwapQueue;
+  for (const mesh of q) {
+    mesh._materialDirty = false;
+    const old = scene._meshDisposables.get(mesh);
+    if (old) {
+      for (const fn of old) {
+        fn();
+      }
+      scene._meshDisposables.delete(mesh);
+    }
+    const mat = mesh.material;
+    const builder = mat == null ? void 0 : mat._buildGroup;
+    if (!builder) {
+      continue;
+    }
+    const rebuild = builder._rebuildSingle;
+    if (!rebuild) {
+      continue;
+    }
+    const renderable = rebuild(scene, mesh);
+    let i = scene._renderables.length;
+    while (i > 0 && scene._renderables[i - 1].order > renderable.order) {
+      i--;
+    }
+    scene._renderables.splice(i, 0, renderable);
+  }
+  q.length = 0;
+  scene._renderableVersion++;
+}
+export {
+  processMaterialSwaps
+};
+//# sourceMappingURL=scene-material-swap-C2ykv55W.js.map

package/scene-material-swap-C2ykv55W.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-material-swap-C2ykv55W.js","sources":["../src/scene/scene-material-swap.ts"],"sourcesContent":["import type { SceneContext } from \"./scene-core.js\";\nimport type { Mesh } from \"../mesh/mesh.js\";\n\n/** @internal Drain _materialSwapQueue: dispose old resources and rebuild renderables. */\nexport function processMaterialSwaps(scene: SceneContext): void {\n    const q = scene._materialSwapQueue;\n    for (const mesh of q) {\n        (mesh as Mesh)._materialDirty = false;\n        const old = scene._meshDisposables.get(mesh);\n        if (old) {\n            for (const fn of old) {\n                fn();\n            }\n            scene._meshDisposables.delete(mesh);\n        }\n\n        const mat = mesh.material;\n        const builder = mat?._buildGroup;\n        if (!builder) {\n            continue;\n        }\n        const rebuild = builder._rebuildSingle;\n        if (!rebuild) {\n            continue;\n        }\n        const renderable = rebuild(scene, mesh);\n        // Insert by `order` so the renderable list stays sorted (frame-graph\n        // tasks bucket opaque/direct/transparent at bind time).\n        let i = scene._renderables.length;\n        while (i > 0 && scene._renderables[i - 1]!.order > renderable.order) {\n            i--;\n        }\n        scene._renderables.splice(i, 0, renderable);\n    }\n    q.length = 0;\n    scene._renderableVersion++;\n}\n"],"names":[],"mappings":"AAIO,SAAS,qBAAqB,OAA2B;AAC5D,QAAM,IAAI,MAAM;AAChB,aAAW,QAAQ,GAAG;AACjB,SAAc,iBAAiB;AAChC,UAAM,MAAM,MAAM,iBAAiB,IAAI,IAAI;AAC3C,QAAI,KAAK;AACL,iBAAW,MAAM,KAAK;AAClB,WAAA;AAAA,MACJ;AACA,YAAM,iBAAiB,OAAO,IAAI;AAAA,IACtC;AAEA,UAAM,MAAM,KAAK;AACjB,UAAM,UAAU,2BAAK;AACrB,QAAI,CAAC,SAAS;AACV;AAAA,IACJ;AACA,UAAM,UAAU,QAAQ;AACxB,QAAI,CAAC,SAAS;AACV;AAAA,IACJ;AACA,UAAM,aAAa,QAAQ,OAAO,IAAI;AAGtC,QAAI,IAAI,MAAM,aAAa;AAC3B,WAAO,IAAI,KAAK,MAAM,aAAa,IAAI,CAAC,EAAG,QAAQ,WAAW,OAAO;AACjE;AAAA,IACJ;AACA,UAAM,aAAa,OAAO,GAAG,GAAG,UAAU;AAAA,EAC9C;AACA,IAAE,SAAS;AACX,QAAM;AACV;"}

package/screen-size-block-BVNnOvE8.js

@@ -0,0 +1,21 @@
+const OUTPUTS = {
+  xy: { swizzle: "", type: "vec2f" },
+  x: { swizzle: ".x", type: "f32" },
+  y: { swizzle: ".y", type: "f32" }
+};
+const emitter = {
+  className: "ScreenSizeBlock",
+  stage: "fragment",
+  emit(_block, outputName, _stage, state) {
+    state.usesScreenSize = true;
+    const out = OUTPUTS[outputName];
+    if (!out) {
+      throw new Error(`NodeMaterial: ScreenSizeBlock has no output "${outputName}"`);
+    }
+    return { expr: `_NME_SCREEN_SIZE_${out.swizzle}`, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=screen-size-block-BVNnOvE8.js.map

package/screen-size-block-BVNnOvE8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-size-block-BVNnOvE8.js","sources":["../src/material/node/blocks/screen-size-block.ts"],"sourcesContent":["/** ScreenSizeBlock — exposes current render size in physical canvas pixels. */\n\nimport type { BlockEmitter, NodeValueType } from \"../node-types.js\";\n\nconst OUTPUTS: Record<string, { readonly swizzle: string; readonly type: NodeValueType }> = {\n    xy: { swizzle: \"\", type: \"vec2f\" },\n    x: { swizzle: \".x\", type: \"f32\" },\n    y: { swizzle: \".y\", type: \"f32\" },\n};\n\nexport const emitter: BlockEmitter = {\n    className: \"ScreenSizeBlock\",\n    stage: \"fragment\",\n    emit(_block, outputName, _stage, state) {\n        state.usesScreenSize = true;\n        const out = OUTPUTS[outputName];\n        if (!out) {\n            throw new Error(`NodeMaterial: ScreenSizeBlock has no output \"${outputName}\"`);\n        }\n        return { expr: `_NME_SCREEN_SIZE_${out.swizzle}`, type: out.type };\n    },\n};\n"],"names":[],"mappings":"AAIA,MAAM,UAAsF;AAAA,EACxF,IAAI,EAAE,SAAS,IAAI,MAAM,QAAA;AAAA,EACzB,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAC9B;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,YAAY,QAAQ,OAAO;AACpC,UAAM,iBAAiB;AACvB,UAAM,MAAM,QAAQ,UAAU;AAC9B,QAAI,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,gDAAgD,UAAU,GAAG;AAAA,IACjF;AACA,WAAO,EAAE,MAAM,oBAAoB,IAAI,OAAO,IAAI,MAAM,IAAI,KAAA;AAAA,EAChE;AACJ;"}

package/screen-space-block-CwaxdfSe.js

@@ -0,0 +1,28 @@
+const OUTPUTS = {
+  output: { swizzle: ".xy", type: "vec2f" },
+  x: { swizzle: ".x", type: "f32" },
+  y: { swizzle: ".y", type: "f32" }
+};
+const emitter = {
+  className: "ScreenSpaceBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    const vectorRaw = ctx.resolve(block, "vector", stage, state);
+    const vector = vectorRaw.type === "vec4f" ? vectorRaw : ctx.cast(vectorRaw, "vec3f");
+    const wvp = ctx.cast(ctx.resolve(block, "worldViewProjection", stage, state), "mat4f");
+    const clip = ctx.temp(state, "screenClip");
+    const uv = ctx.temp(state, "screenUv");
+    const vectorExpr = vector.type === "vec4f" ? vector.expr : `vec4<f32>(${vector.expr}, 1.0)`;
+    state.fragment.body.push(`let ${clip} = ${wvp.expr} * ${vectorExpr};`);
+    state.fragment.body.push(`let ${uv} = (${clip}.xy / ${clip}.w) * 0.5 + vec2<f32>(0.5, 0.5);`);
+    const out = OUTPUTS[outputName];
+    if (!out) {
+      throw new Error(`NodeMaterial: ScreenSpaceBlock has no output "${outputName}"`);
+    }
+    return { expr: `${uv}${out.swizzle}`, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=screen-space-block-CwaxdfSe.js.map

package/screen-space-block-CwaxdfSe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-space-block-CwaxdfSe.js","sources":["../src/material/node/blocks/screen-space-block.ts"],"sourcesContent":["/** ScreenSpaceBlock — transforms a vec3/vec4 by WVP and maps clip XY to 0..1 screen space. */\n\nimport type { BlockEmitter, NodeValueType } from \"../node-types.js\";\n\nconst OUTPUTS: Record<string, { readonly swizzle: string; readonly type: NodeValueType }> = {\n    output: { swizzle: \".xy\", type: \"vec2f\" },\n    x: { swizzle: \".x\", type: \"f32\" },\n    y: { swizzle: \".y\", type: \"f32\" },\n};\n\nexport const emitter: BlockEmitter = {\n    className: \"ScreenSpaceBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx) {\n        const vectorRaw = ctx.resolve(block, \"vector\", stage, state);\n        const vector = vectorRaw.type === \"vec4f\" ? vectorRaw : ctx.cast(vectorRaw, \"vec3f\");\n        const wvp = ctx.cast(ctx.resolve(block, \"worldViewProjection\", stage, state), \"mat4f\");\n        const clip = ctx.temp(state, \"screenClip\");\n        const uv = ctx.temp(state, \"screenUv\");\n        const vectorExpr = vector.type === \"vec4f\" ? vector.expr : `vec4<f32>(${vector.expr}, 1.0)`;\n        state.fragment.body.push(`let ${clip} = ${wvp.expr} * ${vectorExpr};`);\n        state.fragment.body.push(`let ${uv} = (${clip}.xy / ${clip}.w) * 0.5 + vec2<f32>(0.5, 0.5);`);\n        const out = OUTPUTS[outputName];\n        if (!out) {\n            throw new Error(`NodeMaterial: ScreenSpaceBlock has no output \"${outputName}\"`);\n        }\n        return { expr: `${uv}${out.swizzle}`, type: out.type };\n    },\n};\n"],"names":[],"mappings":"AAIA,MAAM,UAAsF;AAAA,EACxF,QAAQ,EAAE,SAAS,OAAO,MAAM,QAAA;AAAA,EAChC,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAC9B;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,YAAY,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK;AAC3D,UAAM,SAAS,UAAU,SAAS,UAAU,YAAY,IAAI,KAAK,WAAW,OAAO;AACnF,UAAM,MAAM,IAAI,KAAK,IAAI,QAAQ,OAAO,uBAAuB,OAAO,KAAK,GAAG,OAAO;AACrF,UAAM,OAAO,IAAI,KAAK,OAAO,YAAY;AACzC,UAAM,KAAK,IAAI,KAAK,OAAO,UAAU;AACrC,UAAM,aAAa,OAAO,SAAS,UAAU,OAAO,OAAO,aAAa,OAAO,IAAI;AACnF,UAAM,SAAS,KAAK,KAAK,OAAO,IAAI,MAAM,IAAI,IAAI,MAAM,UAAU,GAAG;AACrE,UAAM,SAAS,KAAK,KAAK,OAAO,EAAE,OAAO,IAAI,SAAS,IAAI,kCAAkC;AAC5F,UAAM,MAAM,QAAQ,UAAU;AAC9B,QAAI,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,iDAAiD,UAAU,GAAG;AAAA,IAClF;AACA,WAAO,EAAE,MAAM,GAAG,EAAE,GAAG,IAAI,OAAO,IAAI,MAAM,IAAI,KAAA;AAAA,EACpD;AACJ;"}