@d5techs/3dgs-lib 1.4.70 → 1.4.72

package/dist/3dgs-lib.cjs

@@ -2098,103 +2098,6 @@ class SceneAidsRenderer {
     this.axesBindGroup = null;
   }
 }
-async function loadHdr(url) {
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`HdrLoader: fetch failed ${url} (${res.status})`);
-  const buf = await res.arrayBuffer();
-  return parseHdr(new Uint8Array(buf));
-}
-function parseHdr(bytes) {
-  let pos = 0;
-  const readLine = () => {
-    let line = "";
-    while (pos < bytes.length) {
-      const c = bytes[pos++];
-      if (c === 10) return line;
-      line += String.fromCharCode(c);
-    }
-    return line;
-  };
-  const magic = readLine();
-  if (!magic.startsWith("#?")) throw new Error("HdrLoader: not a Radiance HDR file");
-  while (pos < bytes.length) {
-    const line = readLine();
-    if (line.length === 0) break;
-  }
-  const resLine = readLine();
-  const m = resLine.match(/-Y\s+(\d+)\s+\+X\s+(\d+)/);
-  if (!m) throw new Error("HdrLoader: unsupported resolution format: " + resLine);
-  const height = parseInt(m[1], 10);
-  const width = parseInt(m[2], 10);
-  const rgbe = new Uint8Array(width * height * 4);
-  for (let y = 0; y < height; y++) {
-    const scanline = decodeScanline(bytes, pos, width);
-    pos = scanline.newPos;
-    rgbe.set(scanline.pixels, y * width * 4);
-  }
-  const data = new Float32Array(width * height * 4);
-  for (let i = 0; i < width * height; i++) {
-    const r = rgbe[i * 4];
-    const g = rgbe[i * 4 + 1];
-    const b = rgbe[i * 4 + 2];
-    const e = rgbe[i * 4 + 3];
-    if (e === 0) {
-      data[i * 4] = 0;
-      data[i * 4 + 1] = 0;
-      data[i * 4 + 2] = 0;
-    } else {
-      const scale = Math.pow(2, e - 128 - 8);
-      data[i * 4] = r * scale;
-      data[i * 4 + 1] = g * scale;
-      data[i * 4 + 2] = b * scale;
-    }
-    data[i * 4 + 3] = 1;
-  }
-  return { width, height, data };
-}
-function decodeScanline(bytes, pos, width) {
-  const pixels = new Uint8Array(width * 4);
-  if (width < 8 || width > 32767) {
-    for (let i = 0; i < width * 4; i++) pixels[i] = bytes[pos++];
-    return { pixels, newPos: pos };
-  }
-  const b0 = bytes[pos], b1 = bytes[pos + 1], b22 = bytes[pos + 2], b3 = bytes[pos + 3];
-  if (b0 !== 2 || b1 !== 2 || (b22 & 128) !== 0) {
-    for (let i = 0; i < width * 4; i++) pixels[i] = bytes[pos++];
-    return { pixels, newPos: pos };
-  }
-  const lineWidth = b22 << 8 | b3;
-  if (lineWidth !== width) throw new Error("HdrLoader: scanline width mismatch");
-  pos += 4;
-  for (let ch = 0; ch < 4; ch++) {
-    let x = 0;
-    while (x < width) {
-      const code = bytes[pos++];
-      if (code > 128) {
-        const count = code - 128;
-        const val = bytes[pos++];
-        for (let i = 0; i < count; i++) pixels[(x + i) * 4 + ch] = val;
-        x += count;
-      } else {
-        for (let i = 0; i < code; i++) pixels[(x + i) * 4 + ch] = bytes[pos++];
-        x += code;
-      }
-    }
-  }
-  return { pixels, newPos: pos };
-}
-const f32Buf = new Float32Array(1);
-const u32Buf = new Uint32Array(f32Buf.buffer);
-function float32ToFloat16(val) {
-  f32Buf[0] = val;
-  const f = u32Buf[0];
-  const sign = f >> 16 & 32768;
-  const exp = (f >> 23 & 255) - 127 + 15;
-  const frac = f >> 13 & 1023;
-  if (exp <= 0) return sign;
-  if (exp >= 31) return sign | 31744;
-  return sign | exp << 10 | frac;
-}
 const CUBE_WGSL = (
   /* wgsl */
   `
@@ -2211,62 +2114,8 @@ struct V { @builtin(position) pos: vec4<f32>, @location(0) dir: vec3<f32> };
     return o;
 }
 @fragment fn fs(i: V) -> @location(0) vec4<f32> {
-    return vec4(textureSample(cubeTexture, cubeSampler, normalize(i.dir)).rgb, 1.);
-}`
-);
-const EQUIRECT_WGSL = (
-  /* wgsl */
-  `
-struct Uniforms { col0: vec4<f32>, col1: vec4<f32>, col2: vec4<f32>, cam: vec4<f32> };
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var envSampler: sampler;
-@group(0) @binding(2) var envTexture: texture_2d<f32>;
-struct V { @builtin(position) pos: vec4<f32>, @location(0) dir: vec3<f32> };
-const PI: f32 = 3.14159265358979;
-
-fn dirToUv(d: vec3<f32>) -> vec2<f32> {
-    return vec2(atan2(d.z, d.x) / (2.*PI) + .5, 1. - (asin(clamp(d.y,-1.,1.)) / PI + .5));
-}
-
-@vertex fn vs(@builtin(vertex_index) vi: u32) -> V {
-    let ps = array<vec2<f32>,3>(vec2(-1.,-1.),vec2(3.,-1.),vec2(-1.,3.));
-    var o: V; let p = ps[vi]; o.pos = vec4(p, 0., 1.);
-    let e = vec3(p.x*u.col0.w, p.y*u.col1.w, -1.);
-    o.dir = vec3(dot(u.col0.xyz,e), dot(u.col1.xyz,e), dot(u.col2.xyz,e));
-    return o;
-}
-
-@fragment fn fs(i: V) -> @location(0) vec4<f32> {
-    let d  = normalize(i.dir);
-    let cx = u.cam.x;
-    let cy = max(u.cam.y, 0.1);   // clamp: camera always above ground
-    let cz = u.cam.z;
-    let captureH = u.cam.w;
-
-    // --- sky: sample HDR with original direction ---
-    let skyUv = dirToUv(d);
-
-    // --- ground: camera-centered, height-independent projection ---
-    let dyClamped = min(d.y, -0.0001);
-    let ratio = d.x / dyClamped;
-    let ratioZ = d.z / dyClamped;
-
-    // K = captureH controls ground spread (smaller = more horizon, larger = more nadir)
-    let groundDir = normalize(vec3(-ratio, -captureH, -ratioZ));
-    let groundUv  = dirToUv(groundDir);
-
-    // --- sample both (uniform control flow) ---
-    let skyColor    = textureSample(envTexture, envSampler, skyUv).rgb;
-    let groundColor = textureSample(envTexture, envSampler, groundUv).rgb;
-
-    // Sharp blend at horizon — cy is always > 0 so no aboveGround check needed
-    let horizonBlend = smoothstep(0.002, -0.002, d.y);
-    let c = mix(skyColor, groundColor, horizonBlend);
-
-    // Reinhard tone mapping + gamma
-    let mapped = c / (c + vec3(1.));
-    let gamma  = pow(mapped, vec3(1./2.2));
-    return vec4(gamma, 1.);
+    let d = normalize(i.dir);
+    return vec4(textureSample(cubeTexture, cubeSampler, vec3(-d.x, d.y, d.z)).rgb, 1.);
 }`
 );
 class SkyboxRenderer {
@@ -2277,14 +2126,10 @@ class SkyboxRenderer {
     __publicField(this, "uniformData", new Float32Array(16));
     __publicField(this, "cubePipeline");
     __publicField(this, "cubeBindGroupLayout");
-    __publicField(this, "equirectPipeline");
-    __publicField(this, "equirectBindGroupLayout");
     __publicField(this, "texture", null);
     __publicField(this, "bindGroup", null);
     __publicField(this, "frameReady", false);
-    __publicField(this, "mode", "none");
-    /** Virtual HDR capture height (world units). Controls ground texture spread. */
-    __publicField(this, "groundRadius", 50);
+    __publicField(this, "active", false);
     this.device = device;
     const depthStencil = {
       format: depthFormat,
@@ -2305,30 +2150,15 @@ class SkyboxRenderer {
       primitive: { topology: "triangle-list", cullMode: "none" },
       depthStencil
     });
-    this.equirectBindGroupLayout = device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
-        { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
-        { binding: 2, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "2d" } }
-      ]
-    });
-    this.equirectPipeline = device.createRenderPipeline({
-      layout: device.createPipelineLayout({ bindGroupLayouts: [this.equirectBindGroupLayout] }),
-      vertex: { module: device.createShaderModule({ code: EQUIRECT_WGSL }), entryPoint: "vs" },
-      fragment: { module: device.createShaderModule({ code: EQUIRECT_WGSL }), entryPoint: "fs", targets: [{ format }] },
-      primitive: { topology: "triangle-list", cullMode: "none" },
-      depthStencil
-    });
     this.uniformBuffer = device.createBuffer({
       size: 64,
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
     });
-    this.sampler = device.createSampler({ magFilter: "linear", minFilter: "linear" });
+    this.sampler = device.createSampler({ magFilter: "linear", minFilter: "linear", mipmapFilter: "linear" });
   }
   get isActive() {
-    return this.mode !== "none" && this.texture !== null && this.bindGroup !== null;
+    return this.active && this.texture !== null && this.bindGroup !== null;
   }
-  // ---- cubemap ----
   async loadCubemap(faceUrls) {
     this.clear();
     const bitmaps = await Promise.all(
@@ -2346,10 +2176,12 @@ class SkyboxRenderer {
         throw new Error("SkyboxRenderer: all cubemap faces must share the same dimensions");
       }
     }
+    const mipLevelCount = Math.floor(Math.log2(Math.max(width, height))) + 1;
     const tex = this.device.createTexture({
       dimension: "2d",
       size: [width, height, 6],
       format: "rgba8unorm",
+      mipLevelCount,
       usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
     });
     for (let layer = 0; layer < 6; layer++) {
@@ -2360,6 +2192,7 @@ class SkyboxRenderer {
       );
     }
     bitmaps.forEach((b) => b.close());
+    this.generateMipmaps(tex, width, height, 6, mipLevelCount);
     this.bindGroup = this.device.createBindGroup({
       layout: this.cubeBindGroupLayout,
       entries: [
@@ -2369,41 +2202,9 @@ class SkyboxRenderer {
       ]
     });
     this.texture = tex;
-    this.mode = "cubemap";
-  }
-  // ---- equirectangular HDR ----
-  async loadEquirectangular(url) {
-    this.clear();
-    const hdr = await loadHdr(url);
-    const pixelCount = hdr.width * hdr.height * 4;
-    const f16 = new Uint16Array(pixelCount);
-    for (let i = 0; i < pixelCount; i++) {
-      f16[i] = float32ToFloat16(hdr.data[i]);
-    }
-    const tex = this.device.createTexture({
-      size: [hdr.width, hdr.height],
-      format: "rgba16float",
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
-    });
-    this.device.queue.writeTexture(
-      { texture: tex },
-      f16.buffer,
-      { bytesPerRow: hdr.width * 8, rowsPerImage: hdr.height },
-      { width: hdr.width, height: hdr.height }
-    );
-    this.bindGroup = this.device.createBindGroup({
-      layout: this.equirectBindGroupLayout,
-      entries: [
-        { binding: 0, resource: { buffer: this.uniformBuffer } },
-        { binding: 1, resource: this.sampler },
-        { binding: 2, resource: tex.createView() }
-      ]
-    });
-    this.texture = tex;
-    this.mode = "equirect";
+    this.active = true;
   }
-  // ---- common ----
-  prepareFrame(viewMatrix, projectionMatrix, cameraPosition) {
+  prepareFrame(viewMatrix, projectionMatrix) {
     if (!this.isActive) {
       this.frameReady = false;
       return;
@@ -2421,20 +2222,89 @@ class SkyboxRenderer {
     ud[9] = viewMatrix[9];
     ud[10] = viewMatrix[10];
     ud[11] = 0;
-    ud[12] = cameraPosition ? cameraPosition[0] : 0;
-    ud[13] = cameraPosition ? cameraPosition[1] : 0;
-    ud[14] = cameraPosition ? cameraPosition[2] : 0;
-    ud[15] = this.groundRadius;
     this.device.queue.writeBuffer(this.uniformBuffer, 0, ud);
     this.frameReady = true;
   }
   draw(pass) {
     if (!this.frameReady || !this.bindGroup) return;
-    const pipeline = this.mode === "cubemap" ? this.cubePipeline : this.equirectPipeline;
-    pass.setPipeline(pipeline);
+    pass.setPipeline(this.cubePipeline);
     pass.setBindGroup(0, this.bindGroup);
     pass.draw(3);
   }
+  generateMipmaps(tex, baseWidth, baseHeight, layerCount, mipLevelCount) {
+    if (mipLevelCount <= 1) return;
+    const module2 = this.device.createShaderModule({
+      code: (
+        /* wgsl */
+        `
+        @group(0) @binding(0) var src: texture_2d<f32>;
+        @group(0) @binding(1) var srcSampler: sampler;
+        struct V { @builtin(position) pos: vec4<f32>, @location(0) uv: vec2<f32> };
+        @vertex fn vs(@builtin(vertex_index) vi: u32) -> V {
+          let ps = array<vec2<f32>,3>(vec2(0.,0.),vec2(2.,0.),vec2(0.,2.));
+          var o: V; let p = ps[vi];
+          o.pos = vec4(p * 2. - 1., 0., 1.);
+          o.uv = vec2(p.x, 1. - p.y);
+          return o;
+        }
+        @fragment fn fs(i: V) -> @location(0) vec4<f32> {
+          return textureSample(src, srcSampler, i.uv);
+        }`
+      )
+    });
+    const bgl = this.device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+        { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } }
+      ]
+    });
+    const pipeline = this.device.createRenderPipeline({
+      layout: this.device.createPipelineLayout({ bindGroupLayouts: [bgl] }),
+      vertex: { module: module2, entryPoint: "vs" },
+      fragment: { module: module2, entryPoint: "fs", targets: [{ format: "rgba8unorm" }] },
+      primitive: { topology: "triangle-list" }
+    });
+    const linearSampler = this.device.createSampler({ magFilter: "linear", minFilter: "linear" });
+    const encoder = this.device.createCommandEncoder();
+    for (let level = 1; level < mipLevelCount; level++) {
+      for (let layer = 0; layer < layerCount; layer++) {
+        const srcView = tex.createView({
+          dimension: "2d",
+          baseMipLevel: level - 1,
+          mipLevelCount: 1,
+          baseArrayLayer: layer,
+          arrayLayerCount: 1
+        });
+        const dstView = tex.createView({
+          dimension: "2d",
+          baseMipLevel: level,
+          mipLevelCount: 1,
+          baseArrayLayer: layer,
+          arrayLayerCount: 1
+        });
+        const bg = this.device.createBindGroup({
+          layout: bgl,
+          entries: [
+            { binding: 0, resource: srcView },
+            { binding: 1, resource: linearSampler }
+          ]
+        });
+        const pass = encoder.beginRenderPass({
+          colorAttachments: [{
+            view: dstView,
+            loadOp: "clear",
+            storeOp: "store",
+            clearValue: { r: 0, g: 0, b: 0, a: 1 }
+          }]
+        });
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bg);
+        pass.draw(3);
+        pass.end();
+      }
+    }
+    this.device.queue.submit([encoder.finish()]);
+  }
   clear() {
     if (this.texture) {
       this.texture.destroy();
@@ -2442,7 +2312,7 @@ class SkyboxRenderer {
     }
     this.bindGroup = null;
     this.frameReady = false;
-    this.mode = "none";
+    this.active = false;
   }
   destroy() {
     this.clear();
@@ -19061,36 +18931,9 @@ class App {
     this.updateAdaptivePerformance();
     this.hotspotManager.updateBillboards();
     if ((_a2 = this.skyboxRenderer) == null ? void 0 : _a2.isActive) {
-      const cam = this.camera.position;
-      let groundLevel = 0;
-      const gsRendererForGround = this.sceneManager.getGSRenderer();
-      const bbox = (gsRendererForGround == null ? void 0 : gsRendererForGround.getBoundingBox()) ?? null;
-      if (bbox) {
-        const m = gsRendererForGround.getModelMatrix();
-        groundLevel = m[5] * bbox.min[1] + m[13];
-      }
-      if (!this._hdrDebugLogged) {
-        this._hdrDebugLogged = true;
-        console.log(
-          "[HDR Ground Debug]",
-          "hasGsRenderer:",
-          !!gsRendererForGround,
-          "hasBbox:",
-          !!bbox,
-          "bbox:",
-          bbox ? { min: [...bbox.min], max: [...bbox.max], center: [...bbox.center] } : null,
-          "groundLevel:",
-          groundLevel,
-          "cam:",
-          [cam[0].toFixed(2), cam[1].toFixed(2), cam[2].toFixed(2)]
-        );
-      }
-      const camH = cam[1] - groundLevel;
-      this.skyboxRenderer.groundRadius = 0.3;
       this.skyboxRenderer.prepareFrame(
         this.camera.viewMatrix,
-        this.camera.projectionMatrix,
-        [cam[0], camH, cam[2]]
+        this.camera.projectionMatrix
       );
     }
     const pass = this.renderer.beginFrame();
@@ -19275,21 +19118,6 @@ class App {
       faceUrls.negZ
     ]);
   }
-  async setHdrBackground(url) {
-    if (!this.skyboxRenderer) {
-      this.skyboxRenderer = new SkyboxRenderer(
-        this.renderer.device,
-        this.renderer.format,
-        "depth24plus"
-      );
-    }
-    await this.skyboxRenderer.loadEquirectangular(url);
-  }
-  setHdrGroundRadius(radius) {
-    if (this.skyboxRenderer) {
-      this.skyboxRenderer.groundRadius = radius;
-    }
-  }
   clearSkybox() {
     var _a2;
     (_a2 = this.skyboxRenderer) == null ? void 0 : _a2.clear();
@@ -19781,7 +19609,6 @@ exports.exportEditedPLY = exportEditedPLY;
 exports.getRecommendedDPR = getRecommendedDPR;
 exports.isMobileDevice = isMobileDevice;
 exports.isWebGPUSupported = isWebGPUSupported;
-exports.loadHdr = loadHdr;
 exports.loadPLY = loadPLY;
 exports.loadPLYMobile = loadPLYMobile;
 exports.loadSOG = loadSOG;