@babylonjs/lite 0.1.1

package/background-ground-DIw6D3qf.js

@@ -0,0 +1,235 @@
+import { b2 as getBilinearSampler, e as createMappedBuffer, aY as createUniformBuffer, D as targetSignatureKey, aW as SCENE_UBO_WGSL, F as getSceneBindGroupLayout } from "./index-C8HOR2sB.js";
+import { a as WGSL_DITHER, b as WGSL_NO_DITHER } from "./wgsl-helpers-DyzNzCeE.js";
+const groundVertSrc = "// Background Ground Vertex Shader\n// Matches BJS shd_15: DIFFUSE, OPACITYFRESNEL, PREMULTIPLYALPHA (no REFLECTION)\n\nstruct MeshUniforms {\n  world: mat4x4<f32>,\n};\n\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n\nstruct VertexInput {\n  @location(0) position: vec3<f32>,\n  @location(1) normal: vec3<f32>,\n  @location(2) uv: vec2<f32>,\n};\n\nstruct VertexOutput {\n  @builtin(position) clipPos: vec4<f32>,\n  @location(0) vPositionW: vec3<f32>,\n  @location(1) vNormalW: vec3<f32>,\n  @location(2) vUV: vec2<f32>,\n};\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n  var output: VertexOutput;\n  let finalWorld = mesh.world;\n  let worldPos4 = finalWorld * vec4<f32>(input.position, 1.0);\n  output.vPositionW = worldPos4.xyz;\n  output.clipPos = scene.viewProjection * worldPos4;\n  let normalWorld = mat3x3<f32>(finalWorld[0].xyz, finalWorld[1].xyz, finalWorld[2].xyz);\n  output.vNormalW = normalize(normalWorld * input.normal);\n  output.vUV = input.uv;\n  return output;\n}\n";
+const groundFragSrc = "// Background Ground Fragment Shader\n// Matches BJS shd_16: DIFFUSE, OPACITYFRESNEL, PREMULTIPLYALPHA (no REFLECTION)\n// Verified via Spector.GPU capture of BJS scene 1\n\nstruct MeshUniforms {\n  world: mat4x4<f32>,\n  primaryColor: vec3<f32>,\n  alpha: f32,\n  backgroundCenter: vec3<f32>,\n  _pad: f32,\n};\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n\n@group(1) @binding(1) var groundTexture: texture_2d<f32>;\n@group(1) @binding(2) var groundSampler: sampler;\n\nstruct FragmentInput {\n  @location(0) vPositionW: vec3<f32>,\n  @location(1) vNormalW: vec3<f32>,\n  @location(2) vUV: vec2<f32>,\n};\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n  let normalW = normalize(input.vNormalW);\n\n  // Sample diffuse texture (BJS backgroundGround.png: white RGB, radial alpha gradient)\n  let diffuseMap = textureSample(groundTexture, groundSampler, input.vUV);\n\n  // BJS: reflectionColor = vec4(1) (no REFLECTION define)\n  let diffuseColor = diffuseMap.rgb;\n  let colorBase = max(diffuseColor, vec3<f32>(0.0));\n  let mainColor = mesh.primaryColor;\n  let finalColor = colorBase * mainColor;\n\n  // Alpha starts from material alpha, multiplied by texture alpha\n  var finalAlpha = mesh.alpha * diffuseMap.a;\n\n  // OPACITYFRESNEL — BJS shd_16 lines 367-370\n  let viewAngleToFloor = dot(normalW, normalize(scene.vEyePosition.xyz - mesh.backgroundCenter));\n  const startAngle: f32 = 0.1;\n  let fadeFactor = clamp(viewAngleToFloor / startAngle, 0.0, 1.0);\n  finalAlpha *= fadeFactor * fadeFactor;\n\n  // Image processing (preserves alpha)\n  var color = vec4<f32>(finalColor, finalAlpha);\n  if (scene.vImageInfos.w >= 0.0) {\n    color = applyImageProcessing(color);\n  }\n\n  // PREMULTIPLYALPHA — BJS shd_16 line 373\n  color = vec4<f32>(color.rgb * color.a, color.a);\n\n  // Dithering\n  color = vec4<f32>(color.rgb + vec3<f32>(dither(input.vPositionW.xy, 0.5)), color.a);\n  color = max(color, vec4<f32>(0.0));\n\n  return color;\n}\n";
+const WGSL_IMAGE_PROCESSING = `
+fn applyImageProcessing(result: vec4<f32>) -> vec4<f32> {
+var rgb = result.rgb;
+rgb *= scene.vImageInfos.x;
+const tonemappingCalibration: f32 = 1.590579;
+rgb = 1.0 - exp2(-tonemappingCalibration * rgb);
+rgb = pow(rgb, vec3<f32>(1.0 / 2.2));
+rgb = clamp(rgb, vec3<f32>(0.0), vec3<f32>(1.0));
+let highContrast = rgb * rgb * (3.0 - 2.0 * rgb);
+if (scene.vImageInfos.y < 1.0) {
+rgb = mix(vec3<f32>(0.5), rgb, scene.vImageInfos.y);
+} else {
+rgb = mix(rgb, highContrast, scene.vImageInfos.y - 1.0);
+}
+rgb = max(rgb, vec3<f32>(0.0));
+return vec4<f32>(rgb, result.a);
+}
+`;
+const BG_MESH_UNIFORM_SIZE = 96;
+async function buildGroundRenderable(engine, groundSize, rootPosition, primaryColor, groundTextureUrl, groundImagePromise, enableNoise = true) {
+  const fragCode = SCENE_UBO_WGSL + WGSL_IMAGE_PROCESSING + (enableNoise ? WGSL_DITHER : WGSL_NO_DITHER) + groundFragSrc;
+  const gndMat = createGroundMaterial(enableNoise, fragCode);
+  const eps = 2220446049250313e-31;
+  const groundWorld = new Float32Array(16);
+  groundWorld[0] = 1;
+  groundWorld[5] = eps;
+  groundWorld[6] = -1;
+  groundWorld[9] = 1;
+  groundWorld[10] = eps;
+  groundWorld[12] = rootPosition[0];
+  groundWorld[13] = rootPosition[1];
+  groundWorld[14] = rootPosition[2];
+  groundWorld[15] = 1;
+  const gndBufs = createGroundBuffers(engine, groundSize);
+  const gndUBO = createBgMeshUBO(engine, groundWorld, primaryColor);
+  const groundTex = await loadGroundTexture(engine, groundTextureUrl, groundImagePromise);
+  const groundTexView = groundTex.createView();
+  const groundSamp = getBilinearSampler(engine);
+  const gndBG = gndMat.createBindGroup(engine, gndUBO, groundTexView, groundSamp);
+  const r = {
+    order: 200,
+    // ground renders last (transparent)
+    isTransparent: true,
+    bind(eng, sig) {
+      return {
+        renderable: r,
+        pipeline: gndMat.getPipeline(eng, sig),
+        draw(pass) {
+          pass.setBindGroup(1, gndBG);
+          pass.setVertexBuffer(0, gndBufs.posBuffer);
+          pass.setVertexBuffer(1, gndBufs.normBuffer);
+          pass.setVertexBuffer(2, gndBufs.uvBuffer);
+          pass.setIndexBuffer(gndBufs.idxBuffer, "uint16");
+          pass.drawIndexed(gndBufs.idxCount);
+          return 1;
+        }
+      };
+    }
+  };
+  return r;
+}
+const _gndPipelines = /* @__PURE__ */ new Map();
+let _gndLayout = null;
+let _gndCachedDevice = null;
+function createGroundMaterial(enableNoise, fragCode) {
+  function getLayout(engine) {
+    const device = engine._device;
+    if (_gndLayout && _gndCachedDevice === device) {
+      return _gndLayout;
+    }
+    _gndLayout = device.createBindGroupLayout({
+      label: "ground-material",
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "2d" } },
+        { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } }
+      ]
+    });
+    _gndCachedDevice = device;
+    return _gndLayout;
+  }
+  return {
+    getPipeline(engine, sig) {
+      const device = engine._device;
+      if (_gndCachedDevice !== device) {
+        _gndPipelines.clear();
+        _gndLayout = null;
+        _gndCachedDevice = device;
+      }
+      const key = `${+enableNoise}|${targetSignatureKey(sig)}`;
+      const cached = _gndPipelines.get(key);
+      if (cached) {
+        return cached;
+      }
+      const vertModule = device.createShaderModule({ code: SCENE_UBO_WGSL + groundVertSrc, label: "ground-vert" });
+      const fragModule = device.createShaderModule({ code: fragCode, label: "ground-frag" });
+      const pipeline = device.createRenderPipeline({
+        label: "ground-pipeline",
+        layout: device.createPipelineLayout({ bindGroupLayouts: [getSceneBindGroupLayout(engine), getLayout(engine)] }),
+        vertex: {
+          module: vertModule,
+          entryPoint: "main",
+          buffers: [
+            { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }] },
+            { arrayStride: 12, attributes: [{ shaderLocation: 1, offset: 0, format: "float32x3" }] },
+            { arrayStride: 8, attributes: [{ shaderLocation: 2, offset: 0, format: "float32x2" }] }
+          ]
+        },
+        fragment: {
+          module: fragModule,
+          entryPoint: "main",
+          targets: [
+            {
+              format: sig._colorFormat,
+              blend: {
+                color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+                alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
+              }
+            }
+          ]
+        },
+        depthStencil: {
+          format: sig._depthStencilFormat ?? "depth24plus-stencil8",
+          depthCompare: sig._depthCompare ?? "greater-equal",
+          depthWriteEnabled: false
+        },
+        multisample: { count: sig._sampleCount },
+        primitive: { topology: "triangle-list", cullMode: "back", frontFace: sig._flipY ? "cw" : "ccw" }
+      });
+      _gndPipelines.set(key, pipeline);
+      return pipeline;
+    },
+    createBindGroup(engine, meshUBO, groundTextureView, groundSampler) {
+      const device = engine._device;
+      return device.createBindGroup({
+        layout: getLayout(engine),
+        entries: [
+          { binding: 0, resource: { buffer: meshUBO } },
+          { binding: 1, resource: groundTextureView },
+          { binding: 2, resource: groundSampler }
+        ]
+      });
+    }
+  };
+}
+function createGroundBuffers(engine, groundSize) {
+  const h = groundSize / 2;
+  const positions = new Float32Array([
+    -h,
+    -h,
+    0,
+    h,
+    -h,
+    0,
+    h,
+    h,
+    0,
+    -h,
+    h,
+    0
+  ]);
+  const normals = new Float32Array([
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1
+  ]);
+  const uvs = new Float32Array([
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1
+  ]);
+  const indices = new Uint16Array([0, 2, 1, 0, 3, 2]);
+  return {
+    posBuffer: createMappedBuffer(engine, positions, GPUBufferUsage.VERTEX),
+    normBuffer: createMappedBuffer(engine, normals, GPUBufferUsage.VERTEX),
+    uvBuffer: createMappedBuffer(engine, uvs, GPUBufferUsage.VERTEX),
+    idxBuffer: createMappedBuffer(engine, indices, GPUBufferUsage.INDEX),
+    idxCount: 6
+  };
+}
+function createBgMeshUBO(engine, world, primaryColor) {
+  const data = new Float32Array(BG_MESH_UNIFORM_SIZE / 4);
+  data.set(world, 0);
+  data[16] = primaryColor[0];
+  data[17] = primaryColor[1];
+  data[18] = primaryColor[2];
+  data[19] = 0.9;
+  data[20] = 0;
+  data[21] = 0;
+  data[22] = 0;
+  return createUniformBuffer(engine, data);
+}
+async function loadGroundTexture(engine, url, preloadedImage) {
+  const device = engine._device;
+  if (!url) {
+    const tex2 = device.createTexture({
+      size: [1, 1],
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+    });
+    device.queue.writeTexture({ texture: tex2 }, new Uint8Array([255, 255, 255, 255]), { bytesPerRow: 4 }, [1, 1]);
+    return tex2;
+  }
+  const bmp = preloadedImage ? await preloadedImage : await fetch(url).then((r) => r.blob()).then((b) => createImageBitmap(b, { premultiplyAlpha: "none" }));
+  const tex = device.createTexture({
+    size: [bmp.width, bmp.height],
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+  });
+  device.queue.copyExternalImageToTexture({ source: bmp }, { texture: tex }, [bmp.width, bmp.height]);
+  bmp.close();
+  return tex;
+}
+export {
+  buildGroundRenderable
+};
+//# sourceMappingURL=background-ground-DIw6D3qf.js.map

