@rings-webgpu/core 1.0.12 → 1.0.13

package/dist/rings.umd.max.js

@@ -22685,61 +22685,35 @@ 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>;
     
     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(3) var<uniform> materialUniform : MaterialUniform;
+    @group(1) @binding(0) var<uniform> materialUniform: MaterialUniform;
     
-    // Global variables (like PlayCanvas)
-    var<private> orderId: u32;
-    var<private> splatId: u32;
+    struct VSOut {
+        @builtin(position) member: vec4<f32>,
+        @location(0) vColor: vec4<f32>,
+        @location(1) vTexCoord: vec2<f32>,
+    };
+    
+    // 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>;
+    
+    // Global variables for texture lookups
     var<private> splatUV: vec2<i32>;
+    var<private> splatId: u32;
     var<private> tA: vec4<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));
-        }
-    }
-    
     // === calcSplatUV() - returns bool ===
-    fn calcSplatUV(instance_id: u32) -> bool {
-        let numSplats = u32(materialUniform.tex_params.x);
+    fn calcSplatUV(orderId: u32) -> bool {
         let textureWidth = u32(materialUniform.tex_params.y);
-        
-        // calculate splat index
-        orderId = instance_id;
+        let numSplats = u32(materialUniform.tex_params.x);
         
         if (orderId >= numSplats) {
             return false;
@@ -22786,6 +22760,19 @@ struct InstanceData {
         return result;
     }
     
+    // === getRotationMatrix() - returns mat3x3 ===
+    fn getRotationMatrix() -> mat3x3f {
+        let cov_data = getCovariance();
+        let covA = cov_data.covA;
+        let covB = cov_data.covB;
+        
+        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))
+        );
+    }
+    
     // === calcV1V2() - returns vec4 ===
     fn calcV1V2(splat_cam: vec3f, covA: vec3f, covB: vec3f, W: mat3x3f, viewport: vec2f, projMat: mat4x4f) -> vec4f {
         let Vrk = mat3x3f(
@@ -22829,22 +22816,25 @@ 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
+        // 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;
+        
+        // Use vertex position from mesh
+        let vertex_pos = position.xy;
         
         // calculate splat uv
-        if (!calcSplatUV(iid)) {
+        if (!calcSplatUV(orderId)) {
             o.member = discardVec;
             o.vColor = vec4f(0.0);
             o.vTexCoord = vec2f(0.0);
@@ -22872,9 +22862,8 @@ struct InstanceData {
         }
         
         // 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
+        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 ||
             ndc.z < 0.0 || ndc.z > 1.0) {
@@ -22892,6 +22881,12 @@ struct InstanceData {
         
         // 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
         let scale = min(1.0, sqrt(-log(1.0 / 255.0 / color.a)) / 2.0);
@@ -22900,7 +22895,7 @@ struct InstanceData {
         let visBoost = materialUniform.tex_params.w;
         var v1v2_scaled = v1v2 * scale * visBoost;
         
-        // Pixel coverage culling (min and max thresholds)
+        // 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);
         
@@ -22908,7 +22903,7 @@ struct InstanceData {
         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);
@@ -22916,13 +22911,9 @@ struct InstanceData {
             return o;
         }
         
-        // 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 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) {
@@ -22934,12 +22925,9 @@ struct InstanceData {
             }
         }
         
-        // gl_Position = splat_proj + vec4((vertex_position.x * v1v2.xy + vertex_position.y * v1v2.zw) / viewport * splat_proj.w, 0, 0);
+        // 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);
-        
-        // texCoord = vertex_position.xy * scale / 2.0;
         o.vTexCoord = vertex_pos * scale / 2.0;
-        
         o.vColor = color;
         
         return o;
@@ -22954,27 +22942,25 @@ struct InstanceData {
     // === evalSplat() - like PlayCanvas splatCoreFS ===
     fn evalSplat(texCoord: vec2f, color: vec4f) -> vec4f {
         let A = dot(texCoord, texCoord);
+        var B = exp(-A * 4.0) * color.a;
         if (A > 1.0) {
-            discard;
+            B = 0.0;
         }
         
-        let B = exp(-A * 4.0) * color.a;
         if (B < 1.0 / 255.0) {
-            discard;
+            B = 0.0;
         }
         
-        // TONEMAP_ENABLED branch not implemented (would call toneMap() and gammaCorrectOutput())
         return vec4f(color.rgb, B);
     }
-    
-    // === 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,9 +23185,9 @@ 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];
@@ -23223,6 +23209,7 @@ struct InstanceData {
   ], exports.GSplatShader);
 
   class GSplatMaterial extends Material {
+    _pixelCullArray = new Float32Array(4);
     constructor() {
       super();
       ShaderLib.register("gsplat_vs_dc", GSplat_VS);
@@ -23238,6 +23225,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 +23240,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 +23904,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 +24048,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 +24232,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 +24262,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 +24282,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 +24372,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 +24399,7 @@ struct InstanceData {
       } else {
         this._centersSent = false;
       }
+      this.instanceCount = 0;
     }
     /**
      * Set visibility boost factor (material uniform tex_params.w)
@@ -24503,6 +24463,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 +24697,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 +24913,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 +24942,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
+            );
+          }
         }
       }
     }
@@ -27512,6 +27499,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 +30582,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 +30614,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 +30646,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 +30663,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 +40898,7 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     }
   }
 
-  const version = "1.0.12";
+  const version = "1.0.13";
 
   class Engine3D {
     /**
@@ -66579,6 +66686,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 +66935,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;