@rings-webgpu/core 1.0.12 → 1.0.14

package/dist/rings.umd.max.js

@@ -22685,140 +22685,119 @@ struct InstanceData {
     /* wgsl */
     `
     #include "GlobalUniform"
-
-    struct VSOut {
-        @location(auto) vColor : vec4f,
-        @location(auto) vTexCoord : vec2f,
-        @builtin(position) member : vec4f
-    };
-
-    // ===== SPLAT CORE VS (from PlayCanvas shader-generator-gsplat.js) =====
-    
-    // Uniforms (mapped to WebGPU bindings)
-    // matrix_model, matrix_view, matrix_projection -> GlobalUniform + MaterialUniform
-    // viewport -> calculated from globalUniform.windowWidth/Height
-    // tex_params -> materialUniform.tex_params
     
-    @group(1) @binding(0) var splatColor : texture_2d<f32>;
-    @group(1) @binding(1) var transformA : texture_2d<u32>;
-    @group(1) @binding(2) var transformB : texture_2d<f32>;
-    @group(1) @binding(4) var splatOrder : texture_2d<u32>;
+    // 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 {
-        tex_params: vec4f,      // numSplats, textureWidth, validCount, visBoost
         modelMatrix: mat4x4<f32>,
-        pixelCull: vec4f,       // minPixels, maxPixels, maxPixelCullDistance, reserved
+        tex_params: vec4<f32>,      // [numSplats, texWidth, validCount, visBoost]
+        pixelCull: vec4<f32>,        // [minPixels, maxPixels, maxPixelCullDistance, batchSize]
+    };
+    @group(1) @binding(0) var<uniform> materialUniform: MaterialUniform;
+    
+    struct VSOut {
+        @builtin(position) member: vec4<f32>,
+        @location(0) vColor: vec4<f32>,
+        @location(1) vTexCoord: vec2<f32>,
     };
-    @group(1) @binding(3) var<uniform> materialUniform : MaterialUniform;
     
-    // Global variables (like PlayCanvas)
-    var<private> orderId: u32;
-    var<private> splatId: u32;
-    var<private> splatUV: vec2<i32>;
-    var<private> tA: vec4<u32>;
+    // Textures (like PlayCanvas)
+    @group(1) @binding(1) var splatColor: texture_2d<f32>;
+    @group(1) @binding(2) var transformA: texture_2d<u32>;
+    @group(1) @binding(3) var transformB: texture_2d<f32>;
+    @group(1) @binding(4) var splatOrder: texture_2d<u32>;
     
-    // Helper: decode 16-bit half float
-    fn unpackHalf(h: u32) -> f32 {
-        let s = (h >> 15u) & 0x1u;
-        let e = (h >> 10u) & 0x1fu;
-        let m = h & 0x3ffu;
-        let sign = select(1.0, -1.0, s == 1u);
-        if (e == 0u) {
-            if (m == 0u) { return 0.0; }
-            return sign * (f32(m) * exp2(-24.0));
-        } else if (e == 31u) {
-            return sign * 65504.0;
-        } else {
-            return sign * (1.0 + f32(m) / 1024.0) * exp2(f32(i32(e) - 15));
-        }
+    struct SplatData {
+        center: vec3f,
+        covA: vec3f,
+        covB: vec3f,
+    };
+    
+    // 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 bool ===
-    fn calcSplatUV(instance_id: u32) -> bool {
-        let numSplats = u32(materialUniform.tex_params.x);
-        let textureWidth = u32(materialUniform.tex_params.y);
-        
-        // calculate splat index
-        orderId = instance_id;
-        
-        if (orderId >= numSplats) {
-            return false;
-        }
-        
+    // === 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;
+        // Extract covariance
+        data.covA = tB.xyz;
+        data.covB = vec3f(tC.x, tC.y, tB.w);
+        
+        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);
@@ -22829,117 +22808,100 @@ struct InstanceData {
     @vertex
     fn VertMain(
         @builtin(vertex_index) vid : u32,
-        @builtin(instance_index) iid : u32
+        @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);
-        
-        // Vertex position array (PlayCanvas uses attribute vec3 with x,y in [-1,1])
-        let vertex_position = array<vec2f, 4>(
-            vec2f(-2.0, -2.0),
-            vec2f( 2.0, -2.0),
-            vec2f(-2.0,  2.0),
-            vec2f( 2.0,  2.0)
-        );
-        let vertex_pos = vertex_position[vid & 3u];
+        // Calculate splat ID
+        let batchSize = u32(materialUniform.pixelCull.w);
+        let orderId = iid * batchSize + u32(position.z);
         
-        // calculate splat uv
-        if (!calcSplatUV(iid)) {
-            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);
+        
+        // Load color early for alpha test
+        let color = textureLoad(splatColor, splatUV, 0);
+        if (color.a < ALPHA_THRESHOLD) {
+            return discardSplat();
+        }
         
-        // handle transforms
+        // 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
-        // Add margin for splat radius (conservative: ~2x max splat size)
-        let ndc = splat_proj.xyz / splat_proj.w;
-        let margin = 0.5; // Allow splats near edges to be visible
-        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);
-        
-        // calculate scale based on alpha
-        let scale = min(1.0, sqrt(-log(1.0 / 255.0 / color.a)) / 2.0);
+        // Calculate scale based on alpha (optimized formula)
+        let scale = min(1.0, sqrt(LOG_255 + log(color.a)) * 0.5);
         
-        // 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 (min and max thresholds)
-        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 (below minimum pixel coverage)
+        // 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 (above maximum pixel coverage)
-        // Only apply to splats close to camera (distance-based condition)
+        // Cull oversized splats
         if (maxPixels > 0.0) {
-            // Calculate distance from splat to camera
+            let maxPixelCullDistance = materialUniform.pixelCull.z;
             let splatDistance = length(splat_cam.xyz);
-            
-            // Only cull oversized splats if they are close to camera
             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();
                 }
             }
         }
         
-        // gl_Position = splat_proj + vec4((vertex_position.x * v1v2.xy + vertex_position.y * v1v2.zw) / viewport * splat_proj.w, 0, 0);
-        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);
-        
-        // texCoord = vertex_position.xy * scale / 2.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;
@@ -22950,31 +22912,29 @@ struct InstanceData {
     /* 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);
-        if (A > 1.0) {
-            discard;
-        }
         
-        let B = exp(-A * 4.0) * color.a;
-        if (B < 1.0 / 255.0) {
-            discard;
-        }
+        // 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);
         
-        // TONEMAP_ENABLED branch not implemented (would call toneMap() and gammaCorrectOutput())
-        return vec4f(color.rgb, B);
+        return vec4f(color.rgb, alpha);
     }
-    
-    // === main() - like PlayCanvas splatMainFS ===
+
     @fragment
-    fn FragMain(@location(auto) vColor: vec4f, @location(auto) vTexCoord: vec2f) -> FragmentOutput {
-        let result = evalSplat(vTexCoord, vColor);
-        
+    fn FragMain(
+        @location(0) vColor: vec4<f32>,
+        @location(1) vTexCoord: vec2<f32>
+    ) -> FragmentOutput {
         var o: FragmentOutput;
-        o.color = result;
-        o.gBuffer = vec4f(0.0);
+        o.color = evalSplat(vTexCoord, vColor);
         return o;
     }
 `
@@ -23199,12 +23159,13 @@ struct InstanceData {
       const pass = new RenderShaderPass("gsplat_vs_dc", "gsplat_fs_dc");
       pass.passType = PassType.COLOR;
       pass.setShaderEntry("VertMain", "FragMain");
-      pass.topology = GPUPrimitiveTopology.triangle_strip;
+      pass.topology = GPUPrimitiveTopology.triangle_list;
       pass.depthWriteEnabled = false;
-      pass.cullMode = "none";
+      pass.cullMode = GPUCullMode.none;
       pass.shaderState.transparent = true;
       pass.shaderState.blendMode = BlendMode.NORMAL;
       pass.shaderState.writeMasks = [15, 15];
+      pass.shaderState.castReflection = false;
       this.addRenderPass(pass);
       this.setDefault();
     }
@@ -23223,6 +23184,7 @@ struct InstanceData {
   ], exports.GSplatShader);
 
   class GSplatMaterial extends Material {
+    _pixelCullArray = new Float32Array(4);
     constructor() {
       super();
       ShaderLib.register("gsplat_vs_dc", GSplat_VS);
@@ -23238,6 +23200,7 @@ struct InstanceData {
       if (splatOrder) {
         pass.setTexture("splatOrder", splatOrder);
       }
+      pass.shaderState.depthCompare = GPUCompareFunction.less;
     }
     /**
      * Set the model matrix for transforming splats to world space
@@ -23252,9 +23215,13 @@ struct InstanceData {
      * @param maxPixels Maximum pixel coverage (cull oversized splats), default: 0 (disabled)
      * @param maxPixelCullDistance Only cull oversized splats within this distance, 0 = always cull
      */
-    setPixelCulling(minPixels, maxPixels, maxPixelCullDistance = 0) {
+    setPixelCulling(minPixels, maxPixels, maxPixelCullDistance = 0, batchSize = 128) {
+      this._pixelCullArray[0] = minPixels;
+      this._pixelCullArray[1] = maxPixels;
+      this._pixelCullArray[2] = maxPixelCullDistance;
+      this._pixelCullArray[3] = batchSize;
       const pass = this.shader.getDefaultColorShader();
-      pass.setUniform("pixelCull", new Float32Array([minPixels, maxPixels, maxPixelCullDistance, 0]));
+      pass.setUniform("pixelCull", this._pixelCullArray);
     }
   }
 
@@ -23912,108 +23879,47 @@ struct InstanceData {
     }
   }
 
-  class PlaneGeometry extends GeometryBase {
-    width;
-    height;
-    segmentW;
-    segmentH;
-    up;
-    constructor(width, height, segmentW = 1, segmentH = 1, up = Vector3.Y_AXIS) {
+  class GSplatGeometry extends GeometryBase {
+    batchSize;
+    constructor(batchSize = 128) {
       super();
-      this.width = width;
-      this.height = height;
-      this.segmentW = segmentW;
-      this.segmentH = segmentH;
-      this.up = up;
-      this.buildGeometry(this.up);
-    }
-    buildGeometry(axis) {
-      var x, y;
-      var numIndices;
-      var base;
-      var tw = this.segmentW + 1;
-      (this.segmentH + 1) * tw;
-      this.bounds = new BoundingBox(
-        Vector3.ZERO.clone(),
-        new Vector3(this.width, 1, this.height)
-      );
-      numIndices = this.segmentH * this.segmentW * 6;
-      let vertexCount = (this.segmentW + 1) * (this.segmentH + 1);
-      let position_arr = new Float32Array(vertexCount * 3);
-      let normal_arr = new Float32Array(vertexCount * 3);
-      let uv_arr = new Float32Array(vertexCount * 2);
-      let indices_arr;
-      let totalIndexCount = this.segmentW * this.segmentH * 2 * 3;
-      if (totalIndexCount >= Uint16Array.length) {
-        indices_arr = new Uint32Array(this.segmentW * this.segmentH * 2 * 3);
-      } else {
-        indices_arr = new Uint16Array(this.segmentW * this.segmentH * 2 * 3);
-      }
-      numIndices = 0;
-      var indexP = 0;
-      var indexN = 0;
-      var indexU = 0;
-      for (var yi = 0; yi <= this.segmentH; ++yi) {
-        for (var xi = 0; xi <= this.segmentW; ++xi) {
-          x = (xi / this.segmentW - 0.5) * this.width;
-          y = (yi / this.segmentH - 0.5) * this.height;
-          switch (axis) {
-            case Vector3.Y_AXIS:
-              position_arr[indexP++] = x;
-              position_arr[indexP++] = 0;
-              position_arr[indexP++] = y;
-              normal_arr[indexN++] = 0;
-              normal_arr[indexN++] = 1;
-              normal_arr[indexN++] = 0;
-              break;
-            case Vector3.Z_AXIS:
-              position_arr[indexP++] = x;
-              position_arr[indexP++] = -y;
-              position_arr[indexP++] = 0;
-              normal_arr[indexN++] = 0;
-              normal_arr[indexN++] = 0;
-              normal_arr[indexN++] = 1;
-              break;
-            case Vector3.X_AXIS:
-              position_arr[indexP++] = 0;
-              position_arr[indexP++] = x;
-              position_arr[indexP++] = y;
-              normal_arr[indexN++] = 1;
-              normal_arr[indexN++] = 0;
-              normal_arr[indexN++] = 0;
-              break;
-            default:
-              position_arr[indexP++] = x;
-              position_arr[indexP++] = 0;
-              position_arr[indexP++] = y;
-              normal_arr[indexN++] = 0;
-              normal_arr[indexN++] = 1;
-              normal_arr[indexN++] = 0;
-              break;
-          }
-          uv_arr[indexU++] = xi / this.segmentW;
-          uv_arr[indexU++] = yi / this.segmentH;
-          if (xi != this.segmentW && yi != this.segmentH) {
-            base = xi + yi * tw;
-            indices_arr[numIndices++] = base + 1;
-            indices_arr[numIndices++] = base;
-            indices_arr[numIndices++] = base + tw;
-            indices_arr[numIndices++] = base + 1;
-            indices_arr[numIndices++] = base + tw;
-            indices_arr[numIndices++] = base + tw + 1;
-          }
-        }
-      }
-      this.setIndices(indices_arr);
-      this.setAttribute(VertexAttributeName.position, position_arr);
-      this.setAttribute(VertexAttributeName.normal, normal_arr);
-      this.setAttribute(VertexAttributeName.uv, uv_arr);
-      this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+      this.batchSize = batchSize;
+      const meshPositions = new Float32Array(12 * batchSize);
+      for (let i = 0; i < batchSize; ++i) {
+        meshPositions.set([
+          -2,
+          -2,
+          i,
+          2,
+          -2,
+          i,
+          2,
+          2,
+          i,
+          -2,
+          2,
+          i
+        ], i * 12);
+      }
+      const meshIndices = new Uint32Array(6 * batchSize);
+      for (let i = 0; i < batchSize; ++i) {
+        const b = i * 4;
+        meshIndices.set([
+          0 + b,
+          1 + b,
+          2 + b,
+          0 + b,
+          2 + b,
+          3 + b
+        ], i * 6);
+      }
+      this.setAttribute(VertexAttributeName.position, meshPositions);
+      this.setIndices(meshIndices);
       this.addSubGeometry({
         indexStart: 0,
-        indexCount: indices_arr.length,
+        indexCount: meshIndices.length,
         vertexStart: 0,
-        vertexCount: 0,
+        vertexCount: meshPositions.length / 3,
         firstStart: 0,
         index: 0,
         topology: 0
@@ -24117,18 +24023,49 @@ struct InstanceData {
     updateTexture(width, height, data) {
       let device = webGPUContext.device;
       const bytesPerRow = width * 4 * 4;
-      const staging = device.createBuffer({
+      device.queue.writeTexture(
+        { texture: this.getGPUTexture() },
+        data.buffer,
+        { bytesPerRow },
+        { width, height, depthOrArrayLayers: 1 }
+      );
+    }
+  }
+
+  class R32UintTexture extends Texture {
+    _dataBuffer;
+    create(width, height, data) {
+      let device = webGPUContext.device;
+      const bytesPerRow = width * 4;
+      this.format = GPUTextureFormat.r32uint;
+      const mipmapCount = 1;
+      this.createTextureDescriptor(width, height, mipmapCount, this.format);
+      const textureDataBuffer = this._dataBuffer = device.createBuffer({
         size: data.byteLength,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
       });
-      device.queue.writeBuffer(staging, 0, data.buffer);
+      device.queue.writeBuffer(textureDataBuffer, 0, data.buffer);
       const encoder = device.createCommandEncoder();
       encoder.copyBufferToTexture(
-        { buffer: staging, bytesPerRow },
+        { buffer: textureDataBuffer, bytesPerRow },
         { texture: this.getGPUTexture() },
         { width, height, depthOrArrayLayers: 1 }
       );
       device.queue.submit([encoder.finish()]);
+      this.samplerBindingLayout.type = `non-filtering`;
+      this.textureBindingLayout.sampleType = `uint`;
+      this.gpuSampler = device.createSampler({});
+      return this;
+    }
+    updateTexture(width, height, data) {
+      let device = webGPUContext.device;
+      const bytesPerRow = width * 4;
+      device.queue.writeTexture(
+        { texture: this.getGPUTexture() },
+        data.buffer,
+        { bytesPerRow },
+        { width, height, depthOrArrayLayers: 1 }
+      );
     }
   }
 
@@ -24270,14 +24207,15 @@ struct InstanceData {
     // Web Worker for sorting
     _sortWorker;
     _lastSentTime = 0;
-    _minIntervalMs = 0;
-    // No throttle for immediate sorting
+    _minIntervalMs = 16;
     _centersSent = false;
     _lastViewMatrixHash = 0;
     // Adaptive sorting optimization
     _lastCameraSpeed = 0;
     _adaptiveSorting = true;
     // Enable adaptive sorting by default
+    _lastPixelCullParams = "";
+    _texturesInitialized = false;
     // LOD (Level of Detail) system
     _lodEnabled = false;
     _lodDistances = [5, 10, 20, 40];
@@ -24299,6 +24237,11 @@ struct InstanceData {
     get fullCount() {
       return this._fullCount;
     }
+    // Batched rendering
+    _batchSize = 128;
+    // Splats per draw call
+    instanceCount = 0;
+    // For InstanceDrawComponent compatibility
     constructor() {
       super();
     }
@@ -24314,24 +24257,20 @@ struct InstanceData {
       this.texParams = new Float32Array([this.count, this.size.x, this.count, 1]);
       this._positions = asset.position;
       const total = this.size.x * this.size.y;
-      this._orderData = new Uint32Array(total * 4);
+      this._orderData = new Uint32Array(total);
       for (let i = 0; i < total; i++) {
-        const src = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
-        const base = i * 4;
-        this._orderData[base + 0] = src;
-        this._orderData[base + 1] = 0;
-        this._orderData[base + 2] = 0;
-        this._orderData[base + 3] = 0;
-      }
-      this.splatOrder = new Uint32ArrayTexture().create(this.size.x, this.size.y, this._orderData);
+        this._orderData[i] = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
+      }
+      this.splatOrder = new R32UintTexture().create(this.size.x, this.size.y, this._orderData);
       this.splatOrder.name = "splatOrder";
       this.splatOrder.minFilter = "nearest";
       this.splatOrder.magFilter = "nearest";
       this.splatOrder.addressModeU = "clamp-to-edge";
       this.splatOrder.addressModeV = "clamp-to-edge";
       this.gsplatMaterial = new GSplatMaterial();
-      this.geometry = new PlaneGeometry(1, 1, 1, 1);
+      this.geometry = new GSplatGeometry(this._batchSize);
       this.materials = [this.gsplatMaterial];
+      this.instanceCount = 0;
     }
     /**
      * Update splat sorting before rendering
@@ -24408,12 +24347,7 @@ struct InstanceData {
       this.texParams[2] = Math.min(this.texParams[0], this.count);
       const total = this.size.x * this.size.y;
       for (let i = 0; i < total; i++) {
-        const src = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
-        const base = i * 4;
-        this._orderData[base + 0] = src;
-        this._orderData[base + 1] = 0;
-        this._orderData[base + 2] = 0;
-        this._orderData[base + 3] = 0;
+        this._orderData[i] = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
       }
       this.splatOrder.updateTexture(this.size.x, this.size.y, this._orderData);
       if (this._sortWorker) {
@@ -24440,6 +24374,7 @@ struct InstanceData {
       } else {
         this._centersSent = false;
       }
+      this.instanceCount = 0;
     }
     /**
      * Set visibility boost factor (material uniform tex_params.w)
@@ -24503,6 +24438,18 @@ struct InstanceData {
         distanceEnabled: this._maxPixelCullDistance > 0
       };
     }
+    /**
+     * Get batching statistics
+     */
+    getBatchingStats() {
+      return {
+        enabled: true,
+        batchSize: this._batchSize,
+        instanceCount: this.instanceCount,
+        splatCount: this.count,
+        reduction: this.count > 0 ? (1 - this.instanceCount / this.count) * 100 : 0
+      };
+    }
     /**
      * Calculate texture size for given splat count
      */
@@ -24725,18 +24672,20 @@ struct InstanceData {
           const indices = new Uint32Array(newOrder);
           const total = this.size.x * this.size.y;
           const count = this.count;
-          this._orderData = new Uint32Array(total * 4);
-          for (let i = 0; i < total; i++) {
-            const src = i < count ? indices[i] : count > 0 ? count - 1 : 0;
-            const base = i * 4;
-            this._orderData[base + 0] = src;
-            this._orderData[base + 1] = 0;
-            this._orderData[base + 2] = 0;
-            this._orderData[base + 3] = 0;
+          if (!this._orderData || this._orderData.length !== total) {
+            this._orderData = new Uint32Array(total);
+          }
+          const validCount = Math.min(count, indices.length);
+          this._orderData.set(indices.subarray(0, validCount), 0);
+          if (validCount < total) {
+            const lastIndex = count > 0 ? count - 1 : 0;
+            this._orderData.fill(lastIndex, validCount, total);
           }
           this.splatOrder.updateTexture(this.size.x, this.size.y, this._orderData);
           const valid = Math.max(0, Math.min(this.count, ev.data.count | 0));
           this.texParams[2] = valid;
+          const newInstanceCount = Math.ceil(valid / this._batchSize);
+          this.instanceCount = newInstanceCount;
         };
         const worldPos = this._worldPositions || this._positions;
         const centers = this._mapping ? new Float32Array(this._mapping.length * 3) : new Float32Array(worldPos);
@@ -24939,30 +24888,22 @@ struct InstanceData {
     nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
       const worldMatrix = this.object3D.transform.worldMatrix;
       this.gsplatMaterial.setTransformMatrix(worldMatrix);
-      this.gsplatMaterial.setPixelCulling(this._minPixelCoverage, this._maxPixelCoverage, this._maxPixelCullDistance);
-      this.gsplatMaterial.setSplatTextures(
-        this.splatColor,
-        this.transformA,
-        this.transformB,
-        this.texParams,
-        this.splatOrder
-      );
-      super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
-    }
-    /**
-     * Render pass
-     */
-    renderPass2(view, passType, rendererPassState, clusterLightingBuffer, encoder, useBundle = false) {
-      for (let mat of this.materials) {
-        const passes = mat.getPass(passType);
-        if (!passes || passes.length === 0) continue;
-        for (const pass of passes) {
-          if (!pass.pipeline) continue;
-          pass.apply(this.geometry, rendererPassState);
-          GPUContext.bindPipeline(encoder, pass);
-          GPUContext.draw(encoder, 4, this.count, 0, 0);
-        }
+      const currentParams = `${this._minPixelCoverage},${this._maxPixelCoverage},${this._maxPixelCullDistance},${this._batchSize}`;
+      if (currentParams !== this._lastPixelCullParams) {
+        this.gsplatMaterial.setPixelCulling(this._minPixelCoverage, this._maxPixelCoverage, this._maxPixelCullDistance, this._batchSize);
+        this._lastPixelCullParams = currentParams;
+      }
+      if (!this._texturesInitialized) {
+        this.gsplatMaterial.setSplatTextures(
+          this.splatColor,
+          this.transformA,
+          this.transformB,
+          this.texParams,
+          this.splatOrder
+        );
+        this._texturesInitialized = true;
       }
+      super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
     }
     /**
      * Render pass (fallback)
@@ -24976,7 +24917,28 @@ struct InstanceData {
           if (!pass.pipeline) continue;
           pass.apply(this.geometry, renderContext.rendererPassState || renderContext);
           GPUContext.bindPipeline(encoder, pass);
-          GPUContext.draw(encoder, 4, this.count, 0, 0);
+          GPUContext.bindGeometryBuffer(encoder, this.geometry);
+          const subGeometry = this.geometry.subGeometries[0];
+          const lodInfo = subGeometry.lodLevels[0];
+          if (this.instanceCount > 0) {
+            GPUContext.drawIndexed(
+              encoder,
+              lodInfo.indexCount,
+              this.instanceCount,
+              lodInfo.indexStart,
+              0,
+              0
+            );
+          } else {
+            GPUContext.drawIndexed(
+              encoder,
+              lodInfo.indexCount,
+              1,
+              lodInfo.indexStart,
+              0,
+              0
+            );
+          }
         }
       }
     }
@@ -24988,6 +24950,31 @@ struct InstanceData {
         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);
     }
   };
@@ -26895,6 +26882,43 @@ struct InstanceData {
         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;
@@ -27006,6 +27030,10 @@ struct InstanceData {
       super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
     }
     destroy(force) {
+      if (this.morphData) {
+        this.morphData.destroy(force);
+        this.morphData = null;
+      }
       super.destroy(force);
     }
   };
@@ -27512,6 +27540,115 @@ struct InstanceData {
     }
   }
 
+  class PlaneGeometry extends GeometryBase {
+    width;
+    height;
+    segmentW;
+    segmentH;
+    up;
+    constructor(width, height, segmentW = 1, segmentH = 1, up = Vector3.Y_AXIS) {
+      super();
+      this.width = width;
+      this.height = height;
+      this.segmentW = segmentW;
+      this.segmentH = segmentH;
+      this.up = up;
+      this.buildGeometry(this.up);
+    }
+    buildGeometry(axis) {
+      var x, y;
+      var numIndices;
+      var base;
+      var tw = this.segmentW + 1;
+      (this.segmentH + 1) * tw;
+      this.bounds = new BoundingBox(
+        Vector3.ZERO.clone(),
+        new Vector3(this.width, 1, this.height)
+      );
+      numIndices = this.segmentH * this.segmentW * 6;
+      let vertexCount = (this.segmentW + 1) * (this.segmentH + 1);
+      let position_arr = new Float32Array(vertexCount * 3);
+      let normal_arr = new Float32Array(vertexCount * 3);
+      let uv_arr = new Float32Array(vertexCount * 2);
+      let indices_arr;
+      let totalIndexCount = this.segmentW * this.segmentH * 2 * 3;
+      if (totalIndexCount >= Uint16Array.length) {
+        indices_arr = new Uint32Array(this.segmentW * this.segmentH * 2 * 3);
+      } else {
+        indices_arr = new Uint16Array(this.segmentW * this.segmentH * 2 * 3);
+      }
+      numIndices = 0;
+      var indexP = 0;
+      var indexN = 0;
+      var indexU = 0;
+      for (var yi = 0; yi <= this.segmentH; ++yi) {
+        for (var xi = 0; xi <= this.segmentW; ++xi) {
+          x = (xi / this.segmentW - 0.5) * this.width;
+          y = (yi / this.segmentH - 0.5) * this.height;
+          switch (axis) {
+            case Vector3.Y_AXIS:
+              position_arr[indexP++] = x;
+              position_arr[indexP++] = 0;
+              position_arr[indexP++] = y;
+              normal_arr[indexN++] = 0;
+              normal_arr[indexN++] = 1;
+              normal_arr[indexN++] = 0;
+              break;
+            case Vector3.Z_AXIS:
+              position_arr[indexP++] = x;
+              position_arr[indexP++] = -y;
+              position_arr[indexP++] = 0;
+              normal_arr[indexN++] = 0;
+              normal_arr[indexN++] = 0;
+              normal_arr[indexN++] = 1;
+              break;
+            case Vector3.X_AXIS:
+              position_arr[indexP++] = 0;
+              position_arr[indexP++] = x;
+              position_arr[indexP++] = y;
+              normal_arr[indexN++] = 1;
+              normal_arr[indexN++] = 0;
+              normal_arr[indexN++] = 0;
+              break;
+            default:
+              position_arr[indexP++] = x;
+              position_arr[indexP++] = 0;
+              position_arr[indexP++] = y;
+              normal_arr[indexN++] = 0;
+              normal_arr[indexN++] = 1;
+              normal_arr[indexN++] = 0;
+              break;
+          }
+          uv_arr[indexU++] = xi / this.segmentW;
+          uv_arr[indexU++] = yi / this.segmentH;
+          if (xi != this.segmentW && yi != this.segmentH) {
+            base = xi + yi * tw;
+            indices_arr[numIndices++] = base + 1;
+            indices_arr[numIndices++] = base;
+            indices_arr[numIndices++] = base + tw;
+            indices_arr[numIndices++] = base + 1;
+            indices_arr[numIndices++] = base + tw;
+            indices_arr[numIndices++] = base + tw + 1;
+          }
+        }
+      }
+      this.setIndices(indices_arr);
+      this.setAttribute(VertexAttributeName.position, position_arr);
+      this.setAttribute(VertexAttributeName.normal, normal_arr);
+      this.setAttribute(VertexAttributeName.uv, uv_arr);
+      this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+      this.addSubGeometry({
+        indexStart: 0,
+        indexCount: indices_arr.length,
+        vertexStart: 0,
+        vertexCount: 0,
+        firstStart: 0,
+        index: 0,
+        topology: 0
+      });
+    }
+  }
+
   var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
   var __decorateClass$g = (decorators, target, key, kind) => {
     var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
@@ -30486,7 +30623,15 @@ struct InstanceData {
     shadowMapPassRenderer;
     pointLightShadowRenderer;
     ddgiProbeRenderer;
-    postRenderer;
+    _postRenderer;
+    get postRenderer() {
+      if (!this._postRenderer) {
+        let gbufferFrame = GBufferFrame.getGBufferFrame("ColorPassGBuffer");
+        this._postRenderer = this.addRenderer(PostRenderer);
+        this._postRenderer.setRenderStates(gbufferFrame);
+      }
+      return this._postRenderer;
+    }
     clusterLightingRender;
     reflectionRenderer;
     occlusionSystem;
@@ -30510,7 +30655,9 @@ struct InstanceData {
       }
       this.shadowMapPassRenderer = new ShadowMapPassRenderer();
       this.pointLightShadowRenderer = new PointLightShadowRenderer();
-      this.addPost(new FXAAPost());
+      if (Engine3D.setting.render.postProcessing.fxaa.enable) {
+        this.addPost(new FXAAPost());
+      }
     }
     addRenderer(c, param) {
       let renderer;
@@ -30540,11 +30687,6 @@ struct InstanceData {
       this.pauseRender = false;
     }
     addPost(post) {
-      if (!this.postRenderer) {
-        let gbufferFrame = GBufferFrame.getGBufferFrame("ColorPassGBuffer");
-        this.postRenderer = this.addRenderer(PostRenderer);
-        this.postRenderer.setRenderStates(gbufferFrame);
-      }
       if (post instanceof PostBase) {
         this.postRenderer.attachPost(this.view, post);
       }
@@ -30562,15 +30704,21 @@ struct InstanceData {
     renderFrame() {
       let view = this._view;
       ProfilerUtil.startView(view);
-      GlobalBindGroup.getLightEntries(view.scene).update(view);
-      GlobalBindGroup.getReflectionEntries(view.scene).update(view);
-      this.occlusionSystem.update(view.camera, view.scene);
-      this.clusterLightingRender.render(view, this.occlusionSystem);
-      if (this.shadowMapPassRenderer) {
+      if (this.clusterLightingRender) {
+        GlobalBindGroup.getLightEntries(view.scene).update(view);
+        GlobalBindGroup.getReflectionEntries(view.scene).update(view);
+      }
+      if (Engine3D.setting.occlusionQuery.enable && this.occlusionSystem) {
+        this.occlusionSystem.update(view.camera, view.scene);
+      }
+      if (this.clusterLightingRender) {
+        this.clusterLightingRender.render(view, this.occlusionSystem);
+      }
+      if (Engine3D.setting.shadow.enable && this.shadowMapPassRenderer) {
         ShadowLightsCollect.update(view);
         this.shadowMapPassRenderer.render(view, this.occlusionSystem);
       }
-      if (this.pointLightShadowRenderer) {
+      if (Engine3D.setting.shadow.enable && this.pointLightShadowRenderer) {
         this.pointLightShadowRenderer.render(view, this.occlusionSystem);
       }
       if (this.depthPassRenderer) {
@@ -40791,7 +40939,7 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     }
   }
 
-  const version = "1.0.12";
+  const version = "1.0.14";
 
   class Engine3D {
     /**
@@ -66579,6 +66727,7 @@ fn frag(){
   exports.GPUVertexFormat = GPUVertexFormat;
   exports.GPUVertexStepMode = GPUVertexStepMode;
   exports.GSplatFormat = GSplatFormat;
+  exports.GSplatGeometry = GSplatGeometry;
   exports.GSplatMaterial = GSplatMaterial;
   exports.GSplat_FS = GSplat_FS;
   exports.GSplat_VS = GSplat_VS;
@@ -66827,6 +66976,7 @@ fn frag(){
   exports.Quad_frag_wgsl = Quad_frag_wgsl;
   exports.Quad_vert_wgsl = Quad_vert_wgsl;
   exports.Quaternion = Quaternion;
+  exports.R32UintTexture = R32UintTexture;
   exports.RADIANS_TO_DEGREES = RADIANS_TO_DEGREES;
   exports.RGBEErrorCode = RGBEErrorCode;
   exports.RGBEHeader = RGBEHeader;