@babylonjs/lite 0.1.1

package/singlelight-spot-wgsl-DEEUrfVM.js

@@ -0,0 +1,47 @@
+import { M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+const SINGLE_LIGHT_STRUCTS = `
+struct LightEntry {
+vLightData: vec4<f32>,
+vLightDiffuse: vec4<f32>,
+vLightSpecular: vec4<f32>,
+vLightDirection: vec4<f32>,
+};
+struct lightsUniforms {
+count: u32, _p0: u32, _p1: u32, _p2: u32,
+    lights: array<LightEntry, ${MAX_LIGHTS}>,
+};
+`;
+function specularBlock() {
+  return `let H = normalize(V + L);
+let NdotH = clamp(dot(N, H), 0.0000001, 1.0);
+let VdotH = saturate(dot(V, H));
+let directRoughness = max(roughness, AA_factor_x);
+let directAlphaG = directRoughness * directRoughness + 0.0005;
+let D = distributionGGX(NdotH, directAlphaG);
+let G = geometrySmithGGX(NdotL, NdotV, directAlphaG);
+let coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);
+var directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;
+}
+function getSingleLightBlock() {
+  return `let entry = lights.lights[mli(0u)];
+let lightToFrag = entry.vLightData.xyz - input.worldPos;
+let lightDist = length(lightToFrag);
+let L = lightToFrag / max(lightDist, 0.0001);
+let NdotL = max(dot(N, L), 0.0);
+let spotC = dot(entry.vLightDirection.xyz, -L);
+let physicalFalloff = material.lightFalloffMode >= 0.5;
+let rangeAtt = select(max(0.0, 1.0 - lightDist / entry.vLightDiffuse.a), 1.0 / max(dot(lightToFrag, lightToFrag), 0.0000001), physicalFalloff);
+let standardDirFalloff = select(0.0, max(0.0, pow(max(spotC, 0.0), entry.vLightSpecular.a)), spotC >= entry.vLightDirection.w);
+let kappa = 6.64385618977 / max(1.0 - entry.vLightDirection.w, 0.0001);
+let physicalDirFalloff = exp2(kappa * (spotC - 1.0));
+let lightAtten = rangeAtt * select(standardDirFalloff, physicalDirFalloff, physicalFalloff);
+let lightColor = entry.vLightDiffuse.rgb;
+var directDiffuse = surfaceAlbedo * (1.0 / PI) * NdotL * lightColor * lightAtten * material.directIntensity;
+${specularBlock()}
+/*AD*/`;
+}
+export {
+  SINGLE_LIGHT_STRUCTS,
+  getSingleLightBlock
+};
+//# sourceMappingURL=singlelight-spot-wgsl-DEEUrfVM.js.map

package/singlelight-spot-wgsl-DEEUrfVM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singlelight-spot-wgsl-DEEUrfVM.js","sources":["../src/material/pbr/fragments/singlelight-spot-wgsl.ts"],"sourcesContent":["/** Single spot-light WGSL helpers for the PBR template. */\n\nimport { MAX_LIGHTS } from \"../../../light/types.js\";\n\nexport const SINGLE_LIGHT_STRUCTS = `\nstruct LightEntry {\nvLightData: vec4<f32>,\nvLightDiffuse: vec4<f32>,\nvLightSpecular: vec4<f32>,\nvLightDirection: vec4<f32>,\n};\nstruct lightsUniforms {\ncount: u32, _p0: u32, _p1: u32, _p2: u32,\n    lights: array<LightEntry, ${MAX_LIGHTS}>,\n};\n`;\n\nfunction specularBlock(): string {\n    return `let H = normalize(V + L);\nlet NdotH = clamp(dot(N, H), 0.0000001, 1.0);\nlet VdotH = saturate(dot(V, H));\nlet directRoughness = max(roughness, AA_factor_x);\nlet directAlphaG = directRoughness * directRoughness + 0.0005;\nlet D = distributionGGX(NdotH, directAlphaG);\nlet G = geometrySmithGGX(NdotL, NdotV, directAlphaG);\nlet coloredFresnel = fresnelSchlick(VdotH, colorF0, colorF90);\nvar directSpecular = coloredFresnel * D * G * NdotL * lightColor * lightAtten * material.directIntensity;`;\n}\n\nexport function getSingleLightBlock(): string {\n    return `let entry = lights.lights[mli(0u)];\nlet lightToFrag = entry.vLightData.xyz - input.worldPos;\nlet lightDist = length(lightToFrag);\nlet L = lightToFrag / max(lightDist, 0.0001);\nlet NdotL = max(dot(N, L), 0.0);\nlet spotC = dot(entry.vLightDirection.xyz, -L);\nlet physicalFalloff = material.lightFalloffMode >= 0.5;\nlet rangeAtt = select(max(0.0, 1.0 - lightDist / entry.vLightDiffuse.a), 1.0 / max(dot(lightToFrag, lightToFrag), 0.0000001), physicalFalloff);\nlet standardDirFalloff = select(0.0, max(0.0, pow(max(spotC, 0.0), entry.vLightSpecular.a)), spotC >= entry.vLightDirection.w);\nlet kappa = 6.64385618977 / max(1.0 - entry.vLightDirection.w, 0.0001);\nlet physicalDirFalloff = exp2(kappa * (spotC - 1.0));\nlet lightAtten = rangeAtt * select(standardDirFalloff, physicalDirFalloff, physicalFalloff);\nlet lightColor = entry.vLightDiffuse.rgb;\nvar directDiffuse = surfaceAlbedo * (1.0 / PI) * NdotL * lightColor * lightAtten * material.directIntensity;\n${specularBlock()}\n/*AD*/`;\n}\n"],"names":[],"mappings":";AAIO,MAAM,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCASJ,UAAU;AAAA;AAAA;AAI1C,SAAS,gBAAwB;AAC7B,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASX;AAEO,SAAS,sBAA8B;AAC1C,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcT,eAAe;AAAA;AAEjB;"}

package/skeleton-fragment-B_XlFbtx.js

@@ -0,0 +1,71 @@
+import { M as MSH_HAS_SKELETON, a as MSH_HAS_SKELETON_8 } from "./mesh-features-BLENkYVt.js";
+const STAGE_VERTEX = 1;
+const SKELETON_HELPERS = `
+fn readMatrixFromRawSampler(smp: texture_2d<f32>, index: f32) -> mat4x4<f32> {
+let offset = i32(index) * 4;
+let m0 = textureLoad(smp, vec2<i32>(offset + 0, 0), 0);
+let m1 = textureLoad(smp, vec2<i32>(offset + 1, 0), 0);
+let m2 = textureLoad(smp, vec2<i32>(offset + 2, 0), 0);
+let m3 = textureLoad(smp, vec2<i32>(offset + 3, 0), 0);
+return mat4x4f(m0, m1, m2, m3);
+}
+`;
+function makeSkinningCode(has8Bones) {
+  let code = `var influence: mat4x4<f32> = readMatrixFromRawSampler(boneSampler, f32(joints[0])) * weights[0];
+influence = influence + readMatrixFromRawSampler(boneSampler, f32(joints[1])) * weights[1];
+influence = influence + readMatrixFromRawSampler(boneSampler, f32(joints[2])) * weights[2];
+influence = influence + readMatrixFromRawSampler(boneSampler, f32(joints[3])) * weights[3];`;
+  if (has8Bones) {
+    code += `
+influence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[0])) * weights1[0];
+influence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[1])) * weights1[1];
+influence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[2])) * weights1[2];
+influence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[3])) * weights1[3];`;
+  }
+  code += `
+finalWorld = mesh.world * influence;`;
+  return code;
+}
+function createSkeletonFragment(has8Bones) {
+  return {
+    _id: "skeleton",
+    _vertexAttributes: [
+      { _name: "joints", _type: "vec4<u32>", _gpuFormat: "uint32x4", _arrayStride: 16 },
+      { _name: "weights", _type: "vec4<f32>", _gpuFormat: "float32x4", _arrayStride: 16 },
+      ...has8Bones ? [
+        { _name: "joints1", _type: "vec4<u32>", _gpuFormat: "uint32x4", _arrayStride: 16 },
+        { _name: "weights1", _type: "vec4<f32>", _gpuFormat: "float32x4", _arrayStride: 16 }
+      ] : []
+    ],
+    _vertexBindings: [
+      { _name: "boneSampler", _type: { _kind: "texture", _textureType: "texture_2d<f32>", _sampleType: "unfilterable-float" }, _visibility: STAGE_VERTEX }
+    ],
+    _vertexHelperFunctions: SKELETON_HELPERS,
+    _vertexSlots: {
+      VW: makeSkinningCode(has8Bones)
+    }
+  };
+}
+const pbrExt = {
+  id: "skeleton",
+  phase: "vertex",
+  frag(ctx) {
+    if (!(ctx._meshFeatures & MSH_HAS_SKELETON)) {
+      return null;
+    }
+    return createSkeletonFragment((ctx._meshFeatures & MSH_HAS_SKELETON_8) !== 0);
+  },
+  bind(ctx, entries, b) {
+    const mesh = ctx._mesh;
+    if (!(ctx._meshFeatures & MSH_HAS_SKELETON) || !(mesh == null ? void 0 : mesh.skeleton)) {
+      return b;
+    }
+    entries.push({ binding: b++, resource: mesh.skeleton.boneTexture.createView() });
+    return b;
+  }
+};
+export {
+  createSkeletonFragment,
+  pbrExt
+};
+//# sourceMappingURL=skeleton-fragment-B_XlFbtx.js.map

package/skeleton-fragment-B_XlFbtx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton-fragment-B_XlFbtx.js","sources":["../src/material/pbr/fragments/skeleton-fragment.ts"],"sourcesContent":["/**\n * Skeleton Fragment\n *\n * Vertex-stage skeletal animation: bone texture sampling + skinning matrix.\n * Only bundled when a scene has skeletal animation.\n * Supports 4-bone and 8-bone skinning.\n */\n\nimport type { ShaderFragment, VertexAttribute } from \"../../../shader/fragment-types.js\";\n\n// WebGPU shader stage constants\nconst STAGE_VERTEX = 0x1;\n\nconst SKELETON_HELPERS = `\nfn readMatrixFromRawSampler(smp: texture_2d<f32>, index: f32) -> mat4x4<f32> {\nlet offset = i32(index) * 4;\nlet m0 = textureLoad(smp, vec2<i32>(offset + 0, 0), 0);\nlet m1 = textureLoad(smp, vec2<i32>(offset + 1, 0), 0);\nlet m2 = textureLoad(smp, vec2<i32>(offset + 2, 0), 0);\nlet m3 = textureLoad(smp, vec2<i32>(offset + 3, 0), 0);\nreturn mat4x4f(m0, m1, m2, m3);\n}\n`;\n\nfunction makeSkinningCode(has8Bones: boolean): string {\n    let code = `var influence: mat4x4<f32> = readMatrixFromRawSampler(boneSampler, f32(joints[0])) * weights[0];\ninfluence = influence + readMatrixFromRawSampler(boneSampler, f32(joints[1])) * weights[1];\ninfluence = influence + readMatrixFromRawSampler(boneSampler, f32(joints[2])) * weights[2];\ninfluence = influence + readMatrixFromRawSampler(boneSampler, f32(joints[3])) * weights[3];`;\n    if (has8Bones) {\n        code += `\ninfluence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[0])) * weights1[0];\ninfluence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[1])) * weights1[1];\ninfluence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[2])) * weights1[2];\ninfluence = influence + readMatrixFromRawSampler(boneSampler, f32(joints1[3])) * weights1[3];`;\n    }\n    code += `\\nfinalWorld = mesh.world * influence;`;\n    return code;\n}\n\n/**\n * Create a skeleton fragment.\n * @param has8Bones - Whether to use 8-bone skinning (joints1/weights1).\n */\nexport function createSkeletonFragment(has8Bones: boolean): ShaderFragment {\n    return {\n        _id: \"skeleton\",\n\n        _vertexAttributes: [\n            { _name: \"joints\", _type: \"vec4<u32>\", _gpuFormat: \"uint32x4\" as GPUVertexFormat, _arrayStride: 16 },\n            { _name: \"weights\", _type: \"vec4<f32>\", _gpuFormat: \"float32x4\" as GPUVertexFormat, _arrayStride: 16 },\n            ...(has8Bones\n                ? [\n                      { _name: \"joints1\", _type: \"vec4<u32>\", _gpuFormat: \"uint32x4\" as GPUVertexFormat, _arrayStride: 16 },\n                      { _name: \"weights1\", _type: \"vec4<f32>\", _gpuFormat: \"float32x4\" as GPUVertexFormat, _arrayStride: 16 },\n                  ]\n                : []),\n        ] as VertexAttribute[],\n\n        _vertexBindings: [\n            { _name: \"boneSampler\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" as const, _sampleType: \"unfilterable-float\" as const }, _visibility: STAGE_VERTEX },\n        ],\n\n        _vertexHelperFunctions: SKELETON_HELPERS,\n\n        _vertexSlots: {\n            VW: makeSkinningCode(has8Bones),\n        },\n    };\n}\n\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { MSH_HAS_SKELETON, MSH_HAS_SKELETON_8 } from \"../../mesh-features.js\";\n\nexport const pbrExt: PbrExt = {\n    id: \"skeleton\",\n    phase: \"vertex\",\n    frag(ctx) {\n        if (!(ctx._meshFeatures & MSH_HAS_SKELETON)) {\n            return null;\n        }\n        return createSkeletonFragment((ctx._meshFeatures & MSH_HAS_SKELETON_8) !== 0);\n    },\n    bind(ctx, entries, b) {\n        const mesh = ctx._mesh as { skeleton?: { boneTexture: GPUTexture } } | undefined;\n        if (!(ctx._meshFeatures & MSH_HAS_SKELETON) || !mesh?.skeleton) {\n            return b;\n        }\n        entries.push({ binding: b++, resource: mesh.skeleton.boneTexture.createView() });\n        return b;\n    },\n};\n"],"names":[],"mappings":";AAWA,MAAM,eAAe;AAErB,MAAM,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWzB,SAAS,iBAAiB,WAA4B;AAClD,MAAI,OAAO;AAAA;AAAA;AAAA;AAIX,MAAI,WAAW;AACX,YAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,EAKZ;AACA,UAAQ;AAAA;AACR,SAAO;AACX;AAMO,SAAS,uBAAuB,WAAoC;AACvE,SAAO;AAAA,IACH,KAAK;AAAA,IAEL,mBAAmB;AAAA,MACf,EAAE,OAAO,UAAU,OAAO,aAAa,YAAY,YAA+B,cAAc,GAAA;AAAA,MAChG,EAAE,OAAO,WAAW,OAAO,aAAa,YAAY,aAAgC,cAAc,GAAA;AAAA,MAClG,GAAI,YACE;AAAA,QACI,EAAE,OAAO,WAAW,OAAO,aAAa,YAAY,YAA+B,cAAc,GAAA;AAAA,QACjG,EAAE,OAAO,YAAY,OAAO,aAAa,YAAY,aAAgC,cAAc,GAAA;AAAA,MAAG,IAE1G,CAAA;AAAA,IAAC;AAAA,IAGX,iBAAiB;AAAA,MACb,EAAE,OAAO,eAAe,OAAO,EAAE,OAAO,WAAW,cAAc,mBAA4B,aAAa,qBAAA,GAAiC,aAAa,aAAA;AAAA,IAAa;AAAA,IAGzK,wBAAwB;AAAA,IAExB,cAAc;AAAA,MACV,IAAI,iBAAiB,SAAS;AAAA,IAAA;AAAA,EAClC;AAER;AAKO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,KAAK,KAAK;AACN,QAAI,EAAE,IAAI,gBAAgB,mBAAmB;AACzC,aAAO;AAAA,IACX;AACA,WAAO,wBAAwB,IAAI,gBAAgB,wBAAwB,CAAC;AAAA,EAChF;AAAA,EACA,KAAK,KAAK,SAAS,GAAG;AAClB,UAAM,OAAO,IAAI;AACjB,QAAI,EAAE,IAAI,gBAAgB,qBAAqB,EAAC,6BAAM,WAAU;AAC5D,aAAO;AAAA,IACX;AACA,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,KAAK,SAAS,YAAY,WAAA,EAAW,CAAG;AAC/E,WAAO;AAAA,EACX;AACJ;"}

package/skybox-renderable-DDwzu-PT.js

@@ -0,0 +1,92 @@
+import { aY as createUniformBuffer, aW as SCENE_UBO_WGSL, D as targetSignatureKey, E as createDefaultPipelineDescriptor, F as getSceneBindGroupLayout } from "./index-C8HOR2sB.js";
+import { c as WGSL_FOG } from "./wgsl-helpers-DyzNzCeE.js";
+const skyVertSrc = "// Skybox CubeMap Vertex Shader\n// Passes object-space position (for cube texture lookup) and world-space position.\n\nstruct MeshUniforms {\n  world: mat4x4<f32>,\n};\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n\nstruct VertexOutput {\n  @builtin(position) clipPos: vec4<f32>,\n  @location(0) vPositionW: vec3<f32>,\n  @location(1) vPositionLocal: vec3<f32>,\n  @location(2) vFogDistance: vec3<f32>,\n};\n\n@vertex\nfn main(\n  @location(0) position: vec3<f32>,\n  @location(1) normal: vec3<f32>,\n) -> VertexOutput {\n  var out: VertexOutput;\n  let worldPos = mesh.world * vec4<f32>(position, 1.0);\n  out.vPositionW = worldPos.xyz;\n  out.vPositionLocal = position;\n  out.clipPos = scene.viewProjection * worldPos;\n  out.vFogDistance = (scene.view * worldPos).xyz;\n  return out;\n}\n";
+const skyFragSrc = "// Skybox CubeMap Fragment Shader\n// Samples cube texture using object-space position as lookup direction.\n// Matches Babylon StandardMaterial with REFLECTION + REFLECTIONMAP_SKYBOX.\n\n@group(1) @binding(1) var cubeTexture: texture_cube<f32>;\n@group(1) @binding(2) var cubeSampler: sampler;\n\nstruct FragmentInput {\n  @location(0) vPositionW: vec3<f32>,\n  @location(1) vPositionLocal: vec3<f32>,\n  @location(2) vFogDistance: vec3<f32>,\n};\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n  // SKYBOX_MODE: use object-space position as cube lookup direction\n  let lookupDir = normalize(input.vPositionLocal);\n  var color = textureSample(cubeTexture, cubeSampler, lookupDir);\n\n  // Apply fog\n  if (scene.vFogInfos.x > 0.0) {\n    let fog = calcFogFactor(input.vFogDistance);\n    color = vec4<f32>(mix(scene.vFogColor.rgb, color.rgb, fog), color.a);\n  }\n\n  return color;\n}\n";
+function buildSkyboxCubeMapGPU(engine, worldMatrix, cubeView, cubeSampler) {
+  const device = engine._device;
+  const meshBindGroupLayout = device.createBindGroupLayout({
+    label: "skybox-cm-mesh",
+    entries: [
+      { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: "uniform" } },
+      { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+      { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: {} }
+    ]
+  });
+  const meshUBO = createUniformBuffer(engine, worldMatrix);
+  const meshBindGroup = device.createBindGroup({
+    layout: meshBindGroupLayout,
+    entries: [
+      { binding: 0, resource: { buffer: meshUBO } },
+      { binding: 1, resource: cubeView },
+      { binding: 2, resource: cubeSampler }
+    ]
+  });
+  const vertModule = device.createShaderModule({ code: SCENE_UBO_WGSL + skyVertSrc, label: "skybox-cm-vert" });
+  const fragModule = device.createShaderModule({ code: SCENE_UBO_WGSL + WGSL_FOG + skyFragSrc, label: "skybox-cm-frag" });
+  const gpu = {
+    getPipeline(_engine, sig) {
+      const key = targetSignatureKey(sig);
+      const cached = gpu.pipelines.get(key);
+      if (cached) {
+        return cached;
+      }
+      const pipeline = _engine._device.createRenderPipeline(
+        createDefaultPipelineDescriptor({
+          _label: "skybox-cubemap-pipeline",
+          _engine,
+          _bgls: [getSceneBindGroupLayout(_engine), gpu.meshBindGroupLayout],
+          _vertModule: gpu.vertModule,
+          _fragModule: gpu.fragModule,
+          _vertexBuffers: [
+            { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }] },
+            { arrayStride: 12, attributes: [{ shaderLocation: 1, offset: 0, format: "float32x3" }] }
+          ],
+          _format: sig._colorFormat,
+          _depthStencilFormat: sig._depthStencilFormat,
+          _depthCompare: sig._depthCompare,
+          _msaaSamples: sig._sampleCount,
+          _cullMode: "none",
+          _flipY: sig._flipY
+        })
+      );
+      gpu.pipelines.set(key, pipeline);
+      return pipeline;
+    },
+    meshBindGroup,
+    meshUBO,
+    meshBindGroupLayout,
+    vertModule,
+    fragModule,
+    pipelines: /* @__PURE__ */ new Map()
+  };
+  return gpu;
+}
+function buildSkyboxRenderable(scene, skybox) {
+  const engine = scene.engine;
+  const gpu = buildSkyboxCubeMapGPU(engine, skybox.worldMatrix, skybox.cubeView, skybox.cubeSampler);
+  const r = {
+    order: 0,
+    // skybox behind everything
+    isTransparent: false,
+    bind(eng, sig) {
+      const pipeline = gpu.getPipeline(eng, sig);
+      return {
+        renderable: r,
+        pipeline,
+        draw(pass) {
+          pass.setBindGroup(1, gpu.meshBindGroup);
+          pass.setVertexBuffer(0, skybox.posBuffer);
+          pass.setVertexBuffer(1, skybox.normBuffer);
+          pass.setIndexBuffer(skybox.idxBuffer, "uint32");
+          pass.drawIndexed(skybox.idxCount);
+          return 1;
+        }
+      };
+    }
+  };
+  return r;
+}
+export {
+  buildSkyboxRenderable
+};
+//# sourceMappingURL=skybox-renderable-DDwzu-PT.js.map

package/skybox-renderable-DDwzu-PT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skybox-renderable-DDwzu-PT.js","sources":["../shaders/skybox-cubemap.vertex.wgsl?raw","../shaders/skybox-cubemap.fragment.wgsl?raw","../src/material/standard/skybox-cubemap.ts","../src/loader-skybox/skybox-renderable.ts"],"sourcesContent":["export default \"// Skybox CubeMap Vertex Shader\\n// Passes object-space position (for cube texture lookup) and world-space position.\\n\\nstruct MeshUniforms {\\n  world: mat4x4<f32>,\\n};\\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\\n\\nstruct VertexOutput {\\n  @builtin(position) clipPos: vec4<f32>,\\n  @location(0) vPositionW: vec3<f32>,\\n  @location(1) vPositionLocal: vec3<f32>,\\n  @location(2) vFogDistance: vec3<f32>,\\n};\\n\\n@vertex\\nfn main(\\n  @location(0) position: vec3<f32>,\\n  @location(1) normal: vec3<f32>,\\n) -> VertexOutput {\\n  var out: VertexOutput;\\n  let worldPos = mesh.world * vec4<f32>(position, 1.0);\\n  out.vPositionW = worldPos.xyz;\\n  out.vPositionLocal = position;\\n  out.clipPos = scene.viewProjection * worldPos;\\n  out.vFogDistance = (scene.view * worldPos).xyz;\\n  return out;\\n}\\n\"","export default \"// Skybox CubeMap Fragment Shader\\n// Samples cube texture using object-space position as lookup direction.\\n// Matches Babylon StandardMaterial with REFLECTION + REFLECTIONMAP_SKYBOX.\\n\\n@group(1) @binding(1) var cubeTexture: texture_cube<f32>;\\n@group(1) @binding(2) var cubeSampler: sampler;\\n\\nstruct FragmentInput {\\n  @location(0) vPositionW: vec3<f32>,\\n  @location(1) vPositionLocal: vec3<f32>,\\n  @location(2) vFogDistance: vec3<f32>,\\n};\\n\\n@fragment\\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\\n  // SKYBOX_MODE: use object-space position as cube lookup direction\\n  let lookupDir = normalize(input.vPositionLocal);\\n  var color = textureSample(cubeTexture, cubeSampler, lookupDir);\\n\\n  // Apply fog\\n  if (scene.vFogInfos.x > 0.0) {\\n    let fog = calcFogFactor(input.vFogDistance);\\n    color = vec4<f32>(mix(scene.vFogColor.rgb, color.rgb, fog), color.a);\\n  }\\n\\n  return color;\\n}\\n\"","/**\n * Skybox CubeMap Material — renders a cube map on the inside of a box.\n * Material owns shaders (pillar 4c). Self-contained pipeline and bind groups.\n *\n * Used for StandardMaterial + CubeTexture(SKYBOX_MODE) in Babylon.\n * Renders backfaces (no culling → sees inside of box).\n */\n\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { RenderTargetSignature } from \"../../engine/render-target.js\";\nimport skyVertSrc from \"../../../shaders/skybox-cubemap.vertex.wgsl?raw\";\nimport skyFragSrc from \"../../../shaders/skybox-cubemap.fragment.wgsl?raw\";\nimport { getSceneBindGroupLayout, createDefaultPipelineDescriptor } from \"../../render/scene-helpers.js\";\nimport { WGSL_FOG } from \"../../shader/wgsl-helpers.js\";\nimport { SCENE_UBO_WGSL } from \"../../shader/scene-uniforms.js\";\nimport { createUniformBuffer } from \"../../resource/gpu-buffers.js\";\nimport { targetSignatureKey } from \"../../engine/render-target.js\";\n\nexport interface SkyboxCubeMapGPU {\n    /** Sig-keyed pipeline lookup (called from `bind()` once the target sig is known). */\n    getPipeline(engine: EngineContext, sig: RenderTargetSignature): GPURenderPipeline;\n    meshBindGroup: GPUBindGroup;\n    meshUBO: GPUBuffer;\n    meshBindGroupLayout: GPUBindGroupLayout;\n    /** Pre-compiled shader modules — sig-independent. */\n    vertModule: GPUShaderModule;\n    fragModule: GPUShaderModule;\n    /** Per-sig pipeline cache, owned by this skybox instance. */\n    pipelines: Map<string, GPURenderPipeline>;\n}\n\n/**\n * Build the per-skybox GPU resources (mesh BGL + bind group + UBO + shader modules\n * + pipeline cache). The pipeline is created lazily by `getPipeline(engine, sig)`\n * once the target sig is known. The scene bind group is supplied per-pass by the\n * active RenderTask.\n */\nexport function buildSkyboxCubeMapGPU(engine: EngineContext, worldMatrix: Float32Array, cubeView: GPUTextureView, cubeSampler: GPUSampler): SkyboxCubeMapGPU {\n    const device = engine._device;\n    const meshBindGroupLayout = device.createBindGroupLayout({\n        label: \"skybox-cm-mesh\",\n        entries: [\n            { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: \"uniform\" } },\n            { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: \"float\", viewDimension: \"cube\" } },\n            { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: {} },\n        ],\n    });\n\n    const meshUBO = createUniformBuffer(engine, worldMatrix);\n    const meshBindGroup = device.createBindGroup({\n        layout: meshBindGroupLayout,\n        entries: [\n            { binding: 0, resource: { buffer: meshUBO } },\n            { binding: 1, resource: cubeView },\n            { binding: 2, resource: cubeSampler },\n        ],\n    });\n\n    const vertModule = device.createShaderModule({ code: SCENE_UBO_WGSL + skyVertSrc, label: \"skybox-cm-vert\" });\n    const fragModule = device.createShaderModule({ code: SCENE_UBO_WGSL + WGSL_FOG + skyFragSrc, label: \"skybox-cm-frag\" });\n\n    const gpu: SkyboxCubeMapGPU = {\n        getPipeline(_engine, sig) {\n            const key = targetSignatureKey(sig);\n            const cached = gpu.pipelines.get(key);\n            if (cached) {\n                return cached;\n            }\n            const pipeline = _engine._device.createRenderPipeline(\n                createDefaultPipelineDescriptor({\n                    _label: \"skybox-cubemap-pipeline\",\n                    _engine,\n                    _bgls: [getSceneBindGroupLayout(_engine), gpu.meshBindGroupLayout],\n                    _vertModule: gpu.vertModule,\n                    _fragModule: gpu.fragModule,\n                    _vertexBuffers: [\n                        { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: \"float32x3\" as GPUVertexFormat }] },\n                        { arrayStride: 12, attributes: [{ shaderLocation: 1, offset: 0, format: \"float32x3\" as GPUVertexFormat }] },\n                    ],\n                    _format: sig._colorFormat!,\n                    _depthStencilFormat: sig._depthStencilFormat,\n                    _depthCompare: sig._depthCompare,\n                    _msaaSamples: sig._sampleCount,\n                    _cullMode: \"none\",\n                    _flipY: sig._flipY,\n                })\n            );\n            gpu.pipelines.set(key, pipeline);\n            return pipeline;\n        },\n        meshBindGroup,\n        meshUBO,\n        meshBindGroupLayout,\n        vertModule,\n        fragModule,\n        pipelines: new Map(),\n    };\n    return gpu;\n}\n","/** Skybox renderable for cube-texture skyboxes (standard-material scenes).\n *  Wraps the existing skybox-cubemap material into a Renderable. */\n\nimport type { SceneContext } from \"../scene/scene.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { SkyboxData } from \"./load-skybox.js\";\nimport type { Renderable } from \"../render/renderable.js\";\nimport { buildSkyboxCubeMapGPU } from \"../material/standard/skybox-cubemap.js\";\n\n/** Build a skybox Renderable from a SkyboxData (loaded via loadSkybox). */\nexport function buildSkyboxRenderable(scene: SceneContext, skybox: SkyboxData): Renderable {\n    const engine = scene.engine;\n\n    const gpu = buildSkyboxCubeMapGPU(engine, skybox.worldMatrix, skybox.cubeView, skybox.cubeSampler);\n\n    const r: Renderable = {\n        order: 0, // skybox behind everything\n        isTransparent: false,\n        bind(eng, sig) {\n            const pipeline = gpu.getPipeline(eng as EngineContext, sig);\n            return {\n                renderable: r,\n                pipeline,\n                draw(pass) {\n                    pass.setBindGroup(1, gpu.meshBindGroup);\n                    pass.setVertexBuffer(0, skybox.posBuffer);\n                    pass.setVertexBuffer(1, skybox.normBuffer);\n                    pass.setIndexBuffer(skybox.idxBuffer, \"uint32\");\n                    pass.drawIndexed(skybox.idxCount);\n                    return 1;\n                },\n            };\n        },\n    };\n    return r;\n}\n"],"names":[],"mappings":"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"}

package/skybox.vertex-DJgi072W.js

@@ -0,0 +1,5 @@
+const skyboxVertSrc = "// Skybox Vertex Shader — matches Babylon BackgroundMaterial (REFLECTIONMAP_SKYBOX)\n// Outputs local position as cubemap direction (vPositionUVW) + world position for dithering\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  // Infinite distance: strip translation (w=0), center at camera.\n  // Matches BJS skybox.infiniteDistance = true.\n  let worldPos = (mesh.world * vec4<f32>(position, 0.0)).xyz + scene.vEyePosition.xyz;\n  output.positionW = worldPos;\n  output.clipPos = scene.viewProjection * vec4<f32>(worldPos, 1.0);\n  return output;\n}\n";
+export {
+  skyboxVertSrc as s
+};
+//# sourceMappingURL=skybox.vertex-DJgi072W.js.map

package/skybox.vertex-DJgi072W.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skybox.vertex-DJgi072W.js","sources":["../shaders/skybox.vertex.wgsl?raw"],"sourcesContent":["export default \"// Skybox Vertex Shader — matches Babylon BackgroundMaterial (REFLECTIONMAP_SKYBOX)\\n// Outputs local position as cubemap direction (vPositionUVW) + world position for dithering\\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  // Infinite distance: strip translation (w=0), center at camera.\\n  // Matches BJS skybox.infiniteDistance = true.\\n  let worldPos = (mesh.world * vec4<f32>(position, 0.0)).xyz + scene.vEyePosition.xyz;\\n  output.positionW = worldPos;\\n  output.clipPos = scene.viewProjection * vec4<f32>(worldPos, 1.0);\\n  return output;\\n}\\n\""],"names":[],"mappings":"AAAA,MAAA,gBAAe;"}

package/smoothstep-block-Di4t37x-.js

@@ -0,0 +1,15 @@
+const emitter = {
+  className: "SmoothStepBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const value = ctx.resolve(block, "value", stage, state);
+    const edge0 = ctx.resolve(block, "edge0", stage, state);
+    const edge1 = ctx.resolve(block, "edge1", stage, state);
+    const e0 = ctx.cast(edge0, value.type).expr;
+    const e1 = ctx.cast(edge1, value.type).expr;
+    return { expr: `smoothstep(${e0}, ${e1}, ${value.expr})`, type: value.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=smoothstep-block-Di4t37x-.js.map

package/smoothstep-block-Di4t37x-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoothstep-block-Di4t37x-.js","sources":["../src/material/node/blocks/smoothstep-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"SmoothStepBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const value = ctx.resolve(block, \"value\", stage, state);\n        const edge0 = ctx.resolve(block, \"edge0\", stage, state);\n        const edge1 = ctx.resolve(block, \"edge1\", stage, state);\n        const e0 = ctx.cast(edge0, value.type).expr;\n        const e1 = ctx.cast(edge1, value.type).expr;\n        return { expr: `smoothstep(${e0}, ${e1}, ${value.expr})`, 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,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,KAAK,IAAI,KAAK,OAAO,MAAM,IAAI,EAAE;AACvC,UAAM,KAAK,IAAI,KAAK,OAAO,MAAM,IAAI,EAAE;AACvC,WAAO,EAAE,MAAM,cAAc,EAAE,KAAK,EAAE,KAAK,MAAM,IAAI,KAAK,MAAM,MAAM,KAAA;AAAA,EAC1E;AACJ;"}