@rings-webgpu/core 1.0.42 → 1.0.43

package/dist/rings.es.max.js

@@ -1679,21 +1679,47 @@ class Context3D extends CEventDispatcher {
     this.adapter = await navigator.gpu.requestAdapter({
       powerPreference: "high-performance"
       // 或 low-power
+      // xrCompatible: canvasConfig?.xrCompatible, // 可选：如果需要 XR 支持
     });
     if (this.adapter == null) {
       throw new Error("Your browser does not support WebGPU!");
     }
+    const requiredFeatures = [];
+    const requireFeature = (feature) => {
+      const supported = this.adapter.features.has(feature);
+      if (supported) {
+        requiredFeatures.push(feature);
+      }
+      return supported;
+    };
+    requireFeature("bgra8unorm-storage");
+    requireFeature("depth-clip-control");
+    requireFeature("depth32float-stencil8");
+    requireFeature("indirect-first-instance");
+    requireFeature("rg11b10ufloat-renderable");
+    requireFeature("float32-filterable");
+    requireFeature("float32-blendable");
+    requireFeature("timestamp-query");
+    requireFeature("shader-f16");
+    requireFeature("clip-distances");
+    requireFeature("texture-compression-bc");
+    requireFeature("texture-compression-etc2");
+    requireFeature("texture-compression-astc");
+    const adapterLimits = this.adapter?.limits;
+    const requiredLimits = {};
+    if (adapterLimits) {
+      for (const limitName in adapterLimits) {
+        if (limitName === "minSubgroupSize" || limitName === "maxSubgroupSize") {
+          continue;
+        }
+        requiredLimits[limitName] = adapterLimits[limitName];
+      }
+    }
     this.device = await this.adapter.requestDevice({
-      requiredFeatures: [
-        "bgra8unorm-storage",
-        "depth-clip-control",
-        "depth32float-stencil8",
-        "indirect-first-instance",
-        "rg11b10ufloat-renderable"
-      ],
-      requiredLimits: {
-        minUniformBufferOffsetAlignment: 256,
-        maxStorageBufferBindingSize: this.adapter.limits.maxStorageBufferBindingSize
+      requiredFeatures,
+      requiredLimits,
+      defaultQueue: {
+        label: "RingsDefaultQueue"
       }
     });
     if (this.device == null) {
@@ -1701,15 +1727,18 @@ class Context3D extends CEventDispatcher {
     }
     this._pixelRatio = this.canvasConfig?.devicePixelRatio || window.devicePixelRatio || 1;
     this._pixelRatio = Math.min(this._pixelRatio, 2);
-    this.device.label = "device";
+    this.device.label = "RingsWebGPUDevice";
     this.presentationFormat = navigator.gpu.getPreferredCanvasFormat();
     this.context = this.canvas.getContext("webgpu");
     this.context.configure({
       device: this.device,
       format: this.presentationFormat,
-      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+      // RENDER_ATTACHMENT is required, COPY_SRC allows scene grab/copy operations
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
       alphaMode: "premultiplied",
-      colorSpace: `srgb`
+      colorSpace: "srgb"
+      // Optional: viewFormats can be added here if needed for SRGB views
+      // viewFormats: [this.presentationFormat + '-srgb']
     });
     this._resizeEvent = new CResizeEvent(CResizeEvent.RESIZE, {
       width: this.windowWidth,
@@ -22879,11 +22908,23 @@ const GSplat_VS = (
         let radius = length(vec2f((diagonal1 - diagonal2) * 0.5, offDiagonal));
         let lambda1 = mid + radius;
         let lambda2 = max(mid - radius, MIN_LAMBDA);
+
+        let vmin = min(MAX_SPLAT_SIZE, min(viewport.x, viewport.y));
+        let l1 = 2.0 * min(sqrt(2.0 * lambda1), vmin);
+        let l2 = 2.0 * min(sqrt(2.0 * lambda2), vmin);
+
+        // if (l1 < 2.0 && l2 < 2.0) {
+        //     return discardSplat();
+        // }
+
+        let centerProj = projMat * vec4f(splat_cam, 1.0);
+        let c = centerProj.ww * vec2f(1.0 / viewport.x, 1.0 / viewport.y);
+
         let diagonalVector = normalize(vec2f(offDiagonal, lambda1 - diagonal1));
         
         // Calculate axis vectors with size clamping
-        let v1 = min(sqrt(2.0 * lambda1), MAX_SPLAT_SIZE) * diagonalVector;
-        let v2 = min(sqrt(2.0 * lambda2), MAX_SPLAT_SIZE) * vec2f(diagonalVector.y, -diagonalVector.x);
+        let v1 = l1 * diagonalVector;
+        let v2 = l2 * vec2f(diagonalVector.y, -diagonalVector.x);
         
         // WebGPU Y-axis flip: WebGPU NDC Y goes from top(-1) to bottom(1), opposite of WebGL
         return vec4f(v1.x, -v1.y, v2.x, -v2.y);
@@ -22949,11 +22990,13 @@ const GSplat_VS = (
         let v1v2 = calcV1V2(splat_cam.xyz, splatData.covA, splatData.covB, W, viewport, matrix_projection);
         
         // Calculate scale based on alpha (optimized formula)
-        let scale = min(1.0, sqrt(LOG_255 + log(color.a)) * 0.5);
+        let t = pow(splat_cam.z + 0.5, 5);
+        let scale = min(1.0, sqrt(-log(1.0 / (255.0 * color.a))) / 2.0);
         
         // Apply visBoost (size multiplier)
         let visBoost = materialUniform.tex_params.w;
-        let v1v2_scaled = v1v2 * (scale * visBoost);
+        let expt = exp(-1.0 / t);
+        let v1v2_scaled = v1v2 * (scale * visBoost * expt);
         
         // Pixel coverage culling (vectorized squared length calculation)
         let v1v2_sq = v1v2_scaled * v1v2_scaled;
@@ -22987,7 +23030,7 @@ const GSplat_VS = (
         
         var o: VSOut;
         o.member = splat_proj + vec4f(offset, 0.0, 0.0);
-        o.vTexCoord = vertex_pos * (scale * 0.5);
+        o.vTexCoord = vertex_pos * (scale);
         o.vColor = color;
         
         return o;
@@ -23001,16 +23044,30 @@ const GSplat_FS = (
     
     // Constants
     const ALPHA_THRESHOLD: f32 = 0.00392156863; // 1.0 / 255.0
-    const GAUSSIAN_SCALE: f32 = 4.0;
+    // const GAUSSIAN_SCALE: f32 = 4.0;
+    const EXP4      = exp(-4.0);
+    const INV_EXP4  = 1.0 / (1.0 - EXP4);
+
+    fn normExp(x: f32) -> f32 {
+        return (exp(x * -4.0) - EXP4) * INV_EXP4;
+    }
 
     // === evalSplat() - optimized gaussian evaluation ===
     fn evalSplat(texCoord: vec2f, color: vec4f) -> vec4f {
         let A = dot(texCoord, texCoord);
+
+        if (A > 1.0) {
+            discard;
+            // return vec4f(1.0, 0.0, 0.0, 0.5);
+        }
         
         // Branch-less optimization using select
-        let gaussian = exp(-A * GAUSSIAN_SCALE) * color.a;
-        let alpha = select(gaussian, 0.0, A > 1.0 || gaussian < ALPHA_THRESHOLD);
-        
+        var alpha = normExp(A) * color.a;
+
+        if (alpha < ALPHA_THRESHOLD) {
+            discard;
+            // alpha = 0.5;
+        }
         return vec4f(color.rgb, alpha);
     }
 
@@ -23257,8 +23314,9 @@ let GSplatShader = class extends Shader {
     pass.cullMode = GPUCullMode.none;
     pass.shaderState.transparent = true;
     pass.shaderState.blendMode = BlendMode.NORMAL;
-    pass.shaderState.writeMasks = [15, 15];
+    pass.shaderState.writeMasks = [15, 0];
     pass.shaderState.castReflection = false;
+    pass.shaderState.depthCompare = GPUCompareFunction.less;
     this.addRenderPass(pass);
     this.setDefault();
   }
@@ -24007,17 +24065,17 @@ class GSplatGeometry extends GeometryBase {
     const meshPositions = new Float32Array(12 * batchSize);
     for (let i = 0; i < batchSize; ++i) {
       meshPositions.set([
-        -2,
-        -2,
+        -1,
+        -1,
         i,
-        2,
-        -2,
+        1,
+        -1,
         i,
-        2,
-        2,
+        1,
+        1,
         i,
-        -2,
-        2,
+        -1,
+        1,
         i
       ], i * 12);
     }
@@ -27481,6 +27539,8 @@ class GPUContext {
   static matrixCount = 0;
   static lastRenderPassState;
   static LastCommand;
+  static multiTextureViewCache = /* @__PURE__ */ new WeakMap();
+  static swapchainTextureCache = { texture: null, view: null };
   static bindPipeline(encoder, renderShader) {
     if (GPUContext.lastShader != renderShader) {
       GPUContext.lastShader = renderShader;
@@ -27568,21 +27628,40 @@ class GPUContext {
         const renderTarget = renderPassState.renderTargets[i];
         let att = renderPassState.renderPassDescriptor.colorAttachments[i];
         if (renderPassState.multisample > 0 && renderPassState.renderTargets.length == 1) {
-          att.view = renderPassState.multiTexture.createView();
+          let multiView = this.multiTextureViewCache.get(renderPassState.multiTexture);
+          if (!multiView) {
+            multiView = renderPassState.multiTexture.createView();
+            this.multiTextureViewCache.set(renderPassState.multiTexture, multiView);
+          }
+          att.view = multiView;
           att.resolveTarget = renderTarget.getGPUView();
         } else {
-          att.view = renderTarget.getGPUTexture().createView();
+          att.view = renderTarget.getGPUView();
         }
       }
       return command.beginRenderPass(renderPassState.renderPassDescriptor);
     } else {
       let att0 = renderPassState.renderPassDescriptor.colorAttachments[0];
       if (att0) {
+        const swapchainTexture = webGPUContext.context.getCurrentTexture();
         if (renderPassState.multisample > 0) {
-          att0.view = renderPassState.multiTexture.createView();
-          att0.resolveTarget = webGPUContext.context.getCurrentTexture().createView();
+          let multiView = this.multiTextureViewCache.get(renderPassState.multiTexture);
+          if (!multiView) {
+            multiView = renderPassState.multiTexture.createView();
+            this.multiTextureViewCache.set(renderPassState.multiTexture, multiView);
+          }
+          att0.view = multiView;
+          if (this.swapchainTextureCache.texture !== swapchainTexture) {
+            this.swapchainTextureCache.texture = swapchainTexture;
+            this.swapchainTextureCache.view = swapchainTexture.createView();
+          }
+          att0.resolveTarget = this.swapchainTextureCache.view;
         } else {
-          att0.view = webGPUContext.context.getCurrentTexture().createView();
+          if (this.swapchainTextureCache.texture !== swapchainTexture) {
+            this.swapchainTextureCache.texture = swapchainTexture;
+            this.swapchainTextureCache.view = swapchainTexture.createView();
+          }
+          att0.view = this.swapchainTextureCache.view;
         }
       }
       return command.beginRenderPass(renderPassState.renderPassDescriptor);