package/background-ground-DIw6D3qf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-ground-DIw6D3qf.js","sources":["../shaders/background.vertex.wgsl?raw","../shaders/background.ground.fragment.wgsl?raw","../src/material/pbr/background-ground.ts"],"sourcesContent":["export default \"// Background Ground Vertex Shader\\n// Matches BJS shd_15: DIFFUSE, OPACITYFRESNEL, PREMULTIPLYALPHA (no REFLECTION)\\n\\nstruct MeshUniforms {\\n  world: mat4x4<f32>,\\n};\\n\\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\\n\\nstruct VertexInput {\\n  @location(0) position: vec3<f32>,\\n  @location(1) normal: vec3<f32>,\\n  @location(2) uv: vec2<f32>,\\n};\\n\\nstruct VertexOutput {\\n  @builtin(position) clipPos: vec4<f32>,\\n  @location(0) vPositionW: vec3<f32>,\\n  @location(1) vNormalW: vec3<f32>,\\n  @location(2) vUV: vec2<f32>,\\n};\\n\\n@vertex\\nfn main(input: VertexInput) -> VertexOutput {\\n  var output: VertexOutput;\\n  let finalWorld = mesh.world;\\n  let worldPos4 = finalWorld * vec4<f32>(input.position, 1.0);\\n  output.vPositionW = worldPos4.xyz;\\n  output.clipPos = scene.viewProjection * worldPos4;\\n  let normalWorld = mat3x3<f32>(finalWorld[0].xyz, finalWorld[1].xyz, finalWorld[2].xyz);\\n  output.vNormalW = normalize(normalWorld * input.normal);\\n  output.vUV = input.uv;\\n  return output;\\n}\\n\"","export default \"// Background Ground Fragment Shader\\n// Matches BJS shd_16: DIFFUSE, OPACITYFRESNEL, PREMULTIPLYALPHA (no REFLECTION)\\n// Verified via Spector.GPU capture of BJS scene 1\\n\\nstruct MeshUniforms {\\n  world: mat4x4<f32>,\\n  primaryColor: vec3<f32>,\\n  alpha: f32,\\n  backgroundCenter: vec3<f32>,\\n  _pad: f32,\\n};\\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\\n\\n@group(1) @binding(1) var groundTexture: texture_2d<f32>;\\n@group(1) @binding(2) var groundSampler: sampler;\\n\\nstruct FragmentInput {\\n  @location(0) vPositionW: vec3<f32>,\\n  @location(1) vNormalW: vec3<f32>,\\n  @location(2) vUV: vec2<f32>,\\n};\\n\\n@fragment\\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\\n  let normalW = normalize(input.vNormalW);\\n\\n  // Sample diffuse texture (BJS backgroundGround.png: white RGB, radial alpha gradient)\\n  let diffuseMap = textureSample(groundTexture, groundSampler, input.vUV);\\n\\n  // BJS: reflectionColor = vec4(1) (no REFLECTION define)\\n  let diffuseColor = diffuseMap.rgb;\\n  let colorBase = max(diffuseColor, vec3<f32>(0.0));\\n  let mainColor = mesh.primaryColor;\\n  let finalColor = colorBase * mainColor;\\n\\n  // Alpha starts from material alpha, multiplied by texture alpha\\n  var finalAlpha = mesh.alpha * diffuseMap.a;\\n\\n  // OPACITYFRESNEL — BJS shd_16 lines 367-370\\n  let viewAngleToFloor = dot(normalW, normalize(scene.vEyePosition.xyz - mesh.backgroundCenter));\\n  const startAngle: f32 = 0.1;\\n  let fadeFactor = clamp(viewAngleToFloor / startAngle, 0.0, 1.0);\\n  finalAlpha *= fadeFactor * fadeFactor;\\n\\n  // Image processing (preserves alpha)\\n  var color = vec4<f32>(finalColor, finalAlpha);\\n  if (scene.vImageInfos.w >= 0.0) {\\n    color = applyImageProcessing(color);\\n  }\\n\\n  // PREMULTIPLYALPHA — BJS shd_16 line 373\\n  color = vec4<f32>(color.rgb * color.a, color.a);\\n\\n  // Dithering\\n  color = vec4<f32>(color.rgb + vec3<f32>(dither(input.vPositionW.xy, 0.5)), color.a);\\n  color = max(color, vec4<f32>(0.0));\\n\\n  return color;\\n}\\n\"","/** Ground plane renderable — lazy-loaded only when a scene includes a ground.\n *  Contains the ground material, mesh buffers, texture loading, and UBO creation.\n *  Tree-shaken away from scenes that use `skipGround: true`. */\n\nimport type { Mat4 } from \"../../math/types.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { Renderable } from \"../../render/renderable.js\";\nimport type { RenderTargetSignature } from \"../../engine/render-target.js\";\nimport { getBilinearSampler } from \"../../resource/samplers.js\";\nimport { createUniformBuffer } from \"../../resource/gpu-buffers.js\";\nimport { getSceneBindGroupLayout } from \"../../render/scene-helpers.js\";\nimport { targetSignatureKey } from \"../../engine/render-target.js\";\nimport groundVertSrc from \"../../../shaders/background.vertex.wgsl?raw\";\nimport groundFragSrc from \"../../../shaders/background.ground.fragment.wgsl?raw\";\nimport { createMappedBuffer } from \"../../resource/gpu-buffers.js\";\nimport { SCENE_UBO_WGSL } from \"../../shader/scene-uniforms.js\";\nimport { WGSL_DITHER, WGSL_NO_DITHER } from \"../../shader/wgsl-helpers.js\";\n\n// ── Ground-frag-only WGSL helpers (kept here so scenes that don't load the ground\n//    don't pay for the image-processing helper in the shared wgsl-helpers chunk). ──\n\n/** Image processing: exposure → Reinhard tonemap → gamma → contrast. */\nconst WGSL_IMAGE_PROCESSING = `\nfn applyImageProcessing(result: vec4<f32>) -> vec4<f32> {\nvar rgb = result.rgb;\nrgb *= scene.vImageInfos.x;\nconst tonemappingCalibration: f32 = 1.590579;\nrgb = 1.0 - exp2(-tonemappingCalibration * rgb);\nrgb = pow(rgb, vec3<f32>(1.0 / 2.2));\nrgb = clamp(rgb, vec3<f32>(0.0), vec3<f32>(1.0));\nlet highContrast = rgb * rgb * (3.0 - 2.0 * rgb);\nif (scene.vImageInfos.y < 1.0) {\nrgb = mix(vec3<f32>(0.5), rgb, scene.vImageInfos.y);\n} else {\nrgb = mix(rgb, highContrast, scene.vImageInfos.y - 1.0);\n}\nrgb = max(rgb, vec3<f32>(0.0));\nreturn vec4<f32>(rgb, result.a);\n}\n`;\n\nconst BG_MESH_UNIFORM_SIZE = 96; // mat4x4 + primaryColor vec3 + alpha + backgroundCenter vec3 + pad\n\n/** Build the ground renderable for a PBR environment scene. */\nexport async function buildGroundRenderable(\n    engine: EngineContext,\n    groundSize: number,\n    rootPosition: [number, number, number],\n    primaryColor: [number, number, number],\n    groundTextureUrl?: string,\n    groundImagePromise?: Promise<ImageBitmap>,\n    enableNoise = true\n): Promise<Renderable> {\n    const fragCode = SCENE_UBO_WGSL + WGSL_IMAGE_PROCESSING + (enableNoise ? WGSL_DITHER : WGSL_NO_DITHER) + groundFragSrc;\n    const gndMat = createGroundMaterial(enableNoise, fragCode);\n\n    // Ground world: rotated 90° X (XY→XZ), translated to rootPosition\n    // Column-major for WGSL: ground quad in XY plane, normal +Z → world +Y\n    // Offset Y by -0.01 to prevent z-fighting with scene floor geometry.\n    const eps = 2.220446049250313e-16;\n    const groundWorld = new Float32Array(16) as Mat4;\n    groundWorld[0] = 1;\n    groundWorld[5] = eps;\n    groundWorld[6] = -1;\n    groundWorld[9] = 1;\n    groundWorld[10] = eps;\n    groundWorld[12] = rootPosition[0];\n    groundWorld[13] = rootPosition[1];\n    groundWorld[14] = rootPosition[2];\n    groundWorld[15] = 1;\n\n    const gndBufs = createGroundBuffers(engine, groundSize);\n    const gndUBO = createBgMeshUBO(engine, groundWorld, primaryColor);\n\n    const groundTex = await loadGroundTexture(engine, groundTextureUrl, groundImagePromise);\n    const groundTexView = groundTex.createView();\n    const groundSamp = getBilinearSampler(engine);\n    const gndBG = gndMat.createBindGroup(engine, gndUBO, groundTexView, groundSamp);\n\n    const r: Renderable = {\n        order: 200, // ground renders last (transparent)\n        isTransparent: true,\n        bind(eng, sig) {\n            return {\n                renderable: r,\n                pipeline: gndMat.getPipeline(eng as EngineContext, sig),\n                draw(pass) {\n                    pass.setBindGroup(1, gndBG);\n                    pass.setVertexBuffer(0, gndBufs.posBuffer);\n                    pass.setVertexBuffer(1, gndBufs.normBuffer);\n                    pass.setVertexBuffer(2, gndBufs.uvBuffer);\n                    pass.setIndexBuffer(gndBufs.idxBuffer, \"uint16\");\n                    pass.drawIndexed(gndBufs.idxCount);\n                    return 1;\n                },\n            };\n        },\n    };\n    return r;\n}\n\n// ─── Ground Material ────────────────────────────────────────────────────────\n\ninterface GroundMaterial {\n    getPipeline(engine: EngineContext, sig: RenderTargetSignature): GPURenderPipeline;\n    createBindGroup(engine: EngineContext, meshUBO: GPUBuffer, groundTextureView: GPUTextureView, groundSampler: GPUSampler): GPUBindGroup;\n}\n\n/** Module-global pipeline cache — keyed by noise mode + full target signature (color/depth/samples/flipY).\n *  All ground renderables share this cache. */\nconst _gndPipelines = new Map<string, GPURenderPipeline>();\nlet _gndLayout: GPUBindGroupLayout | null = null;\nlet _gndCachedDevice: GPUDevice | null = null;\n\nfunction createGroundMaterial(enableNoise: boolean, fragCode: string): GroundMaterial {\n    function getLayout(engine: EngineContext): GPUBindGroupLayout {\n        const device = engine._device;\n        if (_gndLayout && _gndCachedDevice === device) {\n            return _gndLayout;\n        }\n        _gndLayout = device.createBindGroupLayout({\n            label: \"ground-material\",\n            entries: [\n                { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: \"uniform\" } },\n                { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: \"float\", viewDimension: \"2d\" } },\n                { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: \"filtering\" } },\n            ],\n        });\n        _gndCachedDevice = device;\n        return _gndLayout;\n    }\n\n    return {\n        getPipeline(engine, sig) {\n            const device = engine._device;\n            if (_gndCachedDevice !== device) {\n                _gndPipelines.clear();\n                _gndLayout = null;\n                _gndCachedDevice = device;\n            }\n            const key = `${+enableNoise}|${targetSignatureKey(sig)}`;\n            const cached = _gndPipelines.get(key);\n            if (cached) {\n                return cached;\n            }\n            const vertModule = device.createShaderModule({ code: SCENE_UBO_WGSL + groundVertSrc, label: \"ground-vert\" });\n            const fragModule = device.createShaderModule({ code: fragCode, label: \"ground-frag\" });\n\n            // Matches BJS rp_8: premultiplied alpha blend, depthWrite=false\n            const pipeline = device.createRenderPipeline({\n                label: \"ground-pipeline\",\n                layout: device.createPipelineLayout({ bindGroupLayouts: [getSceneBindGroupLayout(engine), getLayout(engine)] }),\n                vertex: {\n                    module: vertModule,\n                    entryPoint: \"main\",\n                    buffers: [\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                        { arrayStride: 8, attributes: [{ shaderLocation: 2, offset: 0, format: \"float32x2\" as GPUVertexFormat }] },\n                    ],\n                },\n                fragment: {\n                    module: fragModule,\n                    entryPoint: \"main\",\n                    targets: [\n                        {\n                            format: sig._colorFormat!,\n                            blend: {\n                                color: { srcFactor: \"one\", dstFactor: \"one-minus-src-alpha\", operation: \"add\" },\n                                alpha: { srcFactor: \"one\", dstFactor: \"one-minus-src-alpha\", operation: \"add\" },\n                            },\n                        },\n                    ],\n                },\n                depthStencil: {\n                    format: sig._depthStencilFormat ?? \"depth24plus-stencil8\",\n                    depthCompare: sig._depthCompare ?? \"greater-equal\",\n                    depthWriteEnabled: false,\n                },\n                multisample: { count: sig._sampleCount },\n                primitive: { topology: \"triangle-list\", cullMode: \"back\", frontFace: sig._flipY ? \"cw\" : \"ccw\" },\n            });\n            _gndPipelines.set(key, pipeline);\n            return pipeline;\n        },\n\n        createBindGroup(engine, meshUBO, groundTextureView, groundSampler) {\n            const device = engine._device;\n            return device.createBindGroup({\n                layout: getLayout(engine),\n                entries: [\n                    { binding: 0, resource: { buffer: meshUBO } },\n                    { binding: 1, resource: groundTextureView },\n                    { binding: 2, resource: groundSampler },\n                ],\n            });\n        },\n    };\n}\n\n// ─── Ground Mesh Data ───────────────────────────────────────────────────────\n\n/** Ground quad (4 verts, 6 indices — matches BJS CreatePlane with BACKSIDE).\n *  XY plane, normals +Z (become +Y after world rotation). */\nfunction createGroundBuffers(\n    engine: EngineContext,\n    groundSize: number\n): {\n    posBuffer: GPUBuffer;\n    normBuffer: GPUBuffer;\n    uvBuffer: GPUBuffer;\n    idxBuffer: GPUBuffer;\n    idxCount: number;\n} {\n    const h = groundSize / 2;\n    // prettier-ignore\n    const positions = new Float32Array([\n    -h, -h, 0,\n     h, -h, 0,\n     h,  h, 0,\n    -h,  h, 0,\n  ]);\n    // prettier-ignore\n    const normals = new Float32Array([\n    0, 0, 1,  0, 0, 1,  0, 0, 1,  0, 0, 1,\n  ]);\n    // prettier-ignore\n    const uvs = new Float32Array([\n    0, 0,  1, 0,  1, 1,  0, 1,\n  ]);\n    // BACKSIDE winding\n    // prettier-ignore\n    const indices = new Uint16Array([0, 2, 1, 0, 3, 2]);\n\n    return {\n        posBuffer: createMappedBuffer(engine, positions, GPUBufferUsage.VERTEX),\n        normBuffer: createMappedBuffer(engine, normals, GPUBufferUsage.VERTEX),\n        uvBuffer: createMappedBuffer(engine, uvs, GPUBufferUsage.VERTEX),\n        idxBuffer: createMappedBuffer(engine, indices, GPUBufferUsage.INDEX),\n        idxCount: 6,\n    };\n}\n\n// ─── Ground UBO ─────────────────────────────────────────────────────────────\n\nfunction createBgMeshUBO(engine: EngineContext, world: Mat4, primaryColor: [number, number, number]): GPUBuffer {\n    const data = new Float32Array(BG_MESH_UNIFORM_SIZE / 4);\n    data.set(world, 0); // offset 0: world mat4x4\n    data[16] = primaryColor[0]; // offset 64: primaryColor.r\n    data[17] = primaryColor[1]; // offset 68: primaryColor.g\n    data[18] = primaryColor[2]; // offset 72: primaryColor.b\n    data[19] = 0.9; // offset 76: alpha (BJS default groundOpacity)\n    data[20] = 0;\n    data[21] = 0;\n    data[22] = 0; // offset 80: backgroundCenter\n    return createUniformBuffer(engine, data);\n}\n\n// ─── Ground Texture ─────────────────────────────────────────────────────────\n\n/** Load a ground diffuse texture from URL and upload to GPU.\n *  Falls back to a 1×1 white pixel if no URL provided. */\nasync function loadGroundTexture(engine: EngineContext, url?: string, preloadedImage?: Promise<ImageBitmap>): Promise<GPUTexture> {\n    const device = engine._device;\n    if (!url) {\n        const tex = device.createTexture({\n            size: [1, 1],\n            format: \"rgba8unorm\",\n            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,\n        });\n        device.queue.writeTexture({ texture: tex }, new Uint8Array([255, 255, 255, 255]), { bytesPerRow: 4 }, [1, 1]);\n        return tex;\n    }\n    // Use pre-fetched image if available (started early in loadEnvironment)\n    const bmp = preloadedImage\n        ? await preloadedImage\n        : await fetch(url)\n              .then((r) => r.blob())\n              .then((b) => createImageBitmap(b, { premultiplyAlpha: \"none\" }));\n    const tex = device.createTexture({\n        size: [bmp.width, bmp.height],\n        format: \"rgba8unorm\",\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,\n    });\n    device.queue.copyExternalImageToTexture({ source: bmp }, { texture: tex }, [bmp.width, bmp.height]);\n    bmp.close();\n    return tex;\n}\n"],"names":["tex"],"mappings":";;AAAA,MAAA,gBAAe;ACAf,MAAA,gBAAe;ACsBf,MAAM,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmB9B,MAAM,uBAAuB;AAG7B,eAAsB,sBAClB,QACA,YACA,cACA,cACA,kBACA,oBACA,cAAc,MACK;AACnB,QAAM,WAAW,iBAAiB,yBAAyB,cAAc,cAAc,kBAAkB;AACzG,QAAM,SAAS,qBAAqB,aAAa,QAAQ;AAKzD,QAAM,MAAM;AACZ,QAAM,cAAc,IAAI,aAAa,EAAE;AACvC,cAAY,CAAC,IAAI;AACjB,cAAY,CAAC,IAAI;AACjB,cAAY,CAAC,IAAI;AACjB,cAAY,CAAC,IAAI;AACjB,cAAY,EAAE,IAAI;AAClB,cAAY,EAAE,IAAI,aAAa,CAAC;AAChC,cAAY,EAAE,IAAI,aAAa,CAAC;AAChC,cAAY,EAAE,IAAI,aAAa,CAAC;AAChC,cAAY,EAAE,IAAI;AAElB,QAAM,UAAU,oBAAoB,QAAQ,UAAU;AACtD,QAAM,SAAS,gBAAgB,QAAQ,aAAa,YAAY;AAEhE,QAAM,YAAY,MAAM,kBAAkB,QAAQ,kBAAkB,kBAAkB;AACtF,QAAM,gBAAgB,UAAU,WAAA;AAChC,QAAM,aAAa,mBAAmB,MAAM;AAC5C,QAAM,QAAQ,OAAO,gBAAgB,QAAQ,QAAQ,eAAe,UAAU;AAE9E,QAAM,IAAgB;AAAA,IAClB,OAAO;AAAA;AAAA,IACP,eAAe;AAAA,IACf,KAAK,KAAK,KAAK;AACX,aAAO;AAAA,QACH,YAAY;AAAA,QACZ,UAAU,OAAO,YAAY,KAAsB,GAAG;AAAA,QACtD,KAAK,MAAM;AACP,eAAK,aAAa,GAAG,KAAK;AAC1B,eAAK,gBAAgB,GAAG,QAAQ,SAAS;AACzC,eAAK,gBAAgB,GAAG,QAAQ,UAAU;AAC1C,eAAK,gBAAgB,GAAG,QAAQ,QAAQ;AACxC,eAAK,eAAe,QAAQ,WAAW,QAAQ;AAC/C,eAAK,YAAY,QAAQ,QAAQ;AACjC,iBAAO;AAAA,QACX;AAAA,MAAA;AAAA,IAER;AAAA,EAAA;AAEJ,SAAO;AACX;AAWA,MAAM,oCAAoB,IAAA;AAC1B,IAAI,aAAwC;AAC5C,IAAI,mBAAqC;AAEzC,SAAS,qBAAqB,aAAsB,UAAkC;AAClF,WAAS,UAAU,QAA2C;AAC1D,UAAM,SAAS,OAAO;AACtB,QAAI,cAAc,qBAAqB,QAAQ;AAC3C,aAAO;AAAA,IACX;AACA,iBAAa,OAAO,sBAAsB;AAAA,MACtC,OAAO;AAAA,MACP,SAAS;AAAA,QACL,EAAE,SAAS,GAAG,YAAY,eAAe,SAAS,eAAe,UAAU,QAAQ,EAAE,MAAM,UAAA,EAAU;AAAA,QACrG,EAAE,SAAS,GAAG,YAAY,eAAe,UAAU,SAAS,EAAE,YAAY,SAAS,eAAe,KAAA,EAAK;AAAA,QACvG,EAAE,SAAS,GAAG,YAAY,eAAe,UAAU,SAAS,EAAE,MAAM,YAAA,EAAY;AAAA,MAAE;AAAA,IACtF,CACH;AACD,uBAAmB;AACnB,WAAO;AAAA,EACX;AAEA,SAAO;AAAA,IACH,YAAY,QAAQ,KAAK;AACrB,YAAM,SAAS,OAAO;AACtB,UAAI,qBAAqB,QAAQ;AAC7B,sBAAc,MAAA;AACd,qBAAa;AACb,2BAAmB;AAAA,MACvB;AACA,YAAM,MAAM,GAAG,CAAC,WAAW,IAAI,mBAAmB,GAAG,CAAC;AACtD,YAAM,SAAS,cAAc,IAAI,GAAG;AACpC,UAAI,QAAQ;AACR,eAAO;AAAA,MACX;AACA,YAAM,aAAa,OAAO,mBAAmB,EAAE,MAAM,iBAAiB,eAAe,OAAO,eAAe;AAC3G,YAAM,aAAa,OAAO,mBAAmB,EAAE,MAAM,UAAU,OAAO,eAAe;AAGrF,YAAM,WAAW,OAAO,qBAAqB;AAAA,QACzC,OAAO;AAAA,QACP,QAAQ,OAAO,qBAAqB,EAAE,kBAAkB,CAAC,wBAAwB,MAAM,GAAG,UAAU,MAAM,CAAC,GAAG;AAAA,QAC9G,QAAQ;AAAA,UACJ,QAAQ;AAAA,UACR,YAAY;AAAA,UACZ,SAAS;AAAA,YACL,EAAE,aAAa,IAAI,YAAY,CAAC,EAAE,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,YAAA,CAAgC,EAAA;AAAA,YACxG,EAAE,aAAa,IAAI,YAAY,CAAC,EAAE,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,YAAA,CAAgC,EAAA;AAAA,YACxG,EAAE,aAAa,GAAG,YAAY,CAAC,EAAE,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,YAAA,CAAgC,EAAA;AAAA,UAAE;AAAA,QAC7G;AAAA,QAEJ,UAAU;AAAA,UACN,QAAQ;AAAA,UACR,YAAY;AAAA,UACZ,SAAS;AAAA,YACL;AAAA,cACI,QAAQ,IAAI;AAAA,cACZ,OAAO;AAAA,gBACH,OAAO,EAAE,WAAW,OAAO,WAAW,uBAAuB,WAAW,MAAA;AAAA,gBACxE,OAAO,EAAE,WAAW,OAAO,WAAW,uBAAuB,WAAW,MAAA;AAAA,cAAM;AAAA,YAClF;AAAA,UACJ;AAAA,QACJ;AAAA,QAEJ,cAAc;AAAA,UACV,QAAQ,IAAI,uBAAuB;AAAA,UACnC,cAAc,IAAI,iBAAiB;AAAA,UACnC,mBAAmB;AAAA,QAAA;AAAA,QAEvB,aAAa,EAAE,OAAO,IAAI,aAAA;AAAA,QAC1B,WAAW,EAAE,UAAU,iBAAiB,UAAU,QAAQ,WAAW,IAAI,SAAS,OAAO,MAAA;AAAA,MAAM,CAClG;AACD,oBAAc,IAAI,KAAK,QAAQ;AAC/B,aAAO;AAAA,IACX;AAAA,IAEA,gBAAgB,QAAQ,SAAS,mBAAmB,eAAe;AAC/D,YAAM,SAAS,OAAO;AACtB,aAAO,OAAO,gBAAgB;AAAA,QAC1B,QAAQ,UAAU,MAAM;AAAA,QACxB,SAAS;AAAA,UACL,EAAE,SAAS,GAAG,UAAU,EAAE,QAAQ,UAAQ;AAAA,UAC1C,EAAE,SAAS,GAAG,UAAU,kBAAA;AAAA,UACxB,EAAE,SAAS,GAAG,UAAU,cAAA;AAAA,QAAc;AAAA,MAC1C,CACH;AAAA,IACL;AAAA,EAAA;AAER;AAMA,SAAS,oBACL,QACA,YAOF;AACE,QAAM,IAAI,aAAa;AAEvB,QAAM,YAAY,IAAI,aAAa;AAAA,IACnC,CAAC;AAAA,IAAG,CAAC;AAAA,IAAG;AAAA,IACP;AAAA,IAAG,CAAC;AAAA,IAAG;AAAA,IACP;AAAA,IAAI;AAAA,IAAG;AAAA,IACR,CAAC;AAAA,IAAI;AAAA,IAAG;AAAA,EAAA,CACT;AAEC,QAAM,UAAU,IAAI,aAAa;AAAA,IACjC;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,EAAA,CACrC;AAEC,QAAM,MAAM,IAAI,aAAa;AAAA,IAC7B;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,EAAA,CACzB;AAGC,QAAM,UAAU,IAAI,YAAY,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;AAElD,SAAO;AAAA,IACH,WAAW,mBAAmB,QAAQ,WAAW,eAAe,MAAM;AAAA,IACtE,YAAY,mBAAmB,QAAQ,SAAS,eAAe,MAAM;AAAA,IACrE,UAAU,mBAAmB,QAAQ,KAAK,eAAe,MAAM;AAAA,IAC/D,WAAW,mBAAmB,QAAQ,SAAS,eAAe,KAAK;AAAA,IACnE,UAAU;AAAA,EAAA;AAElB;AAIA,SAAS,gBAAgB,QAAuB,OAAa,cAAmD;AAC5G,QAAM,OAAO,IAAI,aAAa,uBAAuB,CAAC;AACtD,OAAK,IAAI,OAAO,CAAC;AACjB,OAAK,EAAE,IAAI,aAAa,CAAC;AACzB,OAAK,EAAE,IAAI,aAAa,CAAC;AACzB,OAAK,EAAE,IAAI,aAAa,CAAC;AACzB,OAAK,EAAE,IAAI;AACX,OAAK,EAAE,IAAI;AACX,OAAK,EAAE,IAAI;AACX,OAAK,EAAE,IAAI;AACX,SAAO,oBAAoB,QAAQ,IAAI;AAC3C;AAMA,eAAe,kBAAkB,QAAuB,KAAc,gBAA4D;AAC9H,QAAM,SAAS,OAAO;AACtB,MAAI,CAAC,KAAK;AACN,UAAMA,OAAM,OAAO,cAAc;AAAA,MAC7B,MAAM,CAAC,GAAG,CAAC;AAAA,MACX,QAAQ;AAAA,MACR,OAAO,gBAAgB,kBAAkB,gBAAgB;AAAA,IAAA,CAC5D;AACD,WAAO,MAAM,aAAa,EAAE,SAASA,QAAO,IAAI,WAAW,CAAC,KAAK,KAAK,KAAK,GAAG,CAAC,GAAG,EAAE,aAAa,KAAK,CAAC,GAAG,CAAC,CAAC;AAC5G,WAAOA;AAAAA,EACX;AAEA,QAAM,MAAM,iBACN,MAAM,iBACN,MAAM,MAAM,GAAG,EACV,KAAK,CAAC,MAAM,EAAE,MAAM,EACpB,KAAK,CAAC,MAAM,kBAAkB,GAAG,EAAE,kBAAkB,OAAA,CAAQ,CAAC;AACzE,QAAM,MAAM,OAAO,cAAc;AAAA,IAC7B,MAAM,CAAC,IAAI,OAAO,IAAI,MAAM;AAAA,IAC5B,QAAQ;AAAA,IACR,OAAO,gBAAgB,kBAAkB,gBAAgB,WAAW,gBAAgB;AAAA,EAAA,CACvF;AACD,SAAO,MAAM,2BAA2B,EAAE,QAAQ,OAAO,EAAE,SAAS,IAAA,GAAO,CAAC,IAAI,OAAO,IAAI,MAAM,CAAC;AAClG,MAAI,MAAA;AACJ,SAAO;AACX;"}

