@rings-webgpu/core 1.0.42 → 1.0.44

package/dist/rings.umd.max.js

@@ -1686,21 +1686,47 @@
       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) {
@@ -1708,15 +1734,18 @@
       }
       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,
@@ -22886,11 +22915,23 @@ struct InstanceData {
         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);
@@ -22956,11 +22997,13 @@ struct InstanceData {
         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;
@@ -22994,7 +23037,7 @@ struct InstanceData {
         
         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;
@@ -23008,16 +23051,30 @@ struct InstanceData {
     
     // 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);
     }
 
@@ -23264,8 +23321,9 @@ struct InstanceData {
       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();
     }
@@ -24014,17 +24072,17 @@ struct InstanceData {
       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);
       }
@@ -25368,7 +25426,6 @@ struct InstanceData {
         }
         
         o.color = vColor;
-        o.gBuffer = vec4f(0.0);
         return o;
     }
 `
@@ -25395,7 +25452,7 @@ struct InstanceData {
       pass.cullMode = GPUCullMode.none;
       pass.shaderState.transparent = false;
       pass.shaderState.blendMode = BlendMode.NORMAL;
-      pass.shaderState.writeMasks = [15, 15];
+      pass.shaderState.writeMasks = [15, 0];
       pass.shaderState.castReflection = false;
       this.addRenderPass(pass);
       this.setDefault();
@@ -27488,6 +27545,8 @@ struct InstanceData {
     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;
@@ -27575,21 +27634,40 @@ struct InstanceData {
           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);
@@ -42292,7 +42370,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.42";
+  const version = "1.0.43";
 
   class Engine3D {
     /**

package/dist/types/gfx/renderJob/GPUContext.d.ts

@@ -15,6 +15,8 @@ export declare class GPUContext {
     static matrixCount: number;
     static lastRenderPassState: RendererPassState;
     static LastCommand: GPUCommandEncoder | null;
+    private static multiTextureViewCache;
+    private static swapchainTextureCache;
     static bindPipeline(encoder: GPURenderPassEncoder | GPURenderBundleEncoder, renderShader: RenderShaderPass): boolean;
     static bindCamera(encoder: GPURenderPassEncoder | GPURenderBundleEncoder, camera: Camera3D): void;
     static bindGeometryBuffer(encoder: GPURenderPassEncoder | GPURenderBundleEncoder, geometry: GeometryBase): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rings-webgpu/core",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {