@d5techs/3dgs-lib 1.4.25 → 1.4.27

package/dist/3dgs-lib.cjs

@@ -653,6 +653,8 @@ const _OrbitControls = class _OrbitControls {
     __publicField(this, "lastTouchCenter", { x: 0, y: 0 });
     // 启用/禁用
     __publicField(this, "enabled", true);
+    // 双击拾取回调：返回世界坐标则聚焦，返回 null 则忽略
+    __publicField(this, "pickWorldPosition", null);
     // 绑定的事件处理函数（用于移除监听器）
     __publicField(this, "boundOnMouseDown");
     __publicField(this, "boundOnMouseMove");
@@ -762,6 +764,9 @@ const _OrbitControls = class _OrbitControls {
       if (this.enableDamping) {
         this.velocityTheta += -deltaX * this.rotateSpeed;
         this.velocityPhi += -deltaY * this.rotateSpeed;
+        const maxRotVel = 0.5;
+        this.velocityTheta = Math.max(-maxRotVel, Math.min(maxRotVel, this.velocityTheta));
+        this.velocityPhi = Math.max(-maxRotVel, Math.min(maxRotVel, this.velocityPhi));
       } else {
         this.theta -= deltaX * this.rotateSpeed;
         this.phi -= deltaY * this.rotateSpeed;
@@ -780,9 +785,15 @@ const _OrbitControls = class _OrbitControls {
   onWheel(e) {
     e.preventDefault();
     if (!this.enabled) return;
-    const zoomDelta = e.deltaY * this.zoomSpeed;
+    let delta = e.deltaY;
+    if (e.deltaMode === 1) delta *= 40;
+    else if (e.deltaMode === 2) delta *= 800;
+    const normalizedDelta = Math.sign(delta) * Math.min(Math.abs(delta), 150);
+    const zoomDelta = normalizedDelta * this.zoomSpeed;
     if (this.enableDamping) {
       this.velocityDistance += zoomDelta;
+      const maxVelocity = 2;
+      this.velocityDistance = Math.max(-maxVelocity, Math.min(maxVelocity, this.velocityDistance));
     } else {
       this.distance *= Math.exp(zoomDelta);
       this.distance = Math.max(
@@ -839,6 +850,13 @@ const _OrbitControls = class _OrbitControls {
   }
   onDblClick(e) {
     if (!this.enabled) return;
+    if (this.pickWorldPosition) {
+      const hit = this.pickWorldPosition(e.clientX, e.clientY);
+      if (hit) {
+        this.animateToTarget(hit);
+      }
+      return;
+    }
     const rect = this.canvas.getBoundingClientRect();
     const ndcX = (e.clientX - rect.left) / rect.width * 2 - 1;
     const ndcY = -((e.clientY - rect.top) / rect.height * 2 - 1);
@@ -6214,7 +6232,10 @@ function buildCodebook(values, k = 256) {
   for (let i = 0; i < N; i++) {
     const uniformPos = (sorted[i] - vMin) / vRange;
     const quantilePos = i / N;
-    const bin = Math.min(H - 1, Math.floor(H * (beta * quantilePos + (1 - beta) * uniformPos)));
+    const bin = Math.min(
+      H - 1,
+      Math.floor(H * (beta * quantilePos + (1 - beta) * uniformPos))
+    );
     counts[bin]++;
     sums[bin] += sorted[i];
   }
@@ -6291,7 +6312,8 @@ function buildCodebook(values, k = 256) {
   centroidValues.sort();
   const result = new Array(k);
   for (let i = 0; i < effectiveK; i++) result[i] = centroidValues[i];
-  for (let i = effectiveK; i < k; i++) result[i] = centroidValues[effectiveK - 1];
+  for (let i = effectiveK; i < k; i++)
+    result[i] = centroidValues[effectiveK - 1];
   return result;
 }
 function findNearest(sortedCB, value) {
@@ -6419,27 +6441,66 @@ async function gpuAssignLabels(device, pointsFlat, centroidsFlat, numPoints, num
   const WORKGROUP_SIZE2 = 64;
   const BATCH_SIZE = 1024 * WORKGROUP_SIZE2;
   const numBatches = Math.ceil(numPoints / BATCH_SIZE);
-  const shaderModule = device.createShaderModule({ code: getGpuClusterShader(dim) });
+  const shaderModule = device.createShaderModule({
+    code: getGpuClusterShader(dim)
+  });
   const bindGroupLayout = device.createBindGroupLayout({
     entries: [
-      { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "uniform" } },
-      { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-      { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-      { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } }
+      {
+        binding: 0,
+        visibility: GPUShaderStage.COMPUTE,
+        buffer: { type: "uniform" }
+      },
+      {
+        binding: 1,
+        visibility: GPUShaderStage.COMPUTE,
+        buffer: { type: "read-only-storage" }
+      },
+      {
+        binding: 2,
+        visibility: GPUShaderStage.COMPUTE,
+        buffer: { type: "read-only-storage" }
+      },
+      {
+        binding: 3,
+        visibility: GPUShaderStage.COMPUTE,
+        buffer: { type: "storage" }
+      }
     ]
   });
   const pipeline = device.createComputePipeline({
-    layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+    layout: device.createPipelineLayout({
+      bindGroupLayouts: [bindGroupLayout]
+    }),
     compute: { module: shaderModule, entryPoint: "main" }
   });
-  const uniformBuf = device.createBuffer({ size: 8, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  const centroidsBuf = device.createBuffer({ size: centroidsFlat.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-  device.queue.writeBuffer(centroidsBuf, 0, centroidsFlat.buffer);
+  const uniformBuf = device.createBuffer({
+    size: 8,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const centroidsBuf = device.createBuffer({
+    size: centroidsFlat.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(
+    centroidsBuf,
+    0,
+    centroidsFlat.buffer
+  );
   const pointsBufSize = BATCH_SIZE * dim * 4;
-  const pointsBuf = device.createBuffer({ size: pointsBufSize, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  const pointsBuf = device.createBuffer({
+    size: pointsBufSize,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
   const resultsBufSize = BATCH_SIZE * 4;
-  const resultsBuf = device.createBuffer({ size: resultsBufSize, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC });
-  const readbackBuf = device.createBuffer({ size: resultsBufSize, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+  const resultsBuf = device.createBuffer({
+    size: resultsBufSize,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+  });
+  const readbackBuf = device.createBuffer({
+    size: resultsBufSize,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  });
   const labels = new Uint32Array(numPoints);
   const bindGroup = device.createBindGroup({
     layout: bindGroupLayout,
@@ -6454,18 +6515,36 @@ async function gpuAssignLabels(device, pointsFlat, centroidsFlat, numPoints, num
     const offset = batch * BATCH_SIZE;
     const currentBatchSize = Math.min(numPoints - offset, BATCH_SIZE);
     const groups = Math.ceil(currentBatchSize / WORKGROUP_SIZE2);
-    device.queue.writeBuffer(uniformBuf, 0, new Uint32Array([currentBatchSize, numCentroids]));
-    device.queue.writeBuffer(pointsBuf, 0, pointsFlat.buffer, offset * dim * 4, currentBatchSize * dim * 4);
+    device.queue.writeBuffer(
+      uniformBuf,
+      0,
+      new Uint32Array([currentBatchSize, numCentroids])
+    );
+    device.queue.writeBuffer(
+      pointsBuf,
+      0,
+      pointsFlat.buffer,
+      offset * dim * 4,
+      currentBatchSize * dim * 4
+    );
     const encoder = device.createCommandEncoder();
     const pass = encoder.beginComputePass();
     pass.setPipeline(pipeline);
     pass.setBindGroup(0, bindGroup);
     pass.dispatchWorkgroups(groups);
     pass.end();
-    encoder.copyBufferToBuffer(resultsBuf, 0, readbackBuf, 0, currentBatchSize * 4);
+    encoder.copyBufferToBuffer(
+      resultsBuf,
+      0,
+      readbackBuf,
+      0,
+      currentBatchSize * 4
+    );
     device.queue.submit([encoder.finish()]);
     await readbackBuf.mapAsync(GPUMapMode.READ);
-    const mapped = new Uint32Array(readbackBuf.getMappedRange(0, currentBatchSize * 4));
+    const mapped = new Uint32Array(
+      readbackBuf.getMappedRange(0, currentBatchSize * 4)
+    );
     labels.set(mapped, offset);
     readbackBuf.unmap();
   }
@@ -6489,13 +6568,23 @@ async function kmeansGpu(pointsFlat, n, dim, k, iterations, onProgress) {
   const centroids = new Float32Array(k * dim);
   const indices = pickRandomIndices(n, k);
   for (let i = 0; i < k; i++) {
-    centroids.set(pointsFlat.subarray(indices[i] * dim, indices[i] * dim + dim), i * dim);
+    centroids.set(
+      pointsFlat.subarray(indices[i] * dim, indices[i] * dim + dim),
+      i * dim
+    );
   }
   const device = await getGpuDevice();
   for (let iter = 0; iter < iterations; iter++) {
     onProgress == null ? void 0 : onProgress(iter, iterations);
     if (device) {
-      const newLabels = await gpuAssignLabels(device, pointsFlat, centroids, n, k, dim);
+      const newLabels = await gpuAssignLabels(
+        device,
+        pointsFlat,
+        centroids,
+        n,
+        k,
+        dim
+      );
       labels.set(newLabels);
     } else {
       assignLabelsCpu(pointsFlat, centroids, labels, n, k, dim);
@@ -6504,7 +6593,14 @@ async function kmeansGpu(pointsFlat, n, dim, k, iterations, onProgress) {
   }
   onProgress == null ? void 0 : onProgress(iterations, iterations);
   if (device) {
-    const finalLabels = await gpuAssignLabels(device, pointsFlat, centroids, n, k, dim);
+    const finalLabels = await gpuAssignLabels(
+      device,
+      pointsFlat,
+      centroids,
+      n,
+      k,
+      dim
+    );
     labels.set(finalLabels);
   } else {
     assignLabelsCpu(pointsFlat, centroids, labels, n, k, dim);
@@ -6550,7 +6646,8 @@ function updateCentroids(points, centroids, labels, n, k, dim) {
   for (let c = 0; c < k; c++) {
     if (counts[c] > 0) {
       const off = c * dim;
-      for (let d = 0; d < dim; d++) centroids[off + d] = sums[off + d] / counts[c];
+      for (let d = 0; d < dim; d++)
+        centroids[off + d] = sums[off + d] / counts[c];
     } else {
       const idx = Math.floor(Math.random() * n);
       centroids.set(points.subarray(idx * dim, idx * dim + dim), c * dim);
@@ -6583,9 +6680,18 @@ function mortonSort(positions, count) {
   const morton = new Uint32Array(count);
   const indices = new Uint32Array(count);
   for (let i = 0; i < count; i++) {
-    const ix = Math.min(1023, Math.floor(1024 * (positions[i * 3] - minx) / xlen));
-    const iy = Math.min(1023, Math.floor(1024 * (positions[i * 3 + 1] - miny) / ylen));
-    const iz = Math.min(1023, Math.floor(1024 * (positions[i * 3 + 2] - minz) / zlen));
+    const ix = Math.min(
+      1023,
+      Math.floor(1024 * (positions[i * 3] - minx) / xlen)
+    );
+    const iy = Math.min(
+      1023,
+      Math.floor(1024 * (positions[i * 3 + 1] - miny) / ylen)
+    );
+    const iz = Math.min(
+      1023,
+      Math.floor(1024 * (positions[i * 3 + 2] - minz) / zlen)
+    );
     morton[i] = (part1By2(iz) << 2) + (part1By2(iy) << 1) + part1By2(ix);
     indices[i] = i;
   }
@@ -6722,7 +6828,8 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}, on
   onProgress == null ? void 0 : onProgress("encode_scale", 0.2);
   await yieldToUI();
   const logScales = new Float32Array(count * 3);
-  for (let i = 0; i < count * 3; i++) logScales[i] = Math.log(Math.max(1e-8, sSca[i]));
+  for (let i = 0; i < count * 3; i++)
+    logScales[i] = Math.log(Math.max(1e-8, sSca[i]));
   const scaleCodebook = buildCodebook(logScales, 256);
   const scalesData = new Uint8ClampedArray(totalPixels * 4);
   scalesData.fill(255);
@@ -6782,9 +6889,15 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}, on
       r1 = qx;
       r2 = qy;
     }
-    quatsData[off] = Math.round(Math.max(0, Math.min(255, (r0 / SQRT2 + 0.5) * 255)));
-    quatsData[off + 1] = Math.round(Math.max(0, Math.min(255, (r1 / SQRT2 + 0.5) * 255)));
-    quatsData[off + 2] = Math.round(Math.max(0, Math.min(255, (r2 / SQRT2 + 0.5) * 255)));
+    quatsData[off] = Math.round(
+      Math.max(0, Math.min(255, (r0 / SQRT2 + 0.5) * 255))
+    );
+    quatsData[off + 1] = Math.round(
+      Math.max(0, Math.min(255, (r1 / SQRT2 + 0.5) * 255))
+    );
+    quatsData[off + 2] = Math.round(
+      Math.max(0, Math.min(255, (r2 / SQRT2 + 0.5) * 255))
+    );
     quatsData[off + 3] = largest + 252;
   }
   onProgress == null ? void 0 : onProgress("encode_color", 0.4);
@@ -6840,7 +6953,8 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}, on
     await yieldToUI();
     const allCoeffValues = new Float32Array(effectivePaletteSize * shDim);
     for (let c = 0; c < effectivePaletteSize; c++) {
-      for (let d = 0; d < shDim; d++) allCoeffValues[c * shDim + d] = centroids[c * shDim + d];
+      for (let d = 0; d < shDim; d++)
+        allCoeffValues[c * shDim + d] = centroids[c * shDim + d];
     }
     const shCodebook = buildCodebook(allCoeffValues, 256);
     const centW = 64 * numCoeffs;
@@ -6854,8 +6968,14 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}, on
         const off = (v * centW + u) * 4;
         const cOff = n * shDim;
         centData[off] = findNearest(shCodebook, centroids[cOff + c * 3]);
-        centData[off + 1] = findNearest(shCodebook, centroids[cOff + c * 3 + 1]);
-        centData[off + 2] = findNearest(shCodebook, centroids[cOff + c * 3 + 2]);
+        centData[off + 1] = findNearest(
+          shCodebook,
+          centroids[cOff + c * 3 + 1]
+        );
+        centData[off + 2] = findNearest(
+          shCodebook,
+          centroids[cOff + c * 3 + 2]
+        );
         centData[off + 3] = 255;
       }
     }
@@ -18113,6 +18233,7 @@ class App {
     this.camera = new Camera();
     this.camera.setAspect(this.renderer.getAspectRatio());
     this.controls = new OrbitControls(this.camera, this.canvas);
+    this.controls.pickWorldPosition = (cx, cy) => this.pickSplatPosition(cx, cy);
     this.meshRenderer = new MeshRenderer(this.renderer, this.camera);
     this.glbLoader = new GLBLoader(this.renderer.device);
     this.objLoader = new OBJLoader(this.renderer.device);
@@ -18733,6 +18854,67 @@ class App {
   getRenderer() {
     return this.renderer;
   }
+  /**
+   * CPU splat 拾取：在屏幕坐标 (clientX, clientY) 处找最近的 splat，返回世界坐标或 null
+   */
+  pickSplatPosition(clientX, clientY) {
+    const gsRenderer = this.sceneManager.getGSRenderer();
+    if (!gsRenderer) return null;
+    const positions = gsRenderer.getCPUPositions();
+    if (!positions) return null;
+    const rect = this.canvas.getBoundingClientRect();
+    const ndcX = (clientX - rect.left) / rect.width * 2 - 1;
+    const ndcY = -((clientY - rect.top) / rect.height * 2 - 1);
+    const modelMatrix = gsRenderer.getModelMatrix();
+    const vp = this.camera.viewProjectionMatrix;
+    const count = positions.length / 3;
+    const step = count > 3e5 ? Math.ceil(count / 3e5) : 1;
+    const halfW = rect.width / 2;
+    const halfH = rect.height / 2;
+    const pickRadiusPx = 20;
+    const pickRadSq = pickRadiusPx * pickRadiusPx;
+    let bestCamDistSq = Infinity;
+    let bestIdx = -1;
+    let bestScreenDistSq = Infinity;
+    const m0 = modelMatrix[0], m1 = modelMatrix[1], m2 = modelMatrix[2];
+    const m4 = modelMatrix[4], m5 = modelMatrix[5], m6 = modelMatrix[6];
+    const m8 = modelMatrix[8], m9 = modelMatrix[9], m10 = modelMatrix[10];
+    const m12 = modelMatrix[12], m13 = modelMatrix[13], m14 = modelMatrix[14];
+    const v0 = vp[0], v1 = vp[1], v3 = vp[3];
+    const v4 = vp[4], v5 = vp[5], v7 = vp[7];
+    const v8 = vp[8], v9 = vp[9], v11 = vp[11];
+    const v12 = vp[12], v13 = vp[13], v15 = vp[15];
+    const rox = this.camera.position[0], roy = this.camera.position[1], roz = this.camera.position[2];
+    for (let i = 0; i < count; i += step) {
+      const i3 = i * 3;
+      const lx = positions[i3], ly = positions[i3 + 1], lz = positions[i3 + 2];
+      const tx = m0 * lx + m4 * ly + m8 * lz + m12;
+      const ty = m1 * lx + m5 * ly + m9 * lz + m13;
+      const tz = m2 * lx + m6 * ly + m10 * lz + m14;
+      const cw = v3 * tx + v7 * ty + v11 * tz + v15;
+      if (cw <= 0) continue;
+      const invCw = 1 / cw;
+      const pixX = ((v0 * tx + v4 * ty + v8 * tz + v12) * invCw - ndcX) * halfW;
+      const pixY = ((v1 * tx + v5 * ty + v9 * tz + v13) * invCw - ndcY) * halfH;
+      const screenDistSq = pixX * pixX + pixY * pixY;
+      if (screenDistSq < pickRadSq) {
+        const dx = tx - rox, dy = ty - roy, dz = tz - roz;
+        const camDistSq = dx * dx + dy * dy + dz * dz;
+        if (camDistSq < bestCamDistSq * 0.98 || camDistSq < bestCamDistSq * 1.02 && screenDistSq < bestScreenDistSq) {
+          bestCamDistSq = camDistSq;
+          bestScreenDistSq = screenDistSq;
+          bestIdx = i;
+        }
+      }
+    }
+    if (bestIdx < 0) return null;
+    const hx = positions[bestIdx * 3], hy = positions[bestIdx * 3 + 1], hz = positions[bestIdx * 3 + 2];
+    return [
+      m0 * hx + m4 * hy + m8 * hz + m12,
+      m1 * hx + m5 * hy + m9 * hz + m13,
+      m2 * hx + m6 * hy + m10 * hz + m14
+    ];
+  }
   getCamera() {
     return this.camera;
   }