package/background-hdr-skybox-c4uuTmkP.js

@@ -0,0 +1,179 @@
+import { c as createCubemapSkyboxMaterial } from "./cubemap-skybox-material-DvXMVc4k.js";
+import { s as skyboxVertSrc } from "./skybox.vertex-DJgi072W.js";
+import { e as createMappedBuffer, aY as createUniformBuffer, aW as SCENE_UBO_WGSL } from "./index-C8HOR2sB.js";
+const skyboxHdrFragSrc = "// HDR Skybox Fragment Shader — samples HDR environment cubemap with image processing.\n// Used when scene has an HDR environment rendered as the background.\n// Matches BJS BackgroundMaterial: cubemap at LOD 0 + exposure + gamma + contrast.\n\nstruct MeshUniforms {\n  world: mat4x4<f32>,\n  primaryColor: vec3<f32>,\n  _pad: f32,\n  skyOutputColor: vec3<f32>,\n  _pad2: f32,\n  exposureLinear: f32,\n  contrast: f32,\n  _pad3: f32,\n  _pad4: f32,\n};\n\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n@group(1) @binding(1) var envCubemap: texture_cube<f32>;\n@group(1) @binding(2) var envSampler: sampler;\n\nstruct FragmentInput {\n  @location(0) positionUVW: vec3<f32>,\n  @location(1) positionW: vec3<f32>,\n};\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n  let dir = normalize(input.positionUVW);\n  var color = textureSampleLevel(envCubemap, envSampler, dir, 0.0).rgb;\n\n  // Image processing: exposure → gamma → contrast (matches BJS applyImageProcessing)\n  color *= mesh.exposureLinear;\n  color = pow(color, vec3<f32>(1.0 / 2.2));\n  color = clamp(color, vec3<f32>(0.0), vec3<f32>(1.0));\n\n  let highContrast = color * color * (3.0 - 2.0 * color);\n  if (mesh.contrast < 1.0) { color = mix(vec3<f32>(0.5), color, mesh.contrast); }\n  else { color = mix(color, highContrast, mesh.contrast - 1.0); }\n  color = max(color, vec3<f32>(0.0));\n\n  return vec4<f32>(color, 1.0);\n}\n";
+const SKY_HDR_UNIFORM_SIZE = 112;
+function createSkyboxBuffers(engine, S) {
+  const positions = new Float32Array([
+    S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    S,
+    S,
+    S,
+    S,
+    S,
+    S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    S,
+    S,
+    S,
+    S,
+    -S,
+    S,
+    S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    -S,
+    -S,
+    S,
+    -S,
+    -S,
+    S,
+    S,
+    -S,
+    S,
+    -S,
+    S,
+    S,
+    -S,
+    S,
+    S,
+    S,
+    S,
+    -S,
+    S,
+    S,
+    -S,
+    -S,
+    -S,
+    -S,
+    -S,
+    -S,
+    -S,
+    S
+  ]);
+  const indices = new Uint16Array([
+    2,
+    1,
+    0,
+    3,
+    2,
+    0,
+    6,
+    5,
+    4,
+    7,
+    6,
+    4,
+    10,
+    9,
+    8,
+    11,
+    10,
+    8,
+    14,
+    13,
+    12,
+    15,
+    14,
+    12,
+    18,
+    17,
+    16,
+    19,
+    18,
+    16,
+    22,
+    21,
+    20,
+    23,
+    22,
+    20
+  ]);
+  return {
+    posBuffer: createMappedBuffer(engine, positions, GPUBufferUsage.VERTEX),
+    idxBuffer: createMappedBuffer(engine, indices, GPUBufferUsage.INDEX),
+    idxCount: 36
+  };
+}
+function buildSkyboxWorldMatrix(rootPosition) {
+  const world = new Float32Array(16);
+  world[0] = 1;
+  world[5] = 1;
+  world[10] = 1;
+  world[15] = 1;
+  world[12] = rootPosition[0];
+  world[13] = rootPosition[1];
+  world[14] = rootPosition[2];
+  return world;
+}
+function buildHdrSkyboxRenderable(scene, envTextures, skyHalfSize, rootPosition, primaryColor) {
+  const engine = scene.engine;
+  const skyboxWorld = buildSkyboxWorldMatrix(rootPosition);
+  const cc = scene.clearColor;
+  const skyBufs = createSkyboxBuffers(engine, skyHalfSize);
+  const mat = createCubemapSkyboxMaterial("skybox-hdr", SCENE_UBO_WGSL + skyboxVertSrc, skyboxHdrFragSrc);
+  const ubo = createSkyHdrMeshUBO(engine, skyboxWorld, primaryColor, [cc.r, cc.g, cc.b], scene.imageProcessing.exposure, scene.imageProcessing.contrast);
+  const bindGroup = mat.createBindGroup(engine, ubo, envTextures.specularCubeView, envTextures.cubeSampler);
+  const r = {
+    order: 0,
+    isTransparent: false,
+    bind(eng, sig) {
+      return {
+        renderable: r,
+        pipeline: mat.getPipeline(eng, sig),
+        draw(pass) {
+          pass.setBindGroup(1, bindGroup);
+          pass.setVertexBuffer(0, skyBufs.posBuffer);
+          pass.setIndexBuffer(skyBufs.idxBuffer, "uint16");
+          pass.drawIndexed(skyBufs.idxCount);
+          return 1;
+        }
+      };
+    }
+  };
+  return r;
+}
+function createSkyHdrMeshUBO(engine, world, primaryColor, skyOutputColor, exposure, contrast) {
+  const data = new Float32Array(SKY_HDR_UNIFORM_SIZE / 4);
+  data.set(world, 0);
+  data[16] = primaryColor[0];
+  data[17] = primaryColor[1];
+  data[18] = primaryColor[2];
+  data[20] = skyOutputColor[0];
+  data[21] = skyOutputColor[1];
+  data[22] = skyOutputColor[2];
+  data[24] = exposure;
+  data[25] = contrast;
+  return createUniformBuffer(engine, data);
+}
+export {
+  buildHdrSkyboxRenderable
+};
+//# sourceMappingURL=background-hdr-skybox-c4uuTmkP.js.map

