@rings-webgpu/core 1.0.12 → 1.0.14

package/dist/rings.es.max.js

@@ -22678,140 +22678,119 @@ const GSplat_VS = (
   /* 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);
@@ -22822,117 +22801,100 @@ const GSplat_VS = (
     @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;
@@ -22943,31 +22905,29 @@ 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);
-        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;
     }
 `
@@ -23192,12 +23152,13 @@ let GSplatShader = class extends Shader {
     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();
   }
@@ -23216,6 +23177,7 @@ GSplatShader = __decorateClass$k([
 ], GSplatShader);
 
 class GSplatMaterial extends Material {
+  _pixelCullArray = new Float32Array(4);
   constructor() {
     super();
     ShaderLib.register("gsplat_vs_dc", GSplat_VS);
@@ -23231,6 +23193,7 @@ class GSplatMaterial extends Material {
     if (splatOrder) {
       pass.setTexture("splatOrder", splatOrder);
     }
+    pass.shaderState.depthCompare = GPUCompareFunction.less;
   }
   /**
    * Set the model matrix for transforming splats to world space
@@ -23245,9 +23208,13 @@ class GSplatMaterial extends Material {
    * @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);
   }
 }
 
@@ -23905,108 +23872,47 @@ class GeometryBase {
   }
 }
 
-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
@@ -24110,18 +24016,49 @@ class Uint32ArrayTexture extends Texture {
   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 }
+    );
   }
 }
 
@@ -24263,14 +24200,15 @@ let GSplatRenderer = class extends RenderNode {
   // 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];
@@ -24292,6 +24230,11 @@ let GSplatRenderer = class extends RenderNode {
   get fullCount() {
     return this._fullCount;
   }
+  // Batched rendering
+  _batchSize = 128;
+  // Splats per draw call
+  instanceCount = 0;
+  // For InstanceDrawComponent compatibility
   constructor() {
     super();
   }
@@ -24307,24 +24250,20 @@ let GSplatRenderer = class extends RenderNode {
     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
@@ -24401,12 +24340,7 @@ let GSplatRenderer = class extends RenderNode {
     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) {
@@ -24433,6 +24367,7 @@ let GSplatRenderer = class extends RenderNode {
     } else {
       this._centersSent = false;
     }
+    this.instanceCount = 0;
   }
   /**
    * Set visibility boost factor (material uniform tex_params.w)
@@ -24496,6 +24431,18 @@ let GSplatRenderer = class extends RenderNode {
       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
    */
@@ -24718,18 +24665,20 @@ let GSplatRenderer = class extends RenderNode {
         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);
@@ -24932,30 +24881,22 @@ let GSplatRenderer = class extends RenderNode {
   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)
@@ -24969,7 +24910,28 @@ let GSplatRenderer = class extends RenderNode {
         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
+          );
+        }
       }
     }
   }
@@ -24981,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);
   }
 };
@@ -26888,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;
@@ -26999,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);
   }
 };
@@ -27505,6 +27533,115 @@ class WebGPUDescriptorCreator {
   }
 }
 
+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;
@@ -30479,7 +30616,15 @@ class RendererJob {
   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;
@@ -30503,7 +30648,9 @@ class RendererJob {
     }
     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;
@@ -30533,11 +30680,6 @@ class RendererJob {
     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);
     }
@@ -30555,15 +30697,21 @@ class RendererJob {
   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) {
@@ -40784,7 +40932,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.12";
+const version = "1.0.14";
 
 class Engine3D {
   /**
@@ -66370,4 +66518,4 @@ const __viteBrowserExternal = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.def
   __proto__: null
 }, Symbol.toStringTag, { value: 'Module' }));
 
-export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FatLineGeometry, FatLineMaterial, FatLineRenderer, FatLineShader, FatLine_FS, FatLine_VS, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GSplatFormat, GSplatMaterial, GSplatRenderer, GSplatShader, GSplat_FS, GSplat_VS, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GaussianSplatParser, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KMZParser, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LDRTextureCube, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MinMaxAnimationCurves, MinMaxCurve, MinMaxCurveState, MinMaxPolyCurves, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PBRLItShader, PBRLitSSSShader, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PointClassification, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UUID, UV, Uint32ArrayTexture, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, ValueSpread, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGSLTranslator, WayLines3D, WayPoint3D, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, buildCurves, byteSizeOfType, calculateCurveRangesValue, calculateMinMax, castPointShadowMap_vert, clamp, clampRepeat, computeAABBFromPositions, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, curvesSupportProcedural, deg2Rad, detectGSplatFormat, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, inferSHOrder, integrateSegment, irradianceDataReader, kPI, lerp, lerpByte, lerpColor, lerpVector3, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, perm, post, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readByType, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, toHalfFloat, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };
+export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FatLineGeometry, FatLineMaterial, FatLineRenderer, FatLineShader, FatLine_FS, FatLine_VS, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GSplatFormat, GSplatGeometry, GSplatMaterial, GSplatRenderer, GSplatShader, GSplat_FS, GSplat_VS, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GaussianSplatParser, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KMZParser, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LDRTextureCube, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MinMaxAnimationCurves, MinMaxCurve, MinMaxCurveState, MinMaxPolyCurves, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PBRLItShader, PBRLitSSSShader, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PointClassification, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, R32UintTexture, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UUID, UV, Uint32ArrayTexture, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, ValueSpread, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGSLTranslator, WayLines3D, WayPoint3D, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, buildCurves, byteSizeOfType, calculateCurveRangesValue, calculateMinMax, castPointShadowMap_vert, clamp, clampRepeat, computeAABBFromPositions, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, curvesSupportProcedural, deg2Rad, detectGSplatFormat, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, inferSHOrder, integrateSegment, irradianceDataReader, kPI, lerp, lerpByte, lerpColor, lerpVector3, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, perm, post, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readByType, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, toHalfFloat, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };