@babylonjs/lite 0.1.1

package/subsurface-fragment-liM3y2-P.js

@@ -0,0 +1,158 @@
+import { aH as PBR_HAS_THICKNESS_MAP, aI as PBR_HAS_SUBSURFACE, aJ as PBR2_HAS_THICKNESS_GLTF_CHANNEL } from "./index-C8HOR2sB.js";
+const SS_HELPERS = `
+fn transmittanceBRDF_Burley(tintColor: vec3<f32>, diffusionDistance: vec3<f32>, thickness: f32) -> vec3<f32> {
+let S = 1.0 / max(vec3<f32>(0.000001), diffusionDistance);
+let temp = exp((-0.333333333 * thickness) * S);
+return tintColor * 0.25 * (temp * temp * temp + 3.0 * temp);
+}
+fn computeWrappedDiffuseNdotL(NdotL: f32, w: f32) -> f32 {
+let t = 1.0 + w;
+let invt2 = 1.0 / (t * t);
+return saturate((NdotL + w) * invt2);
+}
+`;
+const SS_SCOPE_VARS = `var translucencyDirect = vec3<f32>(0.0);
+var ssTransmittance = vec3<f32>(0.0);
+var ssIntensity = 0.0;`;
+function makeThicknessBlock(hasThicknessMap, useGltfChannel) {
+  const chan = useGltfChannel ? "g" : "r";
+  const texSample = hasThicknessMap ? `let thicknessSample = textureSample(thicknessTexture_, thicknessSampler_, input.uv).${chan};` : `let thicknessSample = 1.0;`;
+  return `${texSample}
+let ssThickness = max(material.subsurfaceParams.y + thicknessSample * material.subsurfaceParams.z, 0.000001);
+let ssTranslucencyColor = material.subsurfaceParams3.rgb;
+let ssDiffDist = material.subsurfaceParams2.rgb;
+ssIntensity = material.subsurfaceParams.x;
+ssTransmittance = transmittanceBRDF_Burley(ssTranslucencyColor, ssDiffDist, ssThickness) * ssIntensity;`;
+}
+const SS_DIRECT = `{
+let NdotLU = dot(N, L);
+if (NdotLU < 0.0) {
+let wrapNdotL = computeWrappedDiffuseNdotL(abs(NdotLU), 0.02);
+translucencyDirect += (1.0 / PI) * wrapNdotL * ssTransmittance * lightAtten * lightColor * material.directIntensity;
+}
+}`;
+const SS_IBL_MOD = `{
+let N_back = -N_env;
+let envIrrBack = (scene.vSphericalL00.rgb
+  + scene.vSphericalL1_1.rgb * N_back.y + scene.vSphericalL10.rgb * N_back.z + scene.vSphericalL11.rgb * N_back.x
+  + scene.vSphericalL2_2.rgb * (N_back.y * N_back.x) + scene.vSphericalL2_1.rgb * (N_back.y * N_back.z)
+  + scene.vSphericalL20.rgb * (3.0 * N_back.z * N_back.z - 1.0) + scene.vSphericalL21.rgb * (N_back.z * N_back.x)
+  + scene.vSphericalL22.rgb * (N_back.x * N_back.x - N_back.y * N_back.y)) * material.environmentIntensity;
+let refractionIrradiance = envIrrBack * ssTransmittance;
+color -= finalIrradiance * ssIntensity;
+color += refractionIrradiance * occlusion;
+color -= directDiffuse * ssIntensity;
+color += translucencyDirect * occlusion;
+}`;
+const SS_NO_IBL_MOD = `color -= directDiffuse * ssIntensity;
+color += translucencyDirect;`;
+const STAGE_FRAGMENT = 2;
+function createSubsurfaceFragment(hasThicknessMap, hasIbl, useGltfThicknessChannel) {
+  const bindings = hasThicknessMap ? [
+    { _name: "thicknessTexture_", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+    { _name: "thicknessSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+  ] : [];
+  const slots = {
+    SV: SS_SCOPE_VARS,
+    AT: makeThicknessBlock(hasThicknessMap, useGltfThicknessChannel),
+    AD: SS_DIRECT
+  };
+  if (hasIbl) {
+    slots.AI = SS_IBL_MOD;
+  } else {
+    slots.NI = SS_NO_IBL_MOD;
+  }
+  const deps = [];
+  if (hasIbl) {
+    deps.push("ibl");
+  }
+  return {
+    _id: "subsurface",
+    _dependencies: deps.length > 0 ? deps : void 0,
+    _bindings: bindings.length > 0 ? bindings : void 0,
+    _uboFields: [
+      { _name: "subsurfaceParams", _type: "vec4<f32>" },
+      { _name: "subsurfaceParams2", _type: "vec4<f32>" },
+      { _name: "subsurfaceParams3", _type: "vec4<f32>" }
+    ],
+    _helperFunctions: SS_HELPERS,
+    _fragmentSlots: slots
+  };
+}
+function writeSubsurfaceUBO(data, ss, offsets) {
+  const trans = ss.translucency;
+  const thick = ss.thickness;
+  const off = offsets.get("subsurfaceParams") / 4;
+  data[off] = trans.intensity ?? 1;
+  const minThick = (thick == null ? void 0 : thick.min) ?? 0;
+  const maxThick = (thick == null ? void 0 : thick.max) ?? 1;
+  data[off + 1] = minThick;
+  data[off + 2] = maxThick - minThick;
+  const off2 = offsets.get("subsurfaceParams2") / 4;
+  const dd = trans.diffusionDistance ?? [1, 1, 1];
+  data[off2] = dd[0];
+  data[off2 + 1] = dd[1];
+  data[off2 + 2] = dd[2];
+  const off3 = offsets.get("subsurfaceParams3") / 4;
+  const tc = trans.color ?? [1, 1, 1];
+  data[off3] = tc[0];
+  data[off3 + 1] = tc[1];
+  data[off3 + 2] = tc[2];
+}
+const pbrExt = {
+  id: "subsurface",
+  phase: "fragment",
+  detect(mat) {
+    var _a, _b, _c;
+    const m = mat;
+    if (!((_a = m.subsurface) == null ? void 0 : _a.translucency)) {
+      return { f: 0, f2: 0 };
+    }
+    let f = PBR_HAS_SUBSURFACE;
+    let f2 = 0;
+    if ((_b = m.subsurface.thickness) == null ? void 0 : _b.texture) {
+      f |= PBR_HAS_THICKNESS_MAP;
+    }
+    if ((_c = m.subsurface.thickness) == null ? void 0 : _c.useGlTFChannel) {
+      f2 |= PBR2_HAS_THICKNESS_GLTF_CHANNEL;
+    }
+    return { f, f2 };
+  },
+  frag(ctx) {
+    if (!(ctx._features & PBR_HAS_SUBSURFACE)) {
+      return null;
+    }
+    return createSubsurfaceFragment((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0, ctx._hasIbl, (ctx._features2 & PBR2_HAS_THICKNESS_GLTF_CHANNEL) !== 0);
+  },
+  writeUbo(data, mat, offsets) {
+    var _a;
+    const m = mat;
+    if (((_a = m.subsurface) == null ? void 0 : _a.translucency) && offsets.has("subsurfaceParams")) {
+      writeSubsurfaceUBO(data, m.subsurface, offsets);
+    }
+  },
+  bind(ctx, entries, b) {
+    var _a, _b;
+    if ((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0) {
+      const tex = (_b = (_a = ctx._material.subsurface) == null ? void 0 : _a.thickness) == null ? void 0 : _b.texture;
+      if (tex) {
+        entries.push({ binding: b++, resource: tex.view });
+        entries.push({ binding: b++, resource: tex.sampler });
+      }
+    }
+    return b;
+  },
+  textures(mat, out) {
+    var _a, _b;
+    const t = (_b = (_a = mat.subsurface) == null ? void 0 : _a.thickness) == null ? void 0 : _b.texture;
+    if (t) {
+      out.push(t);
+    }
+  }
+};
+export {
+  createSubsurfaceFragment,
+  pbrExt,
+  writeSubsurfaceUBO
+};
+//# sourceMappingURL=subsurface-fragment-liM3y2-P.js.map

package/subsurface-fragment-liM3y2-P.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsurface-fragment-liM3y2-P.js","sources":["../src/material/pbr/fragments/subsurface-fragment.ts"],"sourcesContent":["/**\n * Subsurface Fragment\n *\n * Adds translucency — light passing through thin surfaces.\n * Only bundled when a scene uses PbrMaterialProps.subsurface.\n *\n * Math follows BJS PBRSubSurfaceConfiguration:\n *  - Burley transmittance BRDF: exp-based approximation\n *  - Thickness from texture (.g channel, BJS glTF-style default)\n *  - Direct: wrap-around diffuse scaled by transmittance\n *  - IBL: irradiance reduced by (1 - intensity), transmittance-weighted contribution added\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps, SubSurfaceProps } from \"../pbr-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR_HAS_SUBSURFACE, PBR_HAS_THICKNESS_MAP, PBR2_HAS_THICKNESS_GLTF_CHANNEL } from \"../pbr-flag-bits.js\";\n\nconst SS_HELPERS = `\nfn transmittanceBRDF_Burley(tintColor: vec3<f32>, diffusionDistance: vec3<f32>, thickness: f32) -> vec3<f32> {\nlet S = 1.0 / max(vec3<f32>(0.000001), diffusionDistance);\nlet temp = exp((-0.333333333 * thickness) * S);\nreturn tintColor * 0.25 * (temp * temp * temp + 3.0 * temp);\n}\nfn computeWrappedDiffuseNdotL(NdotL: f32, w: f32) -> f32 {\nlet t = 1.0 + w;\nlet invt2 = 1.0 / (t * t);\nreturn saturate((NdotL + w) * invt2);\n}\n`;\n\n// SV: declare subsurface scope variables\nconst SS_SCOPE_VARS = `var translucencyDirect = vec3<f32>(0.0);\nvar ssTransmittance = vec3<f32>(0.0);\nvar ssIntensity = 0.0;`;\n\n// AT: sample thickness + compute transmittance.\n// Channel: R by default (matches existing non-glTF path); G when the glTF\n// KHR_materials_volume flag is on (spec mandates G channel).\nfunction makeThicknessBlock(hasThicknessMap: boolean, useGltfChannel: boolean): string {\n    const chan = useGltfChannel ? \"g\" : \"r\";\n    const texSample = hasThicknessMap ? `let thicknessSample = textureSample(thicknessTexture_, thicknessSampler_, input.uv).${chan};` : `let thicknessSample = 1.0;`;\n    return `${texSample}\nlet ssThickness = max(material.subsurfaceParams.y + thicknessSample * material.subsurfaceParams.z, 0.000001);\nlet ssTranslucencyColor = material.subsurfaceParams3.rgb;\nlet ssDiffDist = material.subsurfaceParams2.rgb;\nssIntensity = material.subsurfaceParams.x;\nssTransmittance = transmittanceBRDF_Burley(ssTranslucencyColor, ssDiffDist, ssThickness) * ssIntensity;`;\n}\n\n// AD: direct-light translucency lobe (back-facing only, wrap 0.02, 1/PI diffuse BRDF).\n// BJS also scales the front-facing direct diffuse by (1 - ssIntensity); we cannot easily\n// modify `directDiffuse` at compute time, so compensate via `color -= directDiffuse * ssIntensity`\n// in the AI/NI slot below.\nconst SS_DIRECT = `{\nlet NdotLU = dot(N, L);\nif (NdotLU < 0.0) {\nlet wrapNdotL = computeWrappedDiffuseNdotL(abs(NdotLU), 0.02);\ntranslucencyDirect += (1.0 / PI) * wrapNdotL * ssTransmittance * lightAtten * lightColor * material.directIntensity;\n}\n}`;\n\n// AI: subsurface IBL modification (runs after IBL sets `color`).\n// BJS: finalIrradiance *= (1 - ssI);  finalIrradiance += refractionIrradiance;\n// where refractionIrradiance = environmentIrradiance(-N) * transmittance (no albedo by default).\n// AO/occlusion applies to the full finalIrradiance in BJS.\n// Also: scale direct diffuse by (1-ssI) and add translucencyDirect lobe.\nconst SS_IBL_MOD = `{\nlet N_back = -N_env;\nlet envIrrBack = (scene.vSphericalL00.rgb\n  + scene.vSphericalL1_1.rgb * N_back.y + scene.vSphericalL10.rgb * N_back.z + scene.vSphericalL11.rgb * N_back.x\n  + scene.vSphericalL2_2.rgb * (N_back.y * N_back.x) + scene.vSphericalL2_1.rgb * (N_back.y * N_back.z)\n  + scene.vSphericalL20.rgb * (3.0 * N_back.z * N_back.z - 1.0) + scene.vSphericalL21.rgb * (N_back.z * N_back.x)\n  + scene.vSphericalL22.rgb * (N_back.x * N_back.x - N_back.y * N_back.y)) * material.environmentIntensity;\nlet refractionIrradiance = envIrrBack * ssTransmittance;\ncolor -= finalIrradiance * ssIntensity;\ncolor += refractionIrradiance * occlusion;\ncolor -= directDiffuse * ssIntensity;\ncolor += translucencyDirect * occlusion;\n}`;\n\n// NI: no-IBL path — just scale direct diffuse and add translucency lobe.\nconst SS_NO_IBL_MOD = `color -= directDiffuse * ssIntensity;\ncolor += translucencyDirect;`;\n\nconst STAGE_FRAGMENT = 0x2;\n\n/**\n * Create a subsurface translucency fragment.\n * @param hasThicknessMap - Whether the material has a thickness texture.\n * @param hasIbl - Whether the scene has IBL.\n * @param useGltfThicknessChannel - Sample the thickness texture's G channel\n *        (KHR_materials_volume) instead of R (BJS default).\n */\nexport function createSubsurfaceFragment(hasThicknessMap: boolean, hasIbl: boolean, useGltfThicknessChannel: boolean): ShaderFragment {\n    const bindings = hasThicknessMap\n        ? [\n              { _name: \"thicknessTexture_\", _type: { _kind: \"texture\" as const, _textureType: \"texture_2d<f32>\" as const }, _visibility: STAGE_FRAGMENT },\n              { _name: \"thicknessSampler_\", _type: { _kind: \"sampler\" as const, _samplerType: \"sampler\" as const }, _visibility: STAGE_FRAGMENT },\n          ]\n        : [];\n\n    const slots: Partial<Record<string, string>> = {\n        SV: SS_SCOPE_VARS,\n        AT: makeThicknessBlock(hasThicknessMap, useGltfThicknessChannel),\n        AD: SS_DIRECT,\n    };\n    if (hasIbl) {\n        slots.AI = SS_IBL_MOD;\n    } else {\n        slots.NI = SS_NO_IBL_MOD;\n    }\n\n    const deps: string[] = [];\n    if (hasIbl) {\n        deps.push(\"ibl\");\n    }\n\n    return {\n        _id: \"subsurface\",\n        _dependencies: deps.length > 0 ? deps : undefined,\n        _bindings: bindings.length > 0 ? bindings : undefined,\n        _uboFields: [\n            { _name: \"subsurfaceParams\", _type: \"vec4<f32>\" as const },\n            { _name: \"subsurfaceParams2\", _type: \"vec4<f32>\" as const },\n            { _name: \"subsurfaceParams3\", _type: \"vec4<f32>\" as const },\n        ],\n        _helperFunctions: SS_HELPERS,\n        _fragmentSlots: slots,\n    };\n}\n\n/** Write subsurface UBO data. Called from pbr-renderable.ts only when subsurface is active. */\nexport function writeSubsurfaceUBO(data: Float32Array, ss: SubSurfaceProps, offsets: ReadonlyMap<string, number>): void {\n    const trans = ss.translucency!;\n    const thick = ss.thickness;\n\n    const off = offsets.get(\"subsurfaceParams\")! / 4;\n    data[off] = trans.intensity ?? 1.0;\n    const minThick = thick?.min ?? 0;\n    const maxThick = thick?.max ?? 1.0;\n    data[off + 1] = minThick;\n    data[off + 2] = maxThick - minThick;\n\n    const off2 = offsets.get(\"subsurfaceParams2\")! / 4;\n    const dd = trans.diffusionDistance ?? [1, 1, 1];\n    data[off2] = dd[0]!;\n    data[off2 + 1] = dd[1]!;\n    data[off2 + 2] = dd[2]!;\n\n    const off3 = offsets.get(\"subsurfaceParams3\")! / 4;\n    const tc = trans.color ?? [1, 1, 1];\n    data[off3] = tc[0]!;\n    data[off3 + 1] = tc[1]!;\n    data[off3 + 2] = tc[2]!;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"subsurface\",\n    phase: \"fragment\",\n    detect(mat) {\n        const m = mat as PbrMaterialProps;\n        if (!m.subsurface?.translucency) {\n            return { f: 0, f2: 0 };\n        }\n        let f = PBR_HAS_SUBSURFACE;\n        let f2 = 0;\n        if (m.subsurface.thickness?.texture) {\n            f |= PBR_HAS_THICKNESS_MAP;\n        }\n        if (m.subsurface.thickness?.useGlTFChannel) {\n            f2 |= PBR2_HAS_THICKNESS_GLTF_CHANNEL;\n        }\n        return { f, f2 };\n    },\n    frag(ctx) {\n        if (!(ctx._features & PBR_HAS_SUBSURFACE)) {\n            return null;\n        }\n        return createSubsurfaceFragment((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0, ctx._hasIbl, (ctx._features2 & PBR2_HAS_THICKNESS_GLTF_CHANNEL) !== 0);\n    },\n    writeUbo(data, mat, offsets) {\n        const m = mat as PbrMaterialProps;\n        if (m.subsurface?.translucency && offsets.has(\"subsurfaceParams\")) {\n            writeSubsurfaceUBO(data, m.subsurface as SubSurfaceProps, offsets);\n        }\n    },\n    bind(ctx, entries, b) {\n        if ((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0) {\n            const tex = (ctx._material as PbrMaterialProps).subsurface?.thickness?.texture as Texture2D | undefined;\n            if (tex) {\n                entries.push({ binding: b++, resource: tex.view });\n                entries.push({ binding: b++, resource: tex.sampler });\n            }\n        }\n        return b;\n    },\n    textures(mat, out) {\n        const t = (mat as PbrMaterialProps).subsurface?.thickness?.texture;\n        if (t) {\n            out.push(t);\n        }\n    },\n};\n"],"names":[],"mappings":"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"}

package/subtract-block-NPfKvzQP.js

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

package/subtract-block-NPfKvzQP.js.map

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

package/swapchain-overlay-DcCSFDp7.js

@@ -0,0 +1,35 @@
+function getDefaultSwapchainTask(scene) {
+  for (const task of scene._frameGraph._tasks) {
+    const ptask = task;
+    if (!(ptask == null ? void 0 : ptask._config) || !ptask._colorAttachment) {
+      continue;
+    }
+    const renderTask = task;
+    if (renderTask._config.rt._descriptor.resolveToSwapchain === true) {
+      return renderTask;
+    }
+  }
+  return null;
+}
+function configureSwapchainOverlayScene(engine, overlay) {
+  const base = engine._renderingContexts[engine._renderingContexts.length - 1];
+  if (!(base == null ? void 0 : base._frameGraph)) {
+    return;
+  }
+  const baseTask = getDefaultSwapchainTask(base);
+  const overlayTask = getDefaultSwapchainTask(overlay);
+  if (!baseTask || !overlayTask) {
+    return;
+  }
+  overlayTask._config.clr = false;
+  overlay._beforeRender.unshift(() => {
+    const view = baseTask._colorAttachment.view;
+    if (engine.msaaSamples > 1 && view) {
+      overlayTask._colorAttachment.view = view;
+    }
+  });
+}
+export {
+  configureSwapchainOverlayScene
+};
+//# sourceMappingURL=swapchain-overlay-DcCSFDp7.js.map

package/swapchain-overlay-DcCSFDp7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapchain-overlay-DcCSFDp7.js","sources":["../src/scene/swapchain-overlay.ts"],"sourcesContent":["import type { EngineContext } from \"../engine/engine.js\";\nimport type { RenderTask } from \"../frame-graph/render-task.js\";\nimport type { SceneContext } from \"./scene-core.js\";\n\nfunction getDefaultSwapchainTask(scene: SceneContext): RenderTask | null {\n    for (const task of scene._frameGraph._tasks) {\n        const ptask = task as Partial<RenderTask> | undefined;\n        if (!ptask?._config || !ptask._colorAttachment) {\n            continue;\n        }\n        const renderTask = task as RenderTask;\n        if (renderTask._config.rt._descriptor.resolveToSwapchain === true) {\n            return renderTask;\n        }\n    }\n    return null;\n}\n\n/** @internal Configure a later scene to preserve pixels already rendered into the same swapchain. */\nexport function configureSwapchainOverlayScene(engine: EngineContext, overlay: SceneContext): void {\n    const base = engine._renderingContexts[engine._renderingContexts.length - 1] as Partial<SceneContext> | undefined;\n    if (!base?._frameGraph) {\n        return;\n    }\n    const baseTask = getDefaultSwapchainTask(base as SceneContext);\n    const overlayTask = getDefaultSwapchainTask(overlay);\n    if (!baseTask || !overlayTask) {\n        return;\n    }\n\n    overlayTask._config.clr = false;\n    overlay._beforeRender.unshift(() => {\n        const view = baseTask._colorAttachment.view;\n        if (engine.msaaSamples > 1 && view) {\n            overlayTask._colorAttachment.view = view;\n        }\n    });\n}\n"],"names":[],"mappings":"AAIA,SAAS,wBAAwB,OAAwC;AACrE,aAAW,QAAQ,MAAM,YAAY,QAAQ;AACzC,UAAM,QAAQ;AACd,QAAI,EAAC,+BAAO,YAAW,CAAC,MAAM,kBAAkB;AAC5C;AAAA,IACJ;AACA,UAAM,aAAa;AACnB,QAAI,WAAW,QAAQ,GAAG,YAAY,uBAAuB,MAAM;AAC/D,aAAO;AAAA,IACX;AAAA,EACJ;AACA,SAAO;AACX;AAGO,SAAS,+BAA+B,QAAuB,SAA6B;AAC/F,QAAM,OAAO,OAAO,mBAAmB,OAAO,mBAAmB,SAAS,CAAC;AAC3E,MAAI,EAAC,6BAAM,cAAa;AACpB;AAAA,EACJ;AACA,QAAM,WAAW,wBAAwB,IAAoB;AAC7D,QAAM,cAAc,wBAAwB,OAAO;AACnD,MAAI,CAAC,YAAY,CAAC,aAAa;AAC3B;AAAA,EACJ;AAEA,cAAY,QAAQ,MAAM;AAC1B,UAAQ,cAAc,QAAQ,MAAM;AAChC,UAAM,OAAO,SAAS,iBAAiB;AACvC,QAAI,OAAO,cAAc,KAAK,MAAM;AAChC,kBAAY,iBAAiB,OAAO;AAAA,IACxC;AAAA,EACJ,CAAC;AACL;"}

package/tbn-block-ByOI6Y43.js

@@ -0,0 +1,43 @@
+function emitTbnRows(block, stage, state, ctx) {
+  const stageState = stage === "vertex" ? state.vertex : state.fragment;
+  const memoKey = `_tbn_${block.id}`;
+  const existing = stageState.memo.get(memoKey);
+  if (existing) {
+    return existing;
+  }
+  const normal = ctx.cast(ctx.resolve(block, "normal", stage, state), "vec3f").expr;
+  const tangent = ctx.cast(ctx.resolve(block, "tangent", stage, state), "vec4f").expr;
+  const world = ctx.cast(ctx.resolve(block, "world", stage, state), "mat4f").expr;
+  const prefix = `_tbn${ctx.temp(state, "tbn")}`;
+  stageState.body.push(`let ${prefix}_normal = normalize(${normal});`);
+  stageState.body.push(`let ${prefix}_tangent = normalize((${tangent}).xyz);`);
+  stageState.body.push(`let ${prefix}_bitangent = cross(${prefix}_normal, ${prefix}_tangent) * (${tangent}).w;`);
+  stageState.body.push(
+    `let ${prefix}_mat = mat3x3<f32>((${world})[0].xyz, (${world})[1].xyz, (${world})[2].xyz) * mat3x3<f32>(${prefix}_tangent, ${prefix}_bitangent, ${prefix}_normal);`
+  );
+  stageState.body.push(`let ${prefix}_rows = vec4<f32>(${prefix}_mat[0][0], ${prefix}_mat[1][1], ${prefix}_mat[2][2], 0.0);`);
+  const result = { expr: `${prefix}_rows`, type: "vec4f" };
+  stageState.memo.set(memoKey, result);
+  return result;
+}
+const emitter = {
+  className: "TBNBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    if (outputName === "TBN") {
+      throw new Error("NodeMaterial: TBNBlock object output is not supported; use row0/row1/row2 outputs");
+    }
+    const rows = emitTbnRows(block, stage, state, ctx).expr;
+    if (outputName === "row1") {
+      return { expr: `vec3<f32>(0.0, (${rows}).y, 0.0)`, type: "vec3f" };
+    }
+    if (outputName === "row2") {
+      return { expr: `vec3<f32>(0.0, 0.0, (${rows}).z)`, type: "vec3f" };
+    }
+    return { expr: `vec3<f32>((${rows}).x, 0.0, 0.0)`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=tbn-block-ByOI6Y43.js.map

package/tbn-block-ByOI6Y43.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tbn-block-ByOI6Y43.js","sources":["../src/material/node/blocks/tbn-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nfunction emitTbnRows(\n    block: Parameters<BlockEmitter[\"emit\"]>[0],\n    stage: Parameters<BlockEmitter[\"emit\"]>[2],\n    state: Parameters<BlockEmitter[\"emit\"]>[3],\n    ctx: Parameters<BlockEmitter[\"emit\"]>[4]\n): NodeExpr {\n    const stageState = stage === \"vertex\" ? state.vertex : state.fragment;\n    const memoKey = `_tbn_${block.id}`;\n    const existing = stageState.memo.get(memoKey);\n    if (existing) {\n        return existing;\n    }\n\n    const normal = ctx.cast(ctx.resolve(block, \"normal\", stage, state), \"vec3f\").expr;\n    const tangent = ctx.cast(ctx.resolve(block, \"tangent\", stage, state), \"vec4f\").expr;\n    const world = ctx.cast(ctx.resolve(block, \"world\", stage, state), \"mat4f\").expr;\n    const prefix = `_tbn${ctx.temp(state, \"tbn\")}`;\n    stageState.body.push(`let ${prefix}_normal = normalize(${normal});`);\n    stageState.body.push(`let ${prefix}_tangent = normalize((${tangent}).xyz);`);\n    stageState.body.push(`let ${prefix}_bitangent = cross(${prefix}_normal, ${prefix}_tangent) * (${tangent}).w;`);\n    stageState.body.push(\n        `let ${prefix}_mat = mat3x3<f32>((${world})[0].xyz, (${world})[1].xyz, (${world})[2].xyz) * mat3x3<f32>(${prefix}_tangent, ${prefix}_bitangent, ${prefix}_normal);`\n    );\n    stageState.body.push(`let ${prefix}_rows = vec4<f32>(${prefix}_mat[0][0], ${prefix}_mat[1][1], ${prefix}_mat[2][2], 0.0);`);\n    const result = { expr: `${prefix}_rows`, type: \"vec4f\" } as const;\n    stageState.memo.set(memoKey, result);\n    return result;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"TBNBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx) {\n        if (outputName === \"TBN\") {\n            throw new Error(\"NodeMaterial: TBNBlock object output is not supported; use row0/row1/row2 outputs\");\n        }\n        const rows = emitTbnRows(block, stage, state, ctx).expr;\n        if (outputName === \"row1\") {\n            return { expr: `vec3<f32>(0.0, (${rows}).y, 0.0)`, type: \"vec3f\" };\n        }\n        if (outputName === \"row2\") {\n            return { expr: `vec3<f32>(0.0, 0.0, (${rows}).z)`, type: \"vec3f\" };\n        }\n        return { expr: `vec3<f32>((${rows}).x, 0.0, 0.0)`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAEA,SAAS,YACL,OACA,OACA,OACA,KACQ;AACR,QAAM,aAAa,UAAU,WAAW,MAAM,SAAS,MAAM;AAC7D,QAAM,UAAU,QAAQ,MAAM,EAAE;AAChC,QAAM,WAAW,WAAW,KAAK,IAAI,OAAO;AAC5C,MAAI,UAAU;AACV,WAAO;AAAA,EACX;AAEA,QAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,GAAG,OAAO,EAAE;AAC7E,QAAM,UAAU,IAAI,KAAK,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK,GAAG,OAAO,EAAE;AAC/E,QAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,OAAO,EAAE;AAC3E,QAAM,SAAS,OAAO,IAAI,KAAK,OAAO,KAAK,CAAC;AAC5C,aAAW,KAAK,KAAK,OAAO,MAAM,uBAAuB,MAAM,IAAI;AACnE,aAAW,KAAK,KAAK,OAAO,MAAM,yBAAyB,OAAO,SAAS;AAC3E,aAAW,KAAK,KAAK,OAAO,MAAM,sBAAsB,MAAM,YAAY,MAAM,gBAAgB,OAAO,MAAM;AAC7G,aAAW,KAAK;AAAA,IACZ,OAAO,MAAM,uBAAuB,KAAK,cAAc,KAAK,cAAc,KAAK,2BAA2B,MAAM,aAAa,MAAM,eAAe,MAAM;AAAA,EAAA;AAE5J,aAAW,KAAK,KAAK,OAAO,MAAM,qBAAqB,MAAM,eAAe,MAAM,eAAe,MAAM,mBAAmB;AAC1H,QAAM,SAAS,EAAE,MAAM,GAAG,MAAM,SAAS,MAAM,QAAA;AAC/C,aAAW,KAAK,IAAI,SAAS,MAAM;AACnC,SAAO;AACX;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,QAAI,eAAe,OAAO;AACtB,YAAM,IAAI,MAAM,mFAAmF;AAAA,IACvG;AACA,UAAM,OAAO,YAAY,OAAO,OAAO,OAAO,GAAG,EAAE;AACnD,QAAI,eAAe,QAAQ;AACvB,aAAO,EAAE,MAAM,mBAAmB,IAAI,aAAa,MAAM,QAAA;AAAA,IAC7D;AACA,QAAI,eAAe,QAAQ;AACvB,aAAO,EAAE,MAAM,wBAAwB,IAAI,QAAQ,MAAM,QAAA;AAAA,IAC7D;AACA,WAAO,EAAE,MAAM,cAAc,IAAI,kBAAkB,MAAM,QAAA;AAAA,EAC7D;AACJ;"}

package/teleport-in-block-BMa17cqq.js

@@ -0,0 +1,10 @@
+const emitter = {
+  className: "NodeMaterialTeleportInBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    return ctx.resolve(block, "input", stage, state);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=teleport-in-block-BMa17cqq.js.map

package/teleport-in-block-BMa17cqq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"teleport-in-block-BMa17cqq.js","sources":["../src/material/node/blocks/teleport-in-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"NodeMaterialTeleportInBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        return ctx.resolve(block, \"input\", stage, state);\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,WAAO,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AAAA,EACnD;AACJ;"}

package/teleport-out-block-5AkB25H6.js

@@ -0,0 +1,19 @@
+const emitter = {
+  className: "NodeMaterialTeleportOutBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const entryPoint = block.serialized["entryPoint"];
+    const entryPointId = typeof entryPoint === "number" ? entryPoint : typeof entryPoint === "string" && entryPoint.length > 0 ? Number(entryPoint) : NaN;
+    if (!Number.isFinite(entryPointId)) {
+      throw new Error(`NodeMaterial: TeleportOutBlock (id=${block.id}) has no entryPoint`);
+    }
+    const entryBlock = ctx.graph.blocks.get(entryPointId);
+    if (!entryBlock || entryBlock.className !== "NodeMaterialTeleportInBlock") {
+      throw new Error(`NodeMaterial: TeleportOutBlock (id=${block.id}) points to missing TeleportInBlock ${entryPointId}`);
+    }
+    return ctx.resolve(entryBlock, "input", stage, state);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=teleport-out-block-5AkB25H6.js.map

package/teleport-out-block-5AkB25H6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"teleport-out-block-5AkB25H6.js","sources":["../src/material/node/blocks/teleport-out-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"NodeMaterialTeleportOutBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const entryPoint = block.serialized[\"entryPoint\"];\n        const entryPointId = typeof entryPoint === \"number\" ? entryPoint : typeof entryPoint === \"string\" && entryPoint.length > 0 ? Number(entryPoint) : NaN;\n        if (!Number.isFinite(entryPointId)) {\n            throw new Error(`NodeMaterial: TeleportOutBlock (id=${block.id}) has no entryPoint`);\n        }\n        const entryBlock = ctx.graph.blocks.get(entryPointId);\n        if (!entryBlock || entryBlock.className !== \"NodeMaterialTeleportInBlock\") {\n            throw new Error(`NodeMaterial: TeleportOutBlock (id=${block.id}) points to missing TeleportInBlock ${entryPointId}`);\n        }\n        return ctx.resolve(entryBlock, \"input\", stage, state);\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,aAAa,MAAM,WAAW,YAAY;AAChD,UAAM,eAAe,OAAO,eAAe,WAAW,aAAa,OAAO,eAAe,YAAY,WAAW,SAAS,IAAI,OAAO,UAAU,IAAI;AAClJ,QAAI,CAAC,OAAO,SAAS,YAAY,GAAG;AAChC,YAAM,IAAI,MAAM,sCAAsC,MAAM,EAAE,qBAAqB;AAAA,IACvF;AACA,UAAM,aAAa,IAAI,MAAM,OAAO,IAAI,YAAY;AACpD,QAAI,CAAC,cAAc,WAAW,cAAc,+BAA+B;AACvE,YAAM,IAAI,MAAM,sCAAsC,MAAM,EAAE,uCAAuC,YAAY,EAAE;AAAA,IACvH;AACA,WAAO,IAAI,QAAQ,YAAY,SAAS,OAAO,KAAK;AAAA,EACxD;AACJ;"}

package/texture-block-rr21KIL_.js

@@ -0,0 +1,70 @@
+const OUTPUT = {
+  rgba: { swizzle: "", type: "vec4f" },
+  rgb: { swizzle: ".xyz", type: "vec3f" },
+  r: { swizzle: ".x", type: "f32" },
+  g: { swizzle: ".y", type: "f32" },
+  b: { swizzle: ".z", type: "f32" },
+  a: { swizzle: ".w", type: "f32" }
+};
+function applyColorSpace(expr, outputName, convertToLinear, convertToGamma) {
+  if (!convertToLinear && !convertToGamma) {
+    return expr;
+  }
+  const power = convertToLinear ? "2.2" : "0.45454545";
+  if (outputName === "rgba") {
+    return `vec4<f32>(pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power})), ${expr}.w)`;
+  }
+  if (outputName === "rgb") {
+    return `pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power}))`;
+  }
+  if (outputName === "r" || outputName === "g" || outputName === "b") {
+    return `pow(max(${expr}${OUTPUT[outputName].swizzle}, 0.0), ${power})`;
+  }
+  return expr;
+}
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+const emitter = {
+  className: "TextureBlock",
+  emit(block, outputName, stage, state, ctx) {
+    let bindingName;
+    const source = block.inputs.get("source");
+    if (source == null ? void 0 : source.source) {
+      const producer = ctx.graph.blocks.get(source.source.blockId);
+      bindingName = sanitize((producer == null ? void 0 : producer.name) || `tex${block.id}`);
+    } else {
+      bindingName = sanitize(block.name || `tex${block.id}`);
+    }
+    if (!state.textures.find((t) => t.name === bindingName)) {
+      state.textures.push({ name: bindingName, kind: "texture2d", texture: null });
+    }
+    const uvInput = block.inputs.get("uv");
+    let uv;
+    if (uvInput == null ? void 0 : uvInput.source) {
+      uv = ctx.cast(ctx.resolve(block, "uv", stage, state), "vec2f");
+    } else {
+      uv = { expr: "vec2<f32>(0.0, 0.0)", type: "vec2f" };
+    }
+    const memoKey = `_tex_${block.id}_sample`;
+    const stageState = stage === "vertex" ? state.vertex : state.fragment;
+    let sampleExpr = stageState.memo.get(memoKey);
+    if (!sampleExpr) {
+      const sampleVar = `_s${ctx.temp(state, "tex")}`;
+      stageState.body.push(`let ${sampleVar} = textureSample(nodeTex_${bindingName}, nodeSamp_${bindingName}, ${uv.expr});`);
+      sampleExpr = { expr: sampleVar, type: "vec4f" };
+      stageState.memo.set(memoKey, sampleExpr);
+    }
+    if (outputName === "level") {
+      return { expr: "0.0", type: "f32" };
+    }
+    const out = OUTPUT[outputName] ?? OUTPUT.rgba;
+    const serialized = block.serialized;
+    const expr = applyColorSpace(sampleExpr.expr, outputName, serialized.convertToLinearSpace === true, serialized.convertToGammaSpace === true);
+    return { expr: expr === sampleExpr.expr ? `${sampleExpr.expr}${out.swizzle}` : expr, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=texture-block-rr21KIL_.js.map

package/texture-block-rr21KIL_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture-block-rr21KIL_.js","sources":["../src/material/node/blocks/texture-block.ts"],"sourcesContent":["/** TextureBlock — samples a 2D texture.\n *\n *  Inputs:\n *    - `uv`: vec2 texture coordinates.\n *    - `source` (optional): ImageSourceBlock.output that names the binding. When\n *      absent, this block owns its own binding named after itself.\n *  Outputs: `rgba`, `rgb`, `r`, `g`, `b`, `a`, `level`.\n */\n\nimport type { BlockEmitter, NodeExpr, NodeValueType } from \"../node-types.js\";\n\nconst OUTPUT: Record<string, { swizzle: string; type: NodeValueType }> = {\n    rgba: { swizzle: \"\", type: \"vec4f\" },\n    rgb: { swizzle: \".xyz\", type: \"vec3f\" },\n    r: { swizzle: \".x\", type: \"f32\" },\n    g: { swizzle: \".y\", type: \"f32\" },\n    b: { swizzle: \".z\", type: \"f32\" },\n    a: { swizzle: \".w\", type: \"f32\" },\n};\n\nfunction applyColorSpace(expr: string, outputName: string, convertToLinear: boolean, convertToGamma: boolean): string {\n    if (!convertToLinear && !convertToGamma) {\n        return expr;\n    }\n    const power = convertToLinear ? \"2.2\" : \"0.45454545\";\n    if (outputName === \"rgba\") {\n        return `vec4<f32>(pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power})), ${expr}.w)`;\n    }\n    if (outputName === \"rgb\") {\n        return `pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power}))`;\n    }\n    if (outputName === \"r\" || outputName === \"g\" || outputName === \"b\") {\n        return `pow(max(${expr}${OUTPUT[outputName]!.swizzle}, 0.0), ${power})`;\n    }\n    return expr;\n}\n\nfunction sanitize(name: string): string {\n    return name.replace(/[^A-Za-z0-9_]/g, \"_\");\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"TextureBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        // Resolve source binding: if `source` input is connected, use that producer's name;\n        // otherwise name the binding after this block.\n        let bindingName: string;\n        const source = block.inputs.get(\"source\");\n        if (source?.source) {\n            const producer = ctx.graph.blocks.get(source.source.blockId);\n            bindingName = sanitize(producer?.name || `tex${block.id}`);\n        } else {\n            bindingName = sanitize(block.name || `tex${block.id}`);\n        }\n\n        // Dedup binding.\n        if (!state.textures.find((t) => t.name === bindingName)) {\n            state.textures.push({ name: bindingName, kind: \"texture2d\", texture: null });\n        }\n\n        // Resolve UV.\n        const uvInput = block.inputs.get(\"uv\");\n        let uv: NodeExpr;\n        if (uvInput?.source) {\n            uv = ctx.cast(ctx.resolve(block, \"uv\", stage, state), \"vec2f\");\n        } else {\n            // Fallback: a zero UV so shader still compiles (matches BJS behaviour when unhooked).\n            uv = { expr: \"vec2<f32>(0.0, 0.0)\", type: \"vec2f\" };\n        }\n\n        // Memoize the full sample per-stage so rgba/rgb/r/... share one textureSample call.\n        const memoKey = `_tex_${block.id}_sample`;\n        const stageState = stage === \"vertex\" ? state.vertex : state.fragment;\n        let sampleExpr = stageState.memo.get(memoKey);\n        if (!sampleExpr) {\n            const sampleVar = `_s${ctx.temp(state, \"tex\")}`;\n            stageState.body.push(`let ${sampleVar} = textureSample(nodeTex_${bindingName}, nodeSamp_${bindingName}, ${uv.expr});`);\n            sampleExpr = { expr: sampleVar, type: \"vec4f\" };\n            stageState.memo.set(memoKey, sampleExpr);\n        }\n\n        // Special case: `level` output returns a pseudo-f32 (0.0 for now — proper LOD calc TBD).\n        if (outputName === \"level\") {\n            return { expr: \"0.0\", type: \"f32\" };\n        }\n\n        const out = OUTPUT[outputName] ?? OUTPUT.rgba!;\n        const serialized = block.serialized as { convertToLinearSpace?: boolean; convertToGammaSpace?: boolean };\n        const expr = applyColorSpace(sampleExpr.expr, outputName, serialized.convertToLinearSpace === true, serialized.convertToGammaSpace === true);\n        return { expr: expr === sampleExpr.expr ? `${sampleExpr.expr}${out.swizzle}` : expr, type: out.type };\n    },\n};\n"],"names":[],"mappings":"AAWA,MAAM,SAAmE;AAAA,EACrE,MAAM,EAAE,SAAS,IAAI,MAAM,QAAA;AAAA,EAC3B,KAAK,EAAE,SAAS,QAAQ,MAAM,QAAA;AAAA,EAC9B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAC9B;AAEA,SAAS,gBAAgB,MAAc,YAAoB,iBAA0B,gBAAiC;AAClH,MAAI,CAAC,mBAAmB,CAAC,gBAAgB;AACrC,WAAO;AAAA,EACX;AACA,QAAM,QAAQ,kBAAkB,QAAQ;AACxC,MAAI,eAAe,QAAQ;AACvB,WAAO,qBAAqB,IAAI,oCAAoC,KAAK,OAAO,IAAI;AAAA,EACxF;AACA,MAAI,eAAe,OAAO;AACtB,WAAO,WAAW,IAAI,oCAAoC,KAAK;AAAA,EACnE;AACA,MAAI,eAAe,OAAO,eAAe,OAAO,eAAe,KAAK;AAChE,WAAO,WAAW,IAAI,GAAG,OAAO,UAAU,EAAG,OAAO,WAAW,KAAK;AAAA,EACxE;AACA,SAAO;AACX;AAEA,SAAS,SAAS,MAAsB;AACpC,SAAO,KAAK,QAAQ,kBAAkB,GAAG;AAC7C;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AAGvC,QAAI;AACJ,UAAM,SAAS,MAAM,OAAO,IAAI,QAAQ;AACxC,QAAI,iCAAQ,QAAQ;AAChB,YAAM,WAAW,IAAI,MAAM,OAAO,IAAI,OAAO,OAAO,OAAO;AAC3D,oBAAc,UAAS,qCAAU,SAAQ,MAAM,MAAM,EAAE,EAAE;AAAA,IAC7D,OAAO;AACH,oBAAc,SAAS,MAAM,QAAQ,MAAM,MAAM,EAAE,EAAE;AAAA,IACzD;AAGA,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;AAGA,UAAM,UAAU,MAAM,OAAO,IAAI,IAAI;AACrC,QAAI;AACJ,QAAI,mCAAS,QAAQ;AACjB,WAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,MAAM,OAAO,KAAK,GAAG,OAAO;AAAA,IACjE,OAAO;AAEH,WAAK,EAAE,MAAM,uBAAuB,MAAM,QAAA;AAAA,IAC9C;AAGA,UAAM,UAAU,QAAQ,MAAM,EAAE;AAChC,UAAM,aAAa,UAAU,WAAW,MAAM,SAAS,MAAM;AAC7D,QAAI,aAAa,WAAW,KAAK,IAAI,OAAO;AAC5C,QAAI,CAAC,YAAY;AACb,YAAM,YAAY,KAAK,IAAI,KAAK,OAAO,KAAK,CAAC;AAC7C,iBAAW,KAAK,KAAK,OAAO,SAAS,4BAA4B,WAAW,cAAc,WAAW,KAAK,GAAG,IAAI,IAAI;AACrH,mBAAa,EAAE,MAAM,WAAW,MAAM,QAAA;AACtC,iBAAW,KAAK,IAAI,SAAS,UAAU;AAAA,IAC3C;AAGA,QAAI,eAAe,SAAS;AACxB,aAAO,EAAE,MAAM,OAAO,MAAM,MAAA;AAAA,IAChC;AAEA,UAAM,MAAM,OAAO,UAAU,KAAK,OAAO;AACzC,UAAM,aAAa,MAAM;AACzB,UAAM,OAAO,gBAAgB,WAAW,MAAM,YAAY,WAAW,yBAAyB,MAAM,WAAW,wBAAwB,IAAI;AAC3I,WAAO,EAAE,MAAM,SAAS,WAAW,OAAO,GAAG,WAAW,IAAI,GAAG,IAAI,OAAO,KAAK,MAAM,MAAM,IAAI,KAAA;AAAA,EACnG;AACJ;"}

package/thin-instance-fragment-hsv-RyDs.js

@@ -0,0 +1,69 @@
+function createThinInstanceFragment(hasInstanceColor) {
+  const attrs = [
+    {
+      _name: "world0",
+      _type: "vec4<f32>",
+      _gpuFormat: "float32x4",
+      _arrayStride: 64,
+      _stepMode: "instance",
+      _bufferGroup: "ti-matrix",
+      _offset: 0
+    },
+    {
+      _name: "world1",
+      _type: "vec4<f32>",
+      _gpuFormat: "float32x4",
+      _arrayStride: 64,
+      _stepMode: "instance",
+      _bufferGroup: "ti-matrix",
+      _offset: 16
+    },
+    {
+      _name: "world2",
+      _type: "vec4<f32>",
+      _gpuFormat: "float32x4",
+      _arrayStride: 64,
+      _stepMode: "instance",
+      _bufferGroup: "ti-matrix",
+      _offset: 32
+    },
+    {
+      _name: "world3",
+      _type: "vec4<f32>",
+      _gpuFormat: "float32x4",
+      _arrayStride: 64,
+      _stepMode: "instance",
+      _bufferGroup: "ti-matrix",
+      _offset: 48
+    }
+  ];
+  if (hasInstanceColor) {
+    attrs.push({
+      _name: "instanceColor",
+      _type: "vec4<f32>",
+      _gpuFormat: "float32x4",
+      _arrayStride: 16,
+      _stepMode: "instance",
+      _bufferGroup: "ti-color",
+      _offset: 0
+    });
+  }
+  return {
+    _id: "thin-instance",
+    _vertexAttributes: attrs,
+    _varyings: hasInstanceColor ? [{ _name: "vInstanceColor", _type: "vec4<f32>" }] : [],
+    _vertexSlots: {
+      VW: `let instanceWorld = mat4x4<f32>(world0, world1, world2, world3);
+finalWorld = mesh.world * instanceWorld;`,
+      VB: hasInstanceColor ? `out.vInstanceColor = instanceColor;` : ""
+    },
+    _fragmentSlots: hasInstanceColor ? {
+      AT: `baseColor *= input.vInstanceColor.rgb;
+alpha *= input.vInstanceColor.a;`
+    } : {}
+  };
+}
+export {
+  createThinInstanceFragment
+};
+//# sourceMappingURL=thin-instance-fragment-hsv-RyDs.js.map

package/thin-instance-fragment-hsv-RyDs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thin-instance-fragment-hsv-RyDs.js","sources":["../src/shader/fragments/thin-instance-fragment.ts"],"sourcesContent":["/**\n * Thin Instance Fragment\n *\n * Shared between PBR and Standard materials.\n * Replaces the regex-based string surgery in pbr-thin-instance-ext.ts\n * with clean declarative vertex attributes and slot injection.\n *\n * Zero bytes in bundles for scenes that don't use thin instances.\n */\n\nimport type { ShaderFragment } from \"../fragment-types.js\";\n\n/**\n * Create a thin-instance fragment.\n * @param hasInstanceColor - Whether meshes have per-instance color data.\n */\nexport function createThinInstanceFragment(hasInstanceColor: boolean): ShaderFragment {\n    const attrs = [\n        {\n            _name: \"world0\",\n            _type: \"vec4<f32>\",\n            _gpuFormat: \"float32x4\" as GPUVertexFormat,\n            _arrayStride: 64,\n            _stepMode: \"instance\" as GPUVertexStepMode,\n            _bufferGroup: \"ti-matrix\",\n            _offset: 0,\n        },\n        {\n            _name: \"world1\",\n            _type: \"vec4<f32>\",\n            _gpuFormat: \"float32x4\" as GPUVertexFormat,\n            _arrayStride: 64,\n            _stepMode: \"instance\" as GPUVertexStepMode,\n            _bufferGroup: \"ti-matrix\",\n            _offset: 16,\n        },\n        {\n            _name: \"world2\",\n            _type: \"vec4<f32>\",\n            _gpuFormat: \"float32x4\" as GPUVertexFormat,\n            _arrayStride: 64,\n            _stepMode: \"instance\" as GPUVertexStepMode,\n            _bufferGroup: \"ti-matrix\",\n            _offset: 32,\n        },\n        {\n            _name: \"world3\",\n            _type: \"vec4<f32>\",\n            _gpuFormat: \"float32x4\" as GPUVertexFormat,\n            _arrayStride: 64,\n            _stepMode: \"instance\" as GPUVertexStepMode,\n            _bufferGroup: \"ti-matrix\",\n            _offset: 48,\n        },\n    ];\n\n    if (hasInstanceColor) {\n        attrs.push({\n            _name: \"instanceColor\",\n            _type: \"vec4<f32>\",\n            _gpuFormat: \"float32x4\" as GPUVertexFormat,\n            _arrayStride: 16,\n            _stepMode: \"instance\" as GPUVertexStepMode,\n            _bufferGroup: \"ti-color\",\n            _offset: 0,\n        });\n    }\n\n    return {\n        _id: \"thin-instance\",\n\n        _vertexAttributes: attrs,\n\n        _varyings: hasInstanceColor ? [{ _name: \"vInstanceColor\", _type: \"vec4<f32>\" }] : [],\n\n        _vertexSlots: {\n            VW: `let instanceWorld = mat4x4<f32>(world0, world1, world2, world3);\\nfinalWorld = mesh.world * instanceWorld;`,\n            VB: hasInstanceColor ? `out.vInstanceColor = instanceColor;` : \"\",\n        },\n\n        _fragmentSlots: hasInstanceColor\n            ? {\n                  AT: `baseColor *= input.vInstanceColor.rgb;\\nalpha *= input.vInstanceColor.a;`,\n              }\n            : {},\n    };\n}\n"],"names":[],"mappings":"AAgBO,SAAS,2BAA2B,kBAA2C;AAClF,QAAM,QAAQ;AAAA,IACV;AAAA,MACI,OAAO;AAAA,MACP,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,WAAW;AAAA,MACX,cAAc;AAAA,MACd,SAAS;AAAA,IAAA;AAAA,IAEb;AAAA,MACI,OAAO;AAAA,MACP,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,WAAW;AAAA,MACX,cAAc;AAAA,MACd,SAAS;AAAA,IAAA;AAAA,IAEb;AAAA,MACI,OAAO;AAAA,MACP,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,WAAW;AAAA,MACX,cAAc;AAAA,MACd,SAAS;AAAA,IAAA;AAAA,IAEb;AAAA,MACI,OAAO;AAAA,MACP,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,WAAW;AAAA,MACX,cAAc;AAAA,MACd,SAAS;AAAA,IAAA;AAAA,EACb;AAGJ,MAAI,kBAAkB;AAClB,UAAM,KAAK;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,WAAW;AAAA,MACX,cAAc;AAAA,MACd,SAAS;AAAA,IAAA,CACZ;AAAA,EACL;AAEA,SAAO;AAAA,IACH,KAAK;AAAA,IAEL,mBAAmB;AAAA,IAEnB,WAAW,mBAAmB,CAAC,EAAE,OAAO,kBAAkB,OAAO,YAAA,CAAa,IAAI,CAAA;AAAA,IAElF,cAAc;AAAA,MACV,IAAI;AAAA;AAAA,MACJ,IAAI,mBAAmB,wCAAwC;AAAA,IAAA;AAAA,IAGnE,gBAAgB,mBACV;AAAA,MACI,IAAI;AAAA;AAAA,IAAA,IAER,CAAA;AAAA,EAAC;AAEf;"}

package/thin-instance-gpu-C9Gv_Z1w.js

@@ -0,0 +1,62 @@
+function syncThinInstanceGpuData(engine, ti, hasColor) {
+  var _a, _b;
+  const device = engine._device;
+  const needsStorage = ti._gpuCullingEnabled;
+  if (ti._version !== ti._gpuVersion || ti._gpuBufferStorage !== needsStorage) {
+    const byteSize = ti.count * 64;
+    let bufferRecreated = false;
+    if (!ti._gpuBuffer || ti._gpuBuffer.size < byteSize || ti._gpuBufferStorage !== needsStorage) {
+      (_a = ti._gpuBuffer) == null ? void 0 : _a.destroy();
+      ti._gpuBuffer = device.createBuffer({
+        size: Math.max(ti._capacity * 64, 4),
+        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | (needsStorage ? GPUBufferUsage.STORAGE : 0)
+      });
+      ti._gpuBufferStorage = needsStorage;
+      bufferRecreated = true;
+    }
+    const dirtyMin = bufferRecreated ? 0 : ti._dirtyMin;
+    const dirtyMax = bufferRecreated ? ti.count : Math.min(ti._dirtyMax, ti.count);
+    if (dirtyMax > dirtyMin) {
+      const minByte = dirtyMin * 64;
+      const maxByte = dirtyMax * 64;
+      device.queue.writeBuffer(ti._gpuBuffer, minByte, ti.matrices.buffer, ti.matrices.byteOffset + minByte, maxByte - minByte);
+    }
+    ti._dirtyMin = ti.count;
+    ti._dirtyMax = 0;
+    ti._gpuVersion = ti._version;
+  }
+  if (hasColor && ti.colors) {
+    if (ti._colorVersion !== ti._colorGpuVersion || ti._colorGpuBufferStorage !== needsStorage) {
+      const colorByteSize = ti.count * 16;
+      if (!ti._colorGpuBuffer || ti._colorGpuBuffer.size < colorByteSize || ti._colorGpuBufferStorage !== needsStorage) {
+        (_b = ti._colorGpuBuffer) == null ? void 0 : _b.destroy();
+        ti._colorGpuBuffer = device.createBuffer({
+          size: Math.max(ti._capacity * 16, 4),
+          usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | (needsStorage ? GPUBufferUsage.STORAGE : 0)
+        });
+        ti._colorGpuBufferStorage = needsStorage;
+      }
+      device.queue.writeBuffer(ti._colorGpuBuffer, 0, ti.colors.buffer, ti.colors.byteOffset, colorByteSize);
+      ti._colorGpuVersion = ti._colorVersion;
+    }
+  }
+}
+function syncThinInstanceBuffers(engine, ti, pass, slot, hasColor, drawBuffers) {
+  syncThinInstanceGpuData(engine, ti, hasColor);
+  const matrixBuffer = (drawBuffers == null ? void 0 : drawBuffers.matrixBuffer) ?? ti._gpuBuffer;
+  if (matrixBuffer) {
+    pass.setVertexBuffer(slot++, matrixBuffer);
+  }
+  if (hasColor) {
+    const colorBuffer = (drawBuffers == null ? void 0 : drawBuffers.colorBuffer) ?? ti._colorGpuBuffer;
+    if (colorBuffer) {
+      pass.setVertexBuffer(slot++, colorBuffer);
+    }
+  }
+  return slot;
+}
+export {
+  syncThinInstanceBuffers,
+  syncThinInstanceGpuData
+};
+//# sourceMappingURL=thin-instance-gpu-C9Gv_Z1w.js.map

package/thin-instance-gpu-C9Gv_Z1w.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thin-instance-gpu-C9Gv_Z1w.js","sources":["../src/mesh/thin-instance-gpu.ts"],"sourcesContent":["/** Thin instance GPU buffer sync — dynamically loaded only by scenes with thin instances.\n *  Keeps the standard renderable chunk unchanged for scenes without thin instances. */\n\nimport type { ThinInstanceData } from \"./thin-instance.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\n\n/** @internal Optional replacement buffers used by GPU culling after it compacts visible instances. */\nexport interface ThinInstanceDrawBuffers {\n    readonly matrixBuffer: GPUBuffer;\n    readonly colorBuffer: GPUBuffer | null;\n}\n\n/** @internal Sync CPU thin-instance data to GPU buffers, optionally with STORAGE usage for compute culling. */\nexport function syncThinInstanceGpuData(engine: EngineContext, ti: ThinInstanceData, hasColor: boolean): void {\n    const device = engine._device;\n    const needsStorage = ti._gpuCullingEnabled;\n    if (ti._version !== ti._gpuVersion || ti._gpuBufferStorage !== needsStorage) {\n        const byteSize = ti.count * 64;\n        let bufferRecreated = false;\n        if (!ti._gpuBuffer || ti._gpuBuffer.size < byteSize || ti._gpuBufferStorage !== needsStorage) {\n            ti._gpuBuffer?.destroy();\n            ti._gpuBuffer = device.createBuffer({\n                size: Math.max(ti._capacity * 64, 4),\n                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | (needsStorage ? GPUBufferUsage.STORAGE : 0),\n            });\n            ti._gpuBufferStorage = needsStorage;\n            bufferRecreated = true;\n        }\n        // Upload only the dirty range (or full range if buffer was just created)\n        const dirtyMin = bufferRecreated ? 0 : ti._dirtyMin;\n        const dirtyMax = bufferRecreated ? ti.count : Math.min(ti._dirtyMax, ti.count);\n        if (dirtyMax > dirtyMin) {\n            const minByte = dirtyMin * 64;\n            const maxByte = dirtyMax * 64;\n            device.queue.writeBuffer(ti._gpuBuffer, minByte, ti.matrices.buffer, ti.matrices.byteOffset + minByte, maxByte - minByte);\n        }\n        ti._dirtyMin = ti.count;\n        ti._dirtyMax = 0;\n        ti._gpuVersion = ti._version;\n    }\n\n    if (hasColor && ti.colors) {\n        if (ti._colorVersion !== ti._colorGpuVersion || ti._colorGpuBufferStorage !== needsStorage) {\n            const colorByteSize = ti.count * 16;\n            if (!ti._colorGpuBuffer || ti._colorGpuBuffer.size < colorByteSize || ti._colorGpuBufferStorage !== needsStorage) {\n                ti._colorGpuBuffer?.destroy();\n                ti._colorGpuBuffer = device.createBuffer({\n                    size: Math.max(ti._capacity * 16, 4),\n                    usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | (needsStorage ? GPUBufferUsage.STORAGE : 0),\n                });\n                ti._colorGpuBufferStorage = needsStorage;\n            }\n            device.queue.writeBuffer(ti._colorGpuBuffer, 0, ti.colors.buffer, ti.colors.byteOffset, colorByteSize);\n            ti._colorGpuVersion = ti._colorVersion;\n        }\n    }\n}\n\n/** Sync thin instance matrix + optional color GPU buffers and bind to vertex slots. */\nexport function syncThinInstanceBuffers(\n    engine: EngineContext,\n    ti: ThinInstanceData,\n    pass: GPURenderPassEncoder | GPURenderBundleEncoder,\n    slot: number,\n    hasColor: boolean,\n    drawBuffers?: ThinInstanceDrawBuffers | null\n): number {\n    syncThinInstanceGpuData(engine, ti, hasColor);\n    const matrixBuffer = drawBuffers?.matrixBuffer ?? ti._gpuBuffer;\n    if (matrixBuffer) {\n        pass.setVertexBuffer(slot++, matrixBuffer);\n    }\n\n    if (hasColor) {\n        const colorBuffer = drawBuffers?.colorBuffer ?? ti._colorGpuBuffer;\n        if (colorBuffer) {\n            pass.setVertexBuffer(slot++, colorBuffer);\n        }\n    }\n\n    return slot;\n}\n"],"names":[],"mappings":"AAaO,SAAS,wBAAwB,QAAuB,IAAsB,UAAyB;AAAvG;AACH,QAAM,SAAS,OAAO;AACtB,QAAM,eAAe,GAAG;AACxB,MAAI,GAAG,aAAa,GAAG,eAAe,GAAG,sBAAsB,cAAc;AACzE,UAAM,WAAW,GAAG,QAAQ;AAC5B,QAAI,kBAAkB;AACtB,QAAI,CAAC,GAAG,cAAc,GAAG,WAAW,OAAO,YAAY,GAAG,sBAAsB,cAAc;AAC1F,eAAG,eAAH,mBAAe;AACf,SAAG,aAAa,OAAO,aAAa;AAAA,QAChC,MAAM,KAAK,IAAI,GAAG,YAAY,IAAI,CAAC;AAAA,QACnC,OAAO,eAAe,SAAS,eAAe,YAAY,eAAe,eAAe,UAAU;AAAA,MAAA,CACrG;AACD,SAAG,oBAAoB;AACvB,wBAAkB;AAAA,IACtB;AAEA,UAAM,WAAW,kBAAkB,IAAI,GAAG;AAC1C,UAAM,WAAW,kBAAkB,GAAG,QAAQ,KAAK,IAAI,GAAG,WAAW,GAAG,KAAK;AAC7E,QAAI,WAAW,UAAU;AACrB,YAAM,UAAU,WAAW;AAC3B,YAAM,UAAU,WAAW;AAC3B,aAAO,MAAM,YAAY,GAAG,YAAY,SAAS,GAAG,SAAS,QAAQ,GAAG,SAAS,aAAa,SAAS,UAAU,OAAO;AAAA,IAC5H;AACA,OAAG,YAAY,GAAG;AAClB,OAAG,YAAY;AACf,OAAG,cAAc,GAAG;AAAA,EACxB;AAEA,MAAI,YAAY,GAAG,QAAQ;AACvB,QAAI,GAAG,kBAAkB,GAAG,oBAAoB,GAAG,2BAA2B,cAAc;AACxF,YAAM,gBAAgB,GAAG,QAAQ;AACjC,UAAI,CAAC,GAAG,mBAAmB,GAAG,gBAAgB,OAAO,iBAAiB,GAAG,2BAA2B,cAAc;AAC9G,iBAAG,oBAAH,mBAAoB;AACpB,WAAG,kBAAkB,OAAO,aAAa;AAAA,UACrC,MAAM,KAAK,IAAI,GAAG,YAAY,IAAI,CAAC;AAAA,UACnC,OAAO,eAAe,SAAS,eAAe,YAAY,eAAe,eAAe,UAAU;AAAA,QAAA,CACrG;AACD,WAAG,yBAAyB;AAAA,MAChC;AACA,aAAO,MAAM,YAAY,GAAG,iBAAiB,GAAG,GAAG,OAAO,QAAQ,GAAG,OAAO,YAAY,aAAa;AACrG,SAAG,mBAAmB,GAAG;AAAA,IAC7B;AAAA,EACJ;AACJ;AAGO,SAAS,wBACZ,QACA,IACA,MACA,MACA,UACA,aACM;AACN,0BAAwB,QAAQ,IAAI,QAAQ;AAC5C,QAAM,gBAAe,2CAAa,iBAAgB,GAAG;AACrD,MAAI,cAAc;AACd,SAAK,gBAAgB,QAAQ,YAAY;AAAA,EAC7C;AAEA,MAAI,UAAU;AACV,UAAM,eAAc,2CAAa,gBAAe,GAAG;AACnD,QAAI,aAAa;AACb,WAAK,gBAAgB,QAAQ,WAAW;AAAA,IAC5C;AAAA,EACJ;AAEA,SAAO;AACX;"}