package/background-hdr-skybox-c4uuTmkP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-hdr-skybox-c4uuTmkP.js","sources":["../shaders/skybox-hdr.fragment.wgsl?raw","../src/material/pbr/background-hdr-skybox.ts"],"sourcesContent":["export default \"// HDR Skybox Fragment Shader — samples HDR environment cubemap with image processing.\\n// Used when scene has an HDR environment rendered as the background.\\n// Matches BJS BackgroundMaterial: cubemap at LOD 0 + exposure + gamma + contrast.\\n\\nstruct MeshUniforms {\\n  world: mat4x4<f32>,\\n  primaryColor: vec3<f32>,\\n  _pad: f32,\\n  skyOutputColor: vec3<f32>,\\n  _pad2: f32,\\n  exposureLinear: f32,\\n  contrast: f32,\\n  _pad3: f32,\\n  _pad4: f32,\\n};\\n\\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\\n@group(1) @binding(1) var envCubemap: texture_cube<f32>;\\n@group(1) @binding(2) var envSampler: sampler;\\n\\nstruct FragmentInput {\\n  @location(0) positionUVW: vec3<f32>,\\n  @location(1) positionW: vec3<f32>,\\n};\\n\\n@fragment\\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\\n  let dir = normalize(input.positionUVW);\\n  var color = textureSampleLevel(envCubemap, envSampler, dir, 0.0).rgb;\\n\\n  // Image processing: exposure → gamma → contrast (matches BJS applyImageProcessing)\\n  color *= mesh.exposureLinear;\\n  color = pow(color, vec3<f32>(1.0 / 2.2));\\n  color = clamp(color, vec3<f32>(0.0), vec3<f32>(1.0));\\n\\n  let highContrast = color * color * (3.0 - 2.0 * color);\\n  if (mesh.contrast < 1.0) { color = mix(vec3<f32>(0.5), color, mesh.contrast); }\\n  else { color = mix(color, highContrast, mesh.contrast - 1.0); }\\n  color = max(color, vec3<f32>(0.0));\\n\\n  return vec4<f32>(color, 1.0);\\n}\\n\"","/** HDR cubemap skybox — lazy-loaded only when useCubemapSkybox is true.\n *  Contains the HDR skybox material, shader, UBO, and skybox geometry.\n *  Self-contained: computes scene bounds and builds a full Renderable.\n *  Tree-shaken away from scenes that use the default solid-color skybox. */\n\nimport type { SceneContext } from \"../../scene/scene.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { EnvironmentTextures } from \"../../loader-env/load-env.js\";\nimport type { Mat4 } from \"../../math/types.js\";\nimport type { Renderable } from \"../../render/renderable.js\";\nimport { createCubemapSkyboxMaterial } from \"./cubemap-skybox-material.js\";\nimport skyboxVertSrc from \"../../../shaders/skybox.vertex.wgsl?raw\";\nimport skyboxHdrFragSrc from \"../../../shaders/skybox-hdr.fragment.wgsl?raw\";\nimport { SCENE_UBO_WGSL } from \"../../shader/scene-uniforms.js\";\nimport { createMappedBuffer, createUniformBuffer } from \"../../resource/gpu-buffers.js\";\n\nconst SKY_HDR_UNIFORM_SIZE = 112; // mat4x4 + primaryColor vec3 + pad + skyOutputColor vec3 + pad + exposure + contrast + pad2\n\nfunction createSkyboxBuffers(engine: EngineContext, S: number): { posBuffer: GPUBuffer; idxBuffer: GPUBuffer; idxCount: number } {\n    // prettier-ignore\n    const positions = new Float32Array([\n     S,-S, S, -S,-S, S, -S, S, S,  S, S, S,\n     S, S,-S, -S, S,-S, -S,-S,-S,  S,-S,-S,\n     S, S,-S,  S,-S,-S,  S,-S, S,  S, S, S,\n    -S, S, S, -S,-S, S, -S,-S,-S, -S, S,-S,\n    -S, S, S, -S, S,-S,  S, S,-S,  S, S, S,\n     S,-S, S,  S,-S,-S, -S,-S,-S, -S,-S, S,\n  ]);\n    // prettier-ignore\n    const indices = new Uint16Array([\n     2, 1, 0,  3, 2, 0,   6, 5, 4,  7, 6, 4,\n    10, 9, 8, 11,10, 8,  14,13,12, 15,14,12,\n    18,17,16, 19,18,16,  22,21,20, 23,22,20,\n  ]);\n    return {\n        posBuffer: createMappedBuffer(engine, positions, GPUBufferUsage.VERTEX),\n        idxBuffer: createMappedBuffer(engine, indices, GPUBufferUsage.INDEX),\n        idxCount: 36,\n    };\n}\n\nfunction buildSkyboxWorldMatrix(rootPosition: [number, number, number]): Mat4 {\n    const world = new Float32Array(16) as Mat4;\n    world[0] = 1;\n    world[5] = 1;\n    world[10] = 1;\n    world[15] = 1;\n    world[12] = rootPosition[0];\n    world[13] = rootPosition[1];\n    world[14] = rootPosition[2];\n    return world;\n}\n\n/** Build an HDR cubemap skybox as a complete Renderable (order 0). */\nexport function buildHdrSkyboxRenderable(\n    scene: SceneContext,\n    envTextures: EnvironmentTextures,\n    skyHalfSize: number,\n    rootPosition: [number, number, number],\n    primaryColor: [number, number, number]\n): Renderable {\n    const engine = scene.engine;\n\n    const skyboxWorld = buildSkyboxWorldMatrix(rootPosition);\n\n    const cc = scene.clearColor;\n\n    const skyBufs = createSkyboxBuffers(engine, skyHalfSize);\n    const mat = createCubemapSkyboxMaterial(\"skybox-hdr\", SCENE_UBO_WGSL + skyboxVertSrc, skyboxHdrFragSrc);\n    const ubo = createSkyHdrMeshUBO(engine, skyboxWorld, primaryColor, [cc.r, cc.g, cc.b], scene.imageProcessing.exposure, scene.imageProcessing.contrast);\n\n    const bindGroup = mat.createBindGroup(engine, ubo, envTextures.specularCubeView!, envTextures.cubeSampler);\n\n    const r: Renderable = {\n        order: 0,\n        isTransparent: false,\n        bind(eng, sig) {\n            return {\n                renderable: r,\n                pipeline: mat.getPipeline(eng as EngineContext, sig),\n                draw(pass) {\n                    pass.setBindGroup(1, bindGroup);\n                    pass.setVertexBuffer(0, skyBufs.posBuffer);\n                    pass.setIndexBuffer(skyBufs.idxBuffer, \"uint16\");\n                    pass.drawIndexed(skyBufs.idxCount);\n                    return 1;\n                },\n            };\n        },\n    };\n    return r;\n}\n\n// ─── HDR Skybox UBO ─────────────────────────────────────────────────────────────\n\nfunction createSkyHdrMeshUBO(\n    engine: EngineContext,\n    world: Float32Array,\n    primaryColor: [number, number, number],\n    skyOutputColor: [number, number, number],\n    exposure: number,\n    contrast: number\n): GPUBuffer {\n    const data = new Float32Array(SKY_HDR_UNIFORM_SIZE / 4);\n    data.set(world, 0);\n    data[16] = primaryColor[0];\n    data[17] = primaryColor[1];\n    data[18] = primaryColor[2];\n    data[20] = skyOutputColor[0];\n    data[21] = skyOutputColor[1];\n    data[22] = skyOutputColor[2];\n    data[24] = exposure; // exposureLinear\n    data[25] = contrast; // contrast\n    return createUniformBuffer(engine, data);\n}\n"],"names":[],"mappings":"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"}