@rings-webgpu/core 1.0.13 → 1.0.14

package/dist/rings.es.max.js

@@ -22679,6 +22679,13 @@ const GSplat_VS = (
   `
     #include "GlobalUniform"
     
+    // Constants
+    const ALPHA_THRESHOLD: f32 = 0.00392156863; // 1.0 / 255.0
+    const COV_COMPENSATION: f32 = 0.3;
+    const MAX_SPLAT_SIZE: f32 = 1024.0;
+    const MIN_LAMBDA: f32 = 0.1;
+    const LOG_255: f32 = 5.541263545; // log(255.0) - natural log for WGSL
+    
     struct MaterialUniform {
         modelMatrix: mat4x4<f32>,
         tex_params: vec4<f32>,      // [numSplats, texWidth, validCount, visBoost]
@@ -22698,107 +22705,92 @@ const GSplat_VS = (
     @group(1) @binding(3) var transformB: texture_2d<f32>;
     @group(1) @binding(4) var splatOrder: texture_2d<u32>;
     
-    // Global variables for texture lookups
-    var<private> splatUV: vec2<i32>;
-    var<private> splatId: u32;
-    var<private> tA: vec4<u32>;
+    struct SplatData {
+        center: vec3f,
+        covA: vec3f,
+        covB: vec3f,
+    };
     
-    // === calcSplatUV() - returns bool ===
-    fn calcSplatUV(orderId: u32) -> bool {
-        let textureWidth = u32(materialUniform.tex_params.y);
-        let numSplats = u32(materialUniform.tex_params.x);
-        
-        if (orderId >= numSplats) {
-            return false;
-        }
-        
+    // Helper function to discard splat
+    fn discardSplat() -> VSOut {
+        var o: VSOut;
+        o.member = vec4f(0.0, 0.0, 2.0, 1.0);
+        o.vColor = vec4f(0.0);
+        o.vTexCoord = vec2f(0.0);
+        return o;
+    }
+    
+    // === calcSplatUV() - returns optional UV ===
+    fn calcSplatUV(orderId: u32, textureWidth: u32, numSplats: u32) -> vec2<i32> {
         let orderUV = vec2<i32>(
             i32(orderId % textureWidth),
             i32(orderId / textureWidth)
         );
         
-        // calculate splatUV
-        splatId = textureLoad(splatOrder, orderUV, 0).r;
-        splatUV = vec2<i32>(
+        let splatId = textureLoad(splatOrder, orderUV, 0).r;
+        return vec2<i32>(
             i32(splatId % textureWidth),
             i32(splatId / textureWidth)
         );
-        
-        return true;
-    }
-    
-    // === getCenter() - returns vec3 ===
-    fn getCenter() -> vec3f {
-        tA = textureLoad(transformA, splatUV, 0);
-        return vec3f(bitcast<f32>(tA.x), bitcast<f32>(tA.y), bitcast<f32>(tA.z));
     }
     
-    // Struct to return covA and covB
-    struct CovarianceData {
-        covA: vec3f,
-        covB: vec3f,
-    };
-    
-    // === getCovariance() - returns struct ===
-    fn getCovariance() -> CovarianceData {
-        let tB = textureLoad(transformB, splatUV, 0);
+    // === getSplatData() - unified texture loading ===
+    fn getSplatData(splatUV: vec2<i32>) -> SplatData {
+        var data: SplatData;
         
-        // Use WGSL built-in unpack2x16float (equivalent to GLSL unpackHalf2x16)
+        // Load both textures once
+        let tA = textureLoad(transformA, splatUV, 0);
+        let tB = textureLoad(transformB, splatUV, 0);
         let tC = unpack2x16float(tA.w);
         
-        var result: CovarianceData;
-        result.covA = tB.xyz;
-        result.covB = vec3f(tC.x, tC.y, tB.w);
+        // Extract center
+        data.center = vec3f(bitcast<f32>(tA.x), bitcast<f32>(tA.y), bitcast<f32>(tA.z));
         
-        return result;
-    }
-    
-    // === getRotationMatrix() - returns mat3x3 ===
-    fn getRotationMatrix() -> mat3x3f {
-        let cov_data = getCovariance();
-        let covA = cov_data.covA;
-        let covB = cov_data.covB;
+        // Extract covariance
+        data.covA = tB.xyz;
+        data.covB = vec3f(tC.x, tC.y, tB.w);
         
-        return mat3x3f(
-            vec3f(1.0 - 2.0 * (covA.z * covA.z + covB.x * covB.x), 2.0 * (covA.y * covA.z + covB.y * covB.x), 2.0 * (covA.y * covB.x - covB.y * covA.z)),
-            vec3f(2.0 * (covA.y * covA.z - covB.y * covB.x), 1.0 - 2.0 * (covA.y * covA.y + covB.x * covB.x), 2.0 * (covA.z * covB.x + covA.y * covB.y)),
-            vec3f(2.0 * (covA.y * covB.x + covB.y * covA.z), 2.0 * (covA.z * covB.x - covA.y * covB.y), 1.0 - 2.0 * (covA.y * covA.y + covA.z * covA.z))
-        );
+        return data;
     }
     
     // === calcV1V2() - returns vec4 ===
     fn calcV1V2(splat_cam: vec3f, covA: vec3f, covB: vec3f, W: mat3x3f, viewport: vec2f, projMat: mat4x4f) -> vec4f {
+        // Construct symmetric covariance matrix
         let Vrk = mat3x3f(
             vec3f(covA.x, covA.y, covA.z),
             vec3f(covA.y, covB.x, covB.y),
             vec3f(covA.z, covB.y, covB.z)
         );
         
+        // Calculate Jacobian
         let focal = viewport.x * projMat[0][0];
-        
-        let J1 = focal / splat_cam.z;
-        let J2 = -J1 / splat_cam.z * splat_cam.xy;
+        let inv_z = 1.0 / splat_cam.z;
+        let J1 = focal * inv_z;
+        let J2 = -J1 * inv_z * splat_cam.xy;
         let J = mat3x3f(
             vec3f(J1, 0.0, J2.x),
             vec3f(0.0, J1, J2.y),
             vec3f(0.0, 0.0, 0.0)
         );
         
+        // Project covariance to screen space
         let T = W * J;
         let cov = transpose(T) * Vrk * T;
         
-        let diagonal1 = cov[0][0] + 0.3;
+        // Eigenvalue decomposition with compensation
+        let diagonal1 = cov[0][0] + COV_COMPENSATION;
         let offDiagonal = cov[0][1];
-        let diagonal2 = cov[1][1] + 0.3;
+        let diagonal2 = cov[1][1] + COV_COMPENSATION;
         
         let mid = 0.5 * (diagonal1 + diagonal2);
-        let radius = length(vec2f((diagonal1 - diagonal2) / 2.0, offDiagonal));
+        let radius = length(vec2f((diagonal1 - diagonal2) * 0.5, offDiagonal));
         let lambda1 = mid + radius;
-        let lambda2 = max(mid - radius, 0.1);
+        let lambda2 = max(mid - radius, MIN_LAMBDA);
         let diagonalVector = normalize(vec2f(offDiagonal, lambda1 - diagonal1));
         
-        let v1 = min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector;
-        let v2 = min(sqrt(2.0 * lambda2), 1024.0) * vec2f(diagonalVector.y, -diagonalVector.x);
+        // 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);
         
         // 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);
@@ -22812,115 +22804,97 @@ const GSplat_VS = (
         @builtin(instance_index) iid : u32,
         @location(0) position: vec3<f32>  // vertex_position from mesh (x, y, local_index)
     ) -> VSOut {
-        var o: VSOut;
-        let discardVec = vec4f(0.0, 0.0, 2.0, 1.0);
-        
         // Calculate splat ID
-        // orderId = vertex_id_attrib + uint(vertex_position.z)
-        // In our case: vertex_id_attrib = iid * batchSize
         let batchSize = u32(materialUniform.pixelCull.w);
-        let base_splat_index = iid * batchSize;
-        let local_splat_index = u32(position.z);
-        let orderId = base_splat_index + local_splat_index;
+        let orderId = iid * batchSize + u32(position.z);
         
-        // Use vertex position from mesh
-        let vertex_pos = position.xy;
-        
-        // calculate splat uv
-        if (!calcSplatUV(orderId)) {
-            o.member = discardVec;
-            o.vColor = vec4f(0.0);
-            o.vTexCoord = vec2f(0.0);
-            return o;
+        // Early bounds check
+        let textureWidth = u32(materialUniform.tex_params.y);
+        let numSplats = u32(materialUniform.tex_params.x);
+        if (orderId >= numSplats) {
+            return discardSplat();
         }
         
-        // get center
-        let center = getCenter();
+        // Calculate splat UV and load all data in one go
+        let splatUV = calcSplatUV(orderId, textureWidth, numSplats);
+        let splatData = getSplatData(splatUV);
         
-        // handle transforms
+        // Load color early for alpha test
+        let color = textureLoad(splatColor, splatUV, 0);
+        if (color.a < ALPHA_THRESHOLD) {
+            return discardSplat();
+        }
+        
+        // Transform matrices
+        let matrix_model = materialUniform.modelMatrix;
         let matrix_view = globalUniform.viewMat;
         let matrix_projection = globalUniform.projMat;
-        let matrix_model = materialUniform.modelMatrix;
-        
         let model_view = matrix_view * matrix_model;
-        let splat_cam = model_view * vec4f(center, 1.0);
-        let splat_proj = matrix_projection * splat_cam;
         
-        // Frustum culling: cull splats behind camera
-        if (splat_proj.z < 0.0) {
-            o.member = discardVec;
-            o.vColor = vec4f(0.0);
-            o.vTexCoord = vec2f(0.0);
-            return o;
+        // Transform center to camera and clip space
+        let splat_cam = model_view * vec4f(splatData.center, 1.0);
+        
+        // Early depth culling
+        if (splat_cam.z <= 0.0) {
+            return discardSplat();
         }
         
-        // Frustum culling: cull splats outside screen bounds
-        let ndc = splat_proj.xyz / splat_proj.w;
-        let margin = 0.0;
-        if (ndc.x < -1.0 - margin || ndc.x > 1.0 + margin ||
-            ndc.y < -1.0 - margin || ndc.y > 1.0 + margin ||
+        let splat_proj = matrix_projection * splat_cam;
+        
+        // Frustum culling with NDC check
+        let inv_w = 1.0 / splat_proj.w;
+        let ndc = splat_proj.xyz * inv_w;
+        if (ndc.x < -1.0 || ndc.x > 1.0 ||
+            ndc.y < -1.0 || ndc.y > 1.0 ||
             ndc.z < 0.0 || ndc.z > 1.0) {
-            o.member = discardVec;
-            o.vColor = vec4f(0.0);
-            o.vTexCoord = vec2f(0.0);
-            return o;
+            return discardSplat();
         }
         
-        // get covariance
-        let cov_data = getCovariance();
-        
+        // Calculate v1v2 (screen-space ellipse axes)
         let viewport = vec2f(globalUniform.windowWidth, globalUniform.windowHeight);
-        let v1v2 = calcV1V2(splat_cam.xyz, cov_data.covA, cov_data.covB, transpose(mat3x3f(model_view[0].xyz, model_view[1].xyz, model_view[2].xyz)), viewport, matrix_projection);
+        let W = transpose(mat3x3f(model_view[0].xyz, model_view[1].xyz, model_view[2].xyz));
+        let v1v2 = calcV1V2(splat_cam.xyz, splatData.covA, splatData.covB, W, viewport, matrix_projection);
         
-        // get color
-        let color = textureLoad(splatColor, splatUV, 0);
-        if (color.a < 1.0 / 255.0) {
-            o.member = discardVec;
-            o.vColor = vec4f(0.0);
-            o.vTexCoord = vec2f(0.0);
-            return o;
-        }
+        // Calculate scale based on alpha (optimized formula)
+        let scale = min(1.0, sqrt(LOG_255 + log(color.a)) * 0.5);
         
-        // calculate scale based on alpha
-        let scale = min(1.0, sqrt(-log(1.0 / 255.0 / color.a)) / 2.0);
-        
-        // apply visBoost (size multiplier)
+        // Apply visBoost (size multiplier)
         let visBoost = materialUniform.tex_params.w;
-        var v1v2_scaled = v1v2 * scale * visBoost;
+        let v1v2_scaled = v1v2 * (scale * visBoost);
         
-        // Pixel coverage culling
-        let v1_len_sq = dot(v1v2_scaled.xy, v1v2_scaled.xy);
-        let v2_len_sq = dot(v1v2_scaled.zw, v1v2_scaled.zw);
+        // Pixel coverage culling (vectorized squared length calculation)
+        let v1v2_sq = v1v2_scaled * v1v2_scaled;
+        let v1_len_sq = v1v2_sq.x + v1v2_sq.y;
+        let v2_len_sq = v1v2_sq.z + v1v2_sq.w;
         
         let minPixels = materialUniform.pixelCull.x;
         let maxPixels = materialUniform.pixelCull.y;
-        let maxPixelCullDistance = materialUniform.pixelCull.z;
         
         // Early out tiny splats
         if (v1_len_sq < minPixels && v2_len_sq < minPixels) {
-            o.member = discardVec;
-            o.vColor = vec4f(0.0);
-            o.vTexCoord = vec2f(0.0);
-            return o;
+            return discardSplat();
         }
         
         // Cull oversized splats
         if (maxPixels > 0.0) {
+            let maxPixelCullDistance = materialUniform.pixelCull.z;
             let splatDistance = length(splat_cam.xyz);
             if (maxPixelCullDistance <= 0.0 || splatDistance < maxPixelCullDistance) {
                 let maxAxisSq = maxPixels * maxPixels;
                 if (v1_len_sq > maxAxisSq || v2_len_sq > maxAxisSq) {
-                    o.member = discardVec;
-                    o.vColor = vec4f(0.0);
-                    o.vTexCoord = vec2f(0.0);
-                    return o;
+                    return discardSplat();
                 }
             }
         }
         
-        // Final position
-        o.member = splat_proj + vec4f((vertex_pos.x * v1v2_scaled.xy + vertex_pos.y * v1v2_scaled.zw) / viewport * splat_proj.w, 0.0, 0.0);
-        o.vTexCoord = vertex_pos * scale / 2.0;
+        // Final position calculation (optimized)
+        let vertex_pos = position.xy;
+        let inv_viewport = 1.0 / viewport;
+        let offset = (vertex_pos.x * v1v2_scaled.xy + vertex_pos.y * v1v2_scaled.zw) * inv_viewport * splat_proj.w;
+        
+        var o: VSOut;
+        o.member = splat_proj + vec4f(offset, 0.0, 0.0);
+        o.vTexCoord = vertex_pos * (scale * 0.5);
         o.vColor = color;
         
         return o;
@@ -22931,20 +22905,20 @@ const GSplat_FS = (
   /* wgsl */
   `
     #include "FragmentOutput"
+    
+    // Constants
+    const ALPHA_THRESHOLD: f32 = 0.00392156863; // 1.0 / 255.0
+    const GAUSSIAN_SCALE: f32 = 4.0;
 
-    // === evalSplat() - like PlayCanvas splatCoreFS ===
+    // === evalSplat() - optimized gaussian evaluation ===
     fn evalSplat(texCoord: vec2f, color: vec4f) -> vec4f {
         let A = dot(texCoord, texCoord);
-        var B = exp(-A * 4.0) * color.a;
-        if (A > 1.0) {
-            B = 0.0;
-        }
         
-        if (B < 1.0 / 255.0) {
-            B = 0.0;
-        }
+        // 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);
         
-        return vec4f(color.rgb, B);
+        return vec4f(color.rgb, alpha);
     }
 
     @fragment
@@ -23184,6 +23158,7 @@ let GSplatShader = class extends Shader {
     pass.shaderState.transparent = true;
     pass.shaderState.blendMode = BlendMode.NORMAL;
     pass.shaderState.writeMasks = [15, 15];
+    pass.shaderState.castReflection = false;
     this.addRenderPass(pass);
     this.setDefault();
   }
@@ -24968,6 +24943,31 @@ let GSplatRenderer = class extends RenderNode {
       this._sortWorker.terminate();
       this._sortWorker = null;
     }
+    if (this.splatColor) {
+      this.splatColor.destroy(force);
+      this.splatColor = null;
+    }
+    if (this.transformA) {
+      this.transformA.destroy(force);
+      this.transformA = null;
+    }
+    if (this.transformB) {
+      this.transformB.destroy(force);
+      this.transformB = null;
+    }
+    if (this.splatOrder) {
+      this.splatOrder.destroy(force);
+      this.splatOrder = null;
+    }
+    if (this.gsplatMaterial) {
+      this.gsplatMaterial.destroy(force);
+      this.gsplatMaterial = null;
+    }
+    this._positions = null;
+    this._worldPositions = null;
+    this._orderData = null;
+    this.texParams = null;
+    this._mapping = null;
     super.destroy(force);
   }
 };
@@ -26875,6 +26875,43 @@ class MorphTargetData {
       usage
     );
   }
+  destroy(force) {
+    if (this._computeConfigBuffer) {
+      this._computeConfigBuffer.destroy(force);
+      this._computeConfigBuffer = null;
+    }
+    if (this._morphInfluenceBuffer) {
+      this._morphInfluenceBuffer.destroy(force);
+      this._morphInfluenceBuffer = null;
+    }
+    if (this._computeShader) {
+      this._computeShader.destroy(force);
+      this._computeShader = null;
+    }
+    if (this._positionAttrDataGroup) {
+      if (this._positionAttrDataGroup.input) {
+        this._positionAttrDataGroup.input.destroy(force);
+      }
+      if (this._positionAttrDataGroup.output) {
+        this._positionAttrDataGroup.output.destroy(force);
+      }
+      this._positionAttrDataGroup = null;
+    }
+    if (this._normalAttrDataGroup) {
+      if (this._normalAttrDataGroup.input) {
+        this._normalAttrDataGroup.input.destroy(force);
+      }
+      if (this._normalAttrDataGroup.output) {
+        this._normalAttrDataGroup.output.destroy(force);
+      }
+      this._normalAttrDataGroup = null;
+    }
+    this._computeConfigArray = null;
+    this._morphInfluenceArray = null;
+    this._collectMorphTargetData = null;
+    this._blendTarget = null;
+    this._computeShaders = null;
+  }
 }
 
 var __defProp = Object.defineProperty;
@@ -26986,6 +27023,10 @@ let MeshRenderer = class extends RenderNode {
     super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
   destroy(force) {
+    if (this.morphData) {
+      this.morphData.destroy(force);
+      this.morphData = null;
+    }
     super.destroy(force);
   }
 };
@@ -40891,7 +40932,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.13";
+const version = "1.0.14";
 
 class Engine3D {
   /**