@rings-webgpu/core 1.0.35 → 1.0.37

package/dist/rings.es.max.js

@@ -2113,7 +2113,7 @@ function GetShader(name) {
 }
 
 var __defProp$2 = Object.defineProperty;
-var __decorateClass$o = (decorators, target, key, kind) => {
+var __decorateClass$p = (decorators, target, key, kind) => {
   var result = void 0 ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
@@ -2216,10 +2216,10 @@ const _Struct = class _Struct {
     return struct.__size;
   }
 };
-__decorateClass$o([
+__decorateClass$p([
   NonSerialize
 ], _Struct.prototype, "__refection");
-__decorateClass$o([
+__decorateClass$p([
   NonSerialize
 ], _Struct.prototype, "__size");
 let Struct = _Struct;
@@ -21965,9 +21965,9 @@ class OctreeEntity {
 }
 
 var __defProp$1 = Object.defineProperty;
-var __getOwnPropDesc$n = Object.getOwnPropertyDescriptor;
-var __decorateClass$n = (decorators, target, key, kind) => {
-  var result = __getOwnPropDesc$n(target, key) ;
+var __getOwnPropDesc$o = Object.getOwnPropertyDescriptor;
+var __decorateClass$o = (decorators, target, key, kind) => {
+  var result = __getOwnPropDesc$o(target, key) ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(target, key, result) ) || result;
@@ -22565,13 +22565,13 @@ class RenderNode extends ComponentBase {
     this._combineShaderRefection = void 0;
   }
 }
-__decorateClass$n([
+__decorateClass$o([
   EditorInspector
 ], RenderNode.prototype, "materials");
-__decorateClass$n([
+__decorateClass$o([
   EditorInspector
 ], RenderNode.prototype, "castShadow");
-__decorateClass$n([
+__decorateClass$o([
   EditorInspector
 ], RenderNode.prototype, "castGI");
 
@@ -23238,9 +23238,9 @@ class Shader {
   }
 }
 
-var __getOwnPropDesc$m = Object.getOwnPropertyDescriptor;
-var __decorateClass$m = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$m(target, key) : target;
+var __getOwnPropDesc$n = Object.getOwnPropertyDescriptor;
+var __decorateClass$n = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$n(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -23272,7 +23272,7 @@ let GSplatShader = class extends Shader {
     pass.setUniform("pixelCull", new Float32Array([2, 0, 0, 0]));
   }
 };
-GSplatShader = __decorateClass$m([
+GSplatShader = __decorateClass$n([
   RegisterShader(GSplatShader, "GSplatShader")
 ], GSplatShader);
 
@@ -23316,6 +23316,10 @@ class GSplatMaterial extends Material {
     const pass = this.shader.getDefaultColorShader();
     pass.setUniform("pixelCull", this._pixelCullArray);
   }
+  setTexParams(texParams) {
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniformArray("tex_params", texParams);
+  }
 }
 
 class VertexGPUBuffer extends GPUBufferBase {
@@ -24289,9 +24293,9 @@ class Float16ArrayTexture extends Texture {
   }
 }
 
-var __getOwnPropDesc$l = Object.getOwnPropertyDescriptor;
-var __decorateClass$l = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$l(target, key) : target;
+var __getOwnPropDesc$m = Object.getOwnPropertyDescriptor;
+var __decorateClass$m = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$m(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -25090,7 +25094,7 @@ let GSplatRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-GSplatRenderer = __decorateClass$l([
+GSplatRenderer = __decorateClass$m([
   RegisterComponent(GSplatRenderer, "GSplatRenderer")
 ], GSplatRenderer);
 
@@ -25229,9 +25233,9 @@ const PointCloud_FS = (
 `
 );
 
-var __getOwnPropDesc$k = Object.getOwnPropertyDescriptor;
-var __decorateClass$k = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$k(target, key) : target;
+var __getOwnPropDesc$l = Object.getOwnPropertyDescriptor;
+var __decorateClass$l = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$l(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -25263,7 +25267,7 @@ let PointCloudShader = class extends Shader {
     pass.setUniformArray("pointParams", new Float32Array([0, 0, 0, 128]));
   }
 };
-PointCloudShader = __decorateClass$k([
+PointCloudShader = __decorateClass$l([
   RegisterShader(PointCloudShader, "PointCloudShader")
 ], PointCloudShader);
 
@@ -25456,9 +25460,9 @@ class Float32ArrayTexture extends Texture {
   }
 }
 
-var __getOwnPropDesc$j = Object.getOwnPropertyDescriptor;
-var __decorateClass$j = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$j(target, key) : target;
+var __getOwnPropDesc$k = Object.getOwnPropertyDescriptor;
+var __decorateClass$k = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$k(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -25769,7 +25773,7 @@ let PointCloudRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-PointCloudRenderer = __decorateClass$j([
+PointCloudRenderer = __decorateClass$k([
   RegisterComponent(PointCloudRenderer, "PointCloudRenderer")
 ], PointCloudRenderer);
 
@@ -26124,9 +26128,9 @@ class Entity extends CEventDispatcher {
   }
 }
 
-var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
-var __decorateClass$i = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$i(target, key) : target;
+var __getOwnPropDesc$j = Object.getOwnPropertyDescriptor;
+var __decorateClass$j = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$j(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -26401,7 +26405,7 @@ let Object3D = class extends Entity {
     super.destroy(force);
   }
 };
-Object3D = __decorateClass$i([
+Object3D = __decorateClass$j([
   DecorateObject3D
 ], Object3D);
 function DecorateObject3D(ctor, _) {
@@ -27767,9 +27771,9 @@ class MorphTargetData {
 }
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
-var __decorateClass$h = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
+var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
+var __decorateClass$i = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$i(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
@@ -27882,13 +27886,13 @@ let MeshRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-__decorateClass$h([
+__decorateClass$i([
   EditorInspector
 ], MeshRenderer.prototype, "geometry", 1);
-__decorateClass$h([
+__decorateClass$i([
   EditorInspector
 ], MeshRenderer.prototype, "material", 1);
-MeshRenderer = __decorateClass$h([
+MeshRenderer = __decorateClass$i([
   RegisterComponent(MeshRenderer, "MeshRenderer")
 ], MeshRenderer);
 
@@ -28494,9 +28498,9 @@ class PlaneGeometry extends GeometryBase {
   }
 }
 
-var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
-var __decorateClass$g = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
+var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
+var __decorateClass$h = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -28520,7 +28524,7 @@ let QuadShader = class extends Shader {
     this.setUniformFloat(`height`, 100);
   }
 };
-QuadShader = __decorateClass$g([
+QuadShader = __decorateClass$h([
   RegisterShader(QuadShader, "QuadShader")
 ], QuadShader);
 
@@ -35883,9 +35887,9 @@ class LightBase extends ComponentBase {
   }
 }
 
-var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
-var __decorateClass$f = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
+var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
+var __decorateClass$g = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -35927,13 +35931,13 @@ let DirectLight = class extends LightBase {
   debug() {
   }
 };
-DirectLight = __decorateClass$f([
+DirectLight = __decorateClass$g([
   RegisterComponent(DirectLight, "DirectLight")
 ], DirectLight);
 
-var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
-var __decorateClass$e = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
+var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
+var __decorateClass$f = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -35991,13 +35995,13 @@ let PointLight = class extends LightBase {
   debugDraw(show) {
   }
 };
-PointLight = __decorateClass$e([
+PointLight = __decorateClass$f([
   RegisterComponent(PointLight, "PointLight")
 ], PointLight);
 
-var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
-var __decorateClass$d = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
+var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
+var __decorateClass$e = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -36062,7 +36066,7 @@ let SpotLight = class extends LightBase {
   debugDraw(show) {
   }
 };
-SpotLight = __decorateClass$d([
+SpotLight = __decorateClass$e([
   RegisterComponent(SpotLight, "SpotLight")
 ], SpotLight);
 
@@ -38233,7 +38237,7 @@ class OBJParser extends ParserBase {
         const texturePath = StringUtil.normalizePath(
           this.baseUrl + matData.map_Kd
         );
-        const texture = Engine3D.res.getTexture(texturePath);
+        const texture = Engine3D.res.getTexture(texturePath + OBJParser.cloudImageProcessParam);
         if (texture) {
           mat.baseMap = texture;
         }
@@ -42147,7 +42151,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.34";
+const version = "1.0.36";
 
 class Engine3D {
   /**
@@ -46660,9 +46664,9 @@ class AtmosphericTexture2D extends VirtualTexture {
   }
 }
 
-var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
-var __decorateClass$c = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
+var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
+var __decorateClass$d = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -46686,7 +46690,7 @@ let SkyShader = class extends Shader {
     shaderState.depthCompare = GPUCompareFunction.less;
   }
 };
-SkyShader = __decorateClass$c([
+SkyShader = __decorateClass$d([
   RegisterShader(SkyShader, "SkyShader")
 ], SkyShader);
 
@@ -47484,9 +47488,9 @@ class SkeletonAnimationClipState {
   }
 }
 
-var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
-var __decorateClass$b = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
+var __decorateClass$c = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -47690,7 +47694,7 @@ let SkeletonAnimationComponent = class extends ComponentBase {
     this._currentClipState.weight = 1;
   }
 };
-SkeletonAnimationComponent = __decorateClass$b([
+SkeletonAnimationComponent = __decorateClass$c([
   RegisterComponent(SkeletonAnimationComponent, "SkeletonAnimationComponent")
 ], SkeletonAnimationComponent);
 class SkeletonAnimationCrossFadeState {
@@ -47726,9 +47730,9 @@ class SkeletonAnimationCrossFadeState {
   }
 }
 
-var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
-var __decorateClass$a = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+var __decorateClass$b = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -48139,7 +48143,7 @@ let AnimatorComponent = class extends ComponentBase {
     return dst;
   }
 };
-AnimatorComponent = __decorateClass$a([
+AnimatorComponent = __decorateClass$b([
   RegisterComponent(AnimatorComponent, "AnimatorComponent")
 ], AnimatorComponent);
 class PropertyAnimationClipState {
@@ -48896,9 +48900,9 @@ class PropertyAnimation extends ComponentBase {
   }
 }
 
-var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
-var __decorateClass$9 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
+var __decorateClass$a = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -49047,7 +49051,7 @@ let SkinnedMeshRenderer2 = class extends MeshRenderer {
     super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
 };
-SkinnedMeshRenderer2 = __decorateClass$9([
+SkinnedMeshRenderer2 = __decorateClass$a([
   RegisterComponent(SkinnedMeshRenderer2, "SkinnedMeshRenderer2")
 ], SkinnedMeshRenderer2);
 
@@ -54180,9 +54184,9 @@ class UITextField extends UIRenderAble {
   }
 }
 
-var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
-var __decorateClass$8 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
+var __decorateClass$9 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -54259,13 +54263,13 @@ let Light = class extends LightBase {
   debugDraw(show) {
   }
 };
-Light = __decorateClass$8([
+Light = __decorateClass$9([
   RegisterComponent(Light, "Light")
 ], Light);
 
-var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
-var __decorateClass$7 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -54340,10 +54344,771 @@ let FatLineRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-FatLineRenderer = __decorateClass$7([
+FatLineRenderer = __decorateClass$8([
   RegisterComponent(FatLineRenderer, "FatLineRenderer")
 ], FatLineRenderer);
 
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+let GSplatStreamRenderer = class extends RenderNode {
+  // Splat count and texture dimensions
+  totalCount = 0;
+  size = new Vector2();
+  worldBoundBox = new BoundingBox();
+  // GPU textures for splat data
+  splatColor;
+  transformA;
+  transformB;
+  texParams;
+  // [numSplats, texWidth, validCount, visBoost]
+  splatOrder;
+  // Material and geometry
+  gsplatMaterial;
+  // CPU-side data buffers (pre-allocated)
+  _colorData;
+  // RGBA8: count * 4
+  _transformAData;
+  // RGBA32U: count * 4
+  _transformBData;
+  // RGBA16F: count * 4
+  _orderData;
+  // R32U: size.x * size.y
+  _positions;
+  // xyz per splat (local space)
+  _worldPositions;
+  // xyz per splat (world space, cached)
+  // Tracking which splats have been set
+  _splatSetFlags;
+  // Track which indices have data
+  _validCount = 0;
+  // Number of splats with valid data
+  // Web Worker for sorting (same as GSplatRenderer)
+  _sortWorker;
+  _lastSentTime = 0;
+  _minIntervalMs = 16;
+  _centersSent = false;
+  _lastViewMatrixHash = 0;
+  // Adaptive sorting optimization
+  _lastCameraSpeed = 0;
+  _adaptiveSorting = true;
+  _lastPixelCullParams = "";
+  _texturesInitialized = false;
+  // Pixel coverage culling
+  _minPixelCoverage = 4;
+  _maxPixelCoverage = 0;
+  _maxPixelCullDistance = 0;
+  // Batched rendering
+  _batchSize = 128;
+  instanceCount = 0;
+  // Batch update optimization
+  _pendingUpdates = /* @__PURE__ */ new Set();
+  // Indices pending GPU update
+  _autoFlushThreshold = 100;
+  // Auto-flush when this many updates pending
+  _frameCount = 0;
+  constructor() {
+    super();
+  }
+  /**
+   * Initialize renderer with total splat count
+   * Pre-allocates all GPU resources with zero-initialized data
+   * @param totalCount Total number of splats that will be streamed
+   * @param batchSize Splats per draw call (default: 128)
+   */
+  initCount(totalCount, batchSize = 128) {
+    if (totalCount <= 0) {
+      throw new Error("Total count must be greater than 0");
+    }
+    this.totalCount = totalCount;
+    this._batchSize = batchSize;
+    this.size = this.evalTextureSize(totalCount);
+    const w = this.size.x | 0;
+    const h = this.size.y | 0;
+    const total = w * h;
+    this._colorData = new Uint8Array(total * 4);
+    this._colorData.fill(0);
+    this._transformAData = new Uint32Array(total * 4);
+    this._transformAData.fill(0);
+    this._transformBData = new Array(total * 4).fill(0);
+    this._orderData = new Uint32Array(total);
+    for (let i = 0; i < total; i++) {
+      this._orderData[i] = i < totalCount ? i : totalCount > 0 ? totalCount - 1 : 0;
+    }
+    this._positions = new Float32Array(totalCount * 3);
+    this._positions.fill(0);
+    this._worldPositions = new Float32Array(totalCount * 3);
+    this._worldPositions.fill(0);
+    this._splatSetFlags = new Array(totalCount).fill(false);
+    this._validCount = 0;
+    this.texParams = new Float32Array([this._validCount, this.size.x, 0, 1]);
+    this.splatColor = new Uint8ArrayTexture().create(w, h, this._colorData, false);
+    this.splatColor.name = "splatColor";
+    this.splatColor.minFilter = "nearest";
+    this.splatColor.magFilter = "nearest";
+    this.splatColor.mipmapFilter = "nearest";
+    this.splatColor.addressModeU = "clamp-to-edge";
+    this.splatColor.addressModeV = "clamp-to-edge";
+    this.transformA = new Uint32ArrayTexture().create(w, h, this._transformAData);
+    this.transformA.name = "transformA";
+    this.transformA.minFilter = "nearest";
+    this.transformA.magFilter = "nearest";
+    this.transformA.addressModeU = "clamp-to-edge";
+    this.transformA.addressModeV = "clamp-to-edge";
+    this.transformB = new Float16ArrayTexture().create(w, h, this._transformBData, false);
+    this.transformB.name = "transformB";
+    this.transformB.minFilter = "nearest";
+    this.transformB.magFilter = "nearest";
+    this.transformB.mipmapFilter = "nearest";
+    this.transformB.addressModeU = "clamp-to-edge";
+    this.transformB.addressModeV = "clamp-to-edge";
+    this.splatOrder = new R32UintTexture().create(w, h, 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 GSplatGeometry(this._batchSize);
+    this.materials = [this.gsplatMaterial];
+    this.instanceCount = 0;
+  }
+  /**
+   * Set data for a single splat at the given index
+   * Updates CPU buffers and marks for GPU update
+   * @param index Splat index (0 to count-1)
+   * @param data Splat data (position is required, others optional)
+   */
+  setSplatData(index, data) {
+    if (index < 0 || index >= this.totalCount) {
+      throw new Error(`Index ${index} out of range [0, ${this.totalCount})`);
+    }
+    const wasSet = this._splatSetFlags[index];
+    this._positions[index * 3 + 0] = data.position[0];
+    this._positions[index * 3 + 1] = data.position[1];
+    this._positions[index * 3 + 2] = data.position[2];
+    const SH_C0 = 0.28209479177387814;
+    let r = 0.5, g = 0.5, b = 0.5;
+    if (data.sh && data.sh.coeffs && data.sh.coeffs.length >= 3) {
+      r = 0.5 + data.sh.coeffs[0] * SH_C0;
+      g = 0.5 + data.sh.coeffs[1] * SH_C0;
+      b = 0.5 + data.sh.coeffs[2] * SH_C0;
+    }
+    const a = data.opacity !== void 0 ? 1 / (1 + Math.exp(-data.opacity)) : 1;
+    const colorIdx = index * 4;
+    this._colorData[colorIdx + 0] = Math.max(0, Math.min(255, Math.floor(r * 255)));
+    this._colorData[colorIdx + 1] = Math.max(0, Math.min(255, Math.floor(g * 255)));
+    this._colorData[colorIdx + 2] = Math.max(0, Math.min(255, Math.floor(b * 255)));
+    this._colorData[colorIdx + 3] = Math.max(0, Math.min(255, Math.floor(a * 255)));
+    this.updateTransformData(index, data);
+    if (!wasSet) {
+      this._splatSetFlags[index] = true;
+      this._validCount++;
+      this.texParams[2] = this._validCount;
+      this._centersSent = false;
+    }
+    this._pendingUpdates.add(index);
+  }
+  /**
+   * Update transform data for a single splat
+   */
+  updateTransformData(index, data) {
+    const idx = index * 4;
+    const fb = new ArrayBuffer(4);
+    const f32 = new Float32Array(fb);
+    const u32 = new Uint32Array(fb);
+    const setFloatBits = (v) => {
+      f32[0] = v;
+      return u32[0];
+    };
+    const x = data.position[0];
+    const y = data.position[1];
+    const z = data.position[2];
+    this._transformAData[idx + 0] = setFloatBits(x);
+    this._transformAData[idx + 1] = setFloatBits(y);
+    this._transformAData[idx + 2] = setFloatBits(z);
+    let qx = 0, qy = 0, qz = 0, qw = 1;
+    if (data.rotation) {
+      qx = data.rotation[0];
+      qy = data.rotation[1];
+      qz = data.rotation[2];
+      qw = data.rotation[3];
+      const inv = 1 / Math.hypot(qx, qy, qz, qw);
+      qx *= inv;
+      qy *= inv;
+      qz *= inv;
+      qw *= inv;
+    }
+    let sx = 1, sy = 1, sz = 1;
+    if (data.scale) {
+      sx = Math.exp(data.scale[0]);
+      sy = Math.exp(data.scale[1]);
+      sz = Math.exp(data.scale[2]);
+    }
+    const x2 = qx + qx;
+    const y2 = qy + qy;
+    const z2 = qz + qz;
+    const xx = qx * x2;
+    const xy = qx * y2;
+    const xz = qx * z2;
+    const yy = qy * y2;
+    const yz = qy * z2;
+    const zz = qz * z2;
+    const wx = qw * x2;
+    const wy = qw * y2;
+    const wz = qw * z2;
+    const data0 = 1 - (yy + zz);
+    const data1 = xy + wz;
+    const data2 = xz - wy;
+    const data3 = xy - wz;
+    const data4 = 1 - (xx + zz);
+    const data5 = yz + wx;
+    const data6 = xz + wy;
+    const data7 = yz - wx;
+    const data8 = 1 - (xx + yy);
+    const r00 = data0 * sx;
+    const r01 = data1 * sx;
+    const r02 = data2 * sx;
+    const r10 = data3 * sy;
+    const r11 = data4 * sy;
+    const r12 = data5 * sy;
+    const r20 = data6 * sz;
+    const r21 = data7 * sz;
+    const r22 = data8 * sz;
+    const cAx = r00 * r00 + r10 * r10 + r20 * r20;
+    const cAy = r00 * r01 + r10 * r11 + r20 * r21;
+    const cAz = r00 * r02 + r10 * r12 + r20 * r22;
+    const cBx = r01 * r01 + r11 * r11 + r21 * r21;
+    const cBy = r01 * r02 + r11 * r12 + r21 * r22;
+    const cBz = r02 * r02 + r12 * r12 + r22 * r22;
+    const bidx = idx;
+    this._transformBData[bidx + 0] = cAx;
+    this._transformBData[bidx + 1] = cAy;
+    this._transformBData[bidx + 2] = cAz;
+    this._transformBData[bidx + 3] = cBz;
+    const hx = toHalfFloat(cBx) & 65535;
+    const hy = toHalfFloat(cBy) & 65535;
+    this._transformAData[idx + 3] = hx | hy << 16;
+  }
+  /**
+   * Flush pending updates to GPU
+   * Updates GPU textures with all pending changes
+   */
+  flushUpdates() {
+    if (this._pendingUpdates.size === 0) return;
+    const w = this.size.x | 0;
+    const h = this.size.y | 0;
+    this.splatColor.updateTexture(w, h, this._colorData);
+    this.transformA.updateTexture(w, h, this._transformAData);
+    this.transformB.updateTexture(w, h, this._transformBData, false);
+    this.updatePendingWorldPositions();
+    this._pendingUpdates.clear();
+  }
+  /**
+   * Set auto-flush threshold
+   * @param threshold Number of pending updates before auto-flush (default: 100)
+   */
+  setAutoFlushThreshold(threshold) {
+    this._autoFlushThreshold = Math.max(1, threshold);
+  }
+  /**
+   * Get current streaming statistics
+   */
+  getStreamingStats() {
+    return {
+      totalCount: this.totalCount,
+      validCount: this._validCount,
+      pendingUpdates: this._pendingUpdates.size,
+      progress: this.totalCount > 0 ? this._validCount / this.totalCount * 100 : 0
+    };
+  }
+  /**
+   * Update splat sorting before rendering
+   * Uses the same logic as GSplatRenderer for reliable sorting
+   */
+  onBeforeUpdate(view) {
+    if (this._validCount > 0 && view?.camera) {
+      if (view.camera.viewMatrix) {
+        this.scheduleOrder(view.camera.viewMatrix);
+      }
+    }
+  }
+  /**
+   * Update world space positions when transform changes
+   */
+  updateWorldPositions() {
+    if (!this._positions || this._validCount === 0) return;
+    const worldMatrix = this.object3D.transform.worldMatrix;
+    const localPos = this._positions;
+    const count = this._validCount;
+    const m = worldMatrix.rawData;
+    this.worldBoundBox.makeEmpty();
+    for (let i = 0; i < count; i++) {
+      if (!this._splatSetFlags[i]) continue;
+      const idx = i * 3;
+      const x = localPos[idx + 0];
+      const y = localPos[idx + 1];
+      const z = localPos[idx + 2];
+      this._worldPositions[idx + 0] = m[0] * x + m[4] * y + m[8] * z + m[12];
+      this._worldPositions[idx + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+      this._worldPositions[idx + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+      this.worldBoundBox.expandByPoint(new Vector3(this._worldPositions[idx + 0], this._worldPositions[idx + 1], this._worldPositions[idx + 2]));
+    }
+    this._centersSent = false;
+  }
+  updatePendingWorldPositions() {
+    if (!this._positions || this._validCount === 0) return;
+    const worldMatrix = this.object3D.transform.worldMatrix;
+    const localPos = this._positions;
+    this._validCount;
+    const m = worldMatrix.rawData;
+    const pendingUpdates = Array.from(this._pendingUpdates.values());
+    for (let i = 0; i < pendingUpdates.length; i++) {
+      const ii = pendingUpdates[i];
+      if (!this._splatSetFlags[ii]) continue;
+      const idx = ii * 3;
+      const x = localPos[idx + 0];
+      const y = localPos[idx + 1];
+      const z = localPos[idx + 2];
+      this._worldPositions[idx + 0] = m[0] * x + m[4] * y + m[8] * z + m[12];
+      this._worldPositions[idx + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+      this._worldPositions[idx + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+      this.worldBoundBox.expandByPoint(new Vector3(this._worldPositions[idx + 0], this._worldPositions[idx + 1], this._worldPositions[idx + 2]));
+    }
+    this._centersSent = false;
+  }
+  /**
+   * Schedule Web Worker-based sorting task
+   * Uses the same logic as GSplatRenderer for consistency
+   */
+  scheduleOrder(viewMatrix) {
+    if (this._validCount === 0) return;
+    const transformChanged = this.object3D.transform.localChange;
+    if (transformChanged || !this._worldPositions || this._worldPositions.length === 0) {
+      this.updateWorldPositions();
+    }
+    const r = viewMatrix.rawData;
+    const vx = r[2], vy = r[6], vz = r[10];
+    const px = -(r[0] * r[12] + r[1] * r[13] + r[2] * r[14]);
+    const py = -(r[4] * r[12] + r[5] * r[13] + r[6] * r[14]);
+    const pz = -(r[8] * r[12] + r[9] * r[13] + r[10] * r[14]);
+    const now = performance.now();
+    const deltaTime = (now - this._lastSentTime) / 1e3;
+    const posHash = Math.floor(px * 1e3) ^ Math.floor(py * 1e3) ^ Math.floor(pz * 1e3);
+    const dirHash = Math.floor(vx * 1e3) ^ Math.floor(vy * 1e3) ^ Math.floor(vz * 1e3);
+    const hash = posHash ^ dirHash;
+    if (hash === this._lastViewMatrixHash && !transformChanged && this._centersSent) {
+      return;
+    }
+    let effectiveThrottle = this._minIntervalMs;
+    if (this._adaptiveSorting && this._minIntervalMs > 0) {
+      const hashDelta = Math.abs(hash - this._lastViewMatrixHash);
+      const speed = hashDelta / Math.max(deltaTime, 1e-3);
+      if (speed < 1e3) {
+        effectiveThrottle = this._minIntervalMs;
+      } else if (speed < 1e4) {
+        effectiveThrottle = this._minIntervalMs * 0.5;
+      } else {
+        effectiveThrottle = this._minIntervalMs * 0.2;
+      }
+      this._lastCameraSpeed = speed;
+    }
+    if (now - this._lastSentTime < effectiveThrottle) {
+      return;
+    }
+    this._lastViewMatrixHash = hash;
+    this._lastSentTime = now;
+    if (!this._sortWorker) {
+      this._sortWorker = this.createSortWorker();
+      this._sortWorker.onmessage = (ev) => {
+        const newOrder = ev.data.order;
+        const oldOrder = this._orderData.buffer;
+        this._sortWorker.postMessage({
+          order: oldOrder
+        }, [oldOrder]);
+        const indices = new Uint32Array(newOrder);
+        const total = this.size.x * this.size.y;
+        const validCount = Math.min(this._validCount, indices.length);
+        if (!this._orderData || this._orderData.length !== total) {
+          this._orderData = new Uint32Array(total);
+        }
+        this._orderData.set(indices.subarray(0, validCount), 0);
+        if (validCount < total) {
+          const lastIndex = this._validCount > 0 ? this._validCount - 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._validCount, ev.data.count | 0));
+        this.texParams[2] = valid;
+        this.texParams[0] = valid;
+        this._updateTexParams();
+        const newInstanceCount = Math.ceil(valid / this._batchSize);
+        this.instanceCount = newInstanceCount;
+      };
+      const centers = new Float32Array(this._validCount * 3);
+      const worldPos = this._worldPositions || this._positions;
+      let centerIdx = 0;
+      for (let i = 0; i < this._validCount; i++) {
+        if (this._splatSetFlags[i]) {
+          const srcIdx = i * 3;
+          centers[centerIdx * 3 + 0] = worldPos[srcIdx + 0];
+          centers[centerIdx * 3 + 1] = worldPos[srcIdx + 1];
+          centers[centerIdx * 3 + 2] = worldPos[srcIdx + 2];
+          centerIdx++;
+        }
+      }
+      const orderBuffer = new Uint32Array(this.totalCount);
+      for (let i = 0; i < this.totalCount; i++) {
+        orderBuffer[i] = i < this._validCount ? i : this._validCount > 0 ? this._validCount - 1 : 0;
+      }
+      this._sortWorker.postMessage({
+        order: orderBuffer.buffer,
+        centers: centers.buffer
+      }, [orderBuffer.buffer, centers.buffer]);
+      this._centersSent = true;
+    }
+    if (!this._centersSent && this._sortWorker) {
+      const centers = new Float32Array(this._validCount * 3);
+      const worldPos = this._worldPositions || this._positions;
+      let centerIdx = 0;
+      for (let i = 0; i < this._validCount; i++) {
+        if (this._splatSetFlags[i]) {
+          const srcIdx = i * 3;
+          centers[centerIdx * 3 + 0] = worldPos[srcIdx + 0];
+          centers[centerIdx * 3 + 1] = worldPos[srcIdx + 1];
+          centers[centerIdx * 3 + 2] = worldPos[srcIdx + 2];
+          centerIdx++;
+        }
+      }
+      this._sortWorker.postMessage({
+        type: "centers",
+        centers: centers.buffer
+      }, [centers.buffer]);
+      this._centersSent = true;
+    }
+    this._sortWorker.postMessage({
+      cameraPosition: { x: px, y: py, z: pz },
+      cameraDirection: { x: -vx, y: -vy, z: -vz }
+    });
+  }
+  /**
+   * Create Web Worker for sorting
+   * Uses the exact same logic as GSplatRenderer for consistency
+   */
+  createSortWorker() {
+    function SortWorker() {
+      const compareBits = 16;
+      const bucketCount = 2 ** compareBits + 1;
+      let order;
+      let centers;
+      let cameraPosition;
+      let cameraDirection;
+      let forceUpdate = false;
+      const lastCameraPosition = { x: 0, y: 0, z: 0 };
+      const lastCameraDirection = { x: 0, y: 0, z: 0 };
+      const boundMin = { x: 0, y: 0, z: 0 };
+      const boundMax = { x: 0, y: 0, z: 0 };
+      let distances;
+      let countBuffer;
+      const binarySearch = (m, n, compare_fn) => {
+        while (m <= n) {
+          const k = n + m >> 1;
+          const cmp = compare_fn(k);
+          if (cmp > 0) {
+            m = k + 1;
+          } else if (cmp < 0) {
+            n = k - 1;
+          } else {
+            return k;
+          }
+        }
+        return ~m;
+      };
+      const update = () => {
+        if (!order || !centers || !cameraPosition || !cameraDirection) return;
+        const px = cameraPosition.x;
+        const py = cameraPosition.y;
+        const pz = cameraPosition.z;
+        const dx = cameraDirection.x;
+        const dy = cameraDirection.y;
+        const dz = cameraDirection.z;
+        const epsilon = 1e-3;
+        if (!forceUpdate && Math.abs(px - lastCameraPosition.x) < epsilon && Math.abs(py - lastCameraPosition.y) < epsilon && Math.abs(pz - lastCameraPosition.z) < epsilon && Math.abs(dx - lastCameraDirection.x) < epsilon && Math.abs(dy - lastCameraDirection.y) < epsilon && Math.abs(dz - lastCameraDirection.z) < epsilon) {
+          return;
+        }
+        forceUpdate = false;
+        lastCameraPosition.x = px;
+        lastCameraPosition.y = py;
+        lastCameraPosition.z = pz;
+        lastCameraDirection.x = dx;
+        lastCameraDirection.y = dy;
+        lastCameraDirection.z = dz;
+        const numVertices = centers.length / 3;
+        if (distances?.length !== numVertices) {
+          distances = new Uint32Array(numVertices);
+        }
+        let minDist;
+        let maxDist;
+        for (let i = 0; i < 8; ++i) {
+          const x = (i & 1 ? boundMin.x : boundMax.x) - px;
+          const y = (i & 2 ? boundMin.y : boundMax.y) - py;
+          const z = (i & 4 ? boundMin.z : boundMax.z) - pz;
+          const d = x * dx + y * dy + z * dz;
+          if (i === 0) {
+            minDist = maxDist = d;
+          } else {
+            minDist = Math.min(minDist, d);
+            maxDist = Math.max(maxDist, d);
+          }
+        }
+        if (!countBuffer) {
+          countBuffer = new Uint32Array(bucketCount);
+        } else {
+          countBuffer.fill(0);
+        }
+        const range = maxDist - minDist;
+        const divider = range < 1e-6 ? 0 : 1 / range * 2 ** compareBits;
+        for (let i = 0; i < numVertices; ++i) {
+          const istride = i * 3;
+          const x = centers[istride + 0] - px;
+          const y = centers[istride + 1] - py;
+          const z = centers[istride + 2] - pz;
+          const d = x * dx + y * dy + z * dz;
+          const sortKey = Math.floor((d - minDist) * divider);
+          distances[i] = sortKey;
+          countBuffer[sortKey]++;
+        }
+        for (let i = 1; i < bucketCount; i++) {
+          countBuffer[i] += countBuffer[i - 1];
+        }
+        for (let i = 0; i < numVertices; i++) {
+          const distance = distances[i];
+          const destIndex = --countBuffer[distance];
+          order[destIndex] = i;
+        }
+        const dist = (i) => distances[order[i]] / divider + minDist;
+        const findZero = () => {
+          const result = binarySearch(0, numVertices - 1, (i) => -dist(i));
+          return Math.min(numVertices, Math.abs(result));
+        };
+        const count = dist(numVertices - 1) >= 0 ? findZero() : numVertices;
+        self.postMessage({
+          order: order.buffer,
+          count
+        }, [order.buffer]);
+        order = null;
+      };
+      self.onmessage = (message) => {
+        if (message.data.order) {
+          order = new Uint32Array(message.data.order);
+        }
+        if (message.data.centers) {
+          centers = new Float32Array(message.data.centers);
+          boundMin.x = boundMax.x = centers[0];
+          boundMin.y = boundMax.y = centers[1];
+          boundMin.z = boundMax.z = centers[2];
+          const numVertices = centers.length / 3;
+          for (let i = 1; i < numVertices; ++i) {
+            const x = centers[i * 3 + 0];
+            const y = centers[i * 3 + 1];
+            const z = centers[i * 3 + 2];
+            boundMin.x = Math.min(boundMin.x, x);
+            boundMin.y = Math.min(boundMin.y, y);
+            boundMin.z = Math.min(boundMin.z, z);
+            boundMax.x = Math.max(boundMax.x, x);
+            boundMax.y = Math.max(boundMax.y, y);
+            boundMax.z = Math.max(boundMax.z, z);
+          }
+          forceUpdate = true;
+        }
+        if (message.data.cameraPosition) cameraPosition = message.data.cameraPosition;
+        if (message.data.cameraDirection) cameraDirection = message.data.cameraDirection;
+        update();
+      };
+    }
+    const code = `(${SortWorker.toString()})()`;
+    const blob = new Blob([code], { type: "application/javascript" });
+    const url = URL.createObjectURL(blob);
+    return new Worker(url);
+  }
+  /**
+   * Set visibility boost factor
+   */
+  setVisBoost(v) {
+    this.texParams[3] = Math.max(0, v);
+  }
+  setCount(c) {
+    this.texParams[0] = Math.max(0, c);
+  }
+  _updateTexParams() {
+    this.gsplatMaterial.setTexParams(this.texParams);
+  }
+  /**
+   * Set sort throttle interval (milliseconds)
+   */
+  setSortThrottle(ms) {
+    this._minIntervalMs = Math.max(0, ms | 0);
+  }
+  /**
+   * Enable/disable adaptive sorting
+   */
+  setAdaptiveSorting(enabled) {
+    this._adaptiveSorting = enabled;
+  }
+  /**
+   * Set pixel coverage culling thresholds
+   */
+  setPixelCulling(minPixels, maxPixels = 0, maxPixelCullDistance = 0) {
+    this._minPixelCoverage = Math.max(0, minPixels);
+    this._maxPixelCoverage = Math.max(0, maxPixels);
+    this._maxPixelCullDistance = Math.max(0, maxPixelCullDistance);
+  }
+  /**
+   * Get current pixel culling settings
+   */
+  getPixelCullingStats() {
+    return {
+      minPixels: this._minPixelCoverage,
+      maxPixels: this._maxPixelCoverage,
+      maxPixelCullDistance: this._maxPixelCullDistance,
+      maxEnabled: this._maxPixelCoverage > 0,
+      distanceEnabled: this._maxPixelCullDistance > 0
+    };
+  }
+  /**
+   * Get batching statistics
+   */
+  getBatchingStats() {
+    return {
+      enabled: true,
+      batchSize: this._batchSize,
+      instanceCount: this.instanceCount,
+      splatCount: this._validCount,
+      reduction: this._validCount > 0 ? (1 - this.instanceCount / this._validCount) * 100 : 0
+    };
+  }
+  /**
+   * Calculate texture size for given splat count
+   */
+  evalTextureSize(count) {
+    let w = Math.ceil(Math.sqrt(count));
+    const align = 64;
+    w = Math.ceil(w / align) * align;
+    const h = Math.ceil(count / w);
+    return new Vector2(w, h);
+  }
+  /**
+   * Update node before rendering
+   */
+  nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+    if (this._pendingUpdates.size > 0 && this._frameCount >= 60) {
+      this.flushUpdates();
+    }
+    if (this._frameCount >= 60 && this._pendingUpdates.size === 0) {
+      this._frameCount = 0;
+    }
+    this._frameCount++;
+    const worldMatrix = this.object3D.transform.worldMatrix;
+    this.gsplatMaterial.setTransformMatrix(worldMatrix);
+    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
+   */
+  renderPass(view, passType, renderContext) {
+    const encoder = renderContext.encoder;
+    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, renderContext.rendererPassState || renderContext);
+        GPUContext.bindPipeline(encoder, pass);
+        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
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Clean up resources
+   */
+  destroy(force) {
+    if (this._sortWorker) {
+      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;
+    }
+    this._positions = null;
+    this._worldPositions = null;
+    this._orderData = null;
+    this._colorData = null;
+    this._transformAData = null;
+    this._transformBData = null;
+    this.texParams = null;
+    this._splatSetFlags = null;
+    this._pendingUpdates.clear();
+    super.destroy(force);
+  }
+};
+GSplatStreamRenderer = __decorateClass$7([
+  RegisterComponent(GSplatStreamRenderer, "GSplatStreamRenderer")
+], GSplatStreamRenderer);
+
 class Probe extends Object3D {
   index = 0;
   drawCallFrame = -1;
@@ -59823,6 +60588,127 @@ class LoaderManager extends CEventDispatcher {
   }
 }
 
+class StreamLoader extends LoaderBase {
+  /**
+   * Load resource with streaming support
+   * @param url Resource URL
+   * @param parserClass Parser class that supports streaming
+   * @param loaderFunctions Optional loader callbacks
+   * @param userData Optional user data
+   * @returns Promise that resolves when initial data is ready (header parsed), includes cancel method
+   */
+  async loadStream(url, parserClass, loaderFunctions, userData) {
+    if (parserClass.format !== ParserFormat.BIN) {
+      throw new Error("StreamLoader only supports BIN format parsers");
+    }
+    return new Promise(async (succ, fail) => {
+      let aborted = false;
+      let reader = null;
+      let abortController = null;
+      const cancel = () => {
+        aborted = true;
+        if (reader) {
+          reader.cancel().catch(() => {
+          });
+          reader.releaseLock();
+        }
+        if (abortController) {
+          abortController.abort();
+        }
+        if (parser && typeof parser.cancel === "function") {
+          parser.cancel();
+        }
+      };
+      let parser = null;
+      try {
+        this.baseUrl = url.substring(0, url.lastIndexOf("/") + 1);
+        this.initUrl = url;
+        abortController = new AbortController();
+        const response = await fetch(url, {
+          headers: loaderFunctions?.headers,
+          signal: abortController.signal
+        });
+        if (!response.ok) {
+          throw new Error(`Request rejected with status ${response.status}`);
+        }
+        reader = response.body.getReader();
+        const contentLength = +response.headers.get("Content-Length") || 0;
+        parser = new parserClass();
+        parser.userData = userData;
+        parser.baseUrl = this.baseUrl;
+        parser.initUrl = url;
+        parser.loaderFunctions = loaderFunctions;
+        if (typeof parser.initStream !== "function") {
+          throw new Error(`Parser ${parserClass.name} does not support streaming. Implement initStream() method.`);
+        }
+        let parserResolved = false;
+        await parser.initStream(contentLength, () => {
+          if (!parserResolved && !aborted && parser && parser.verification()) {
+            parserResolved = true;
+            succ({ parser, cancel });
+          }
+        });
+        let receivedLength = 0;
+        while (!aborted) {
+          const { done, value } = await reader.read();
+          if (done || aborted) {
+            if (!aborted) {
+              if (typeof parser.finalizeStream === "function") {
+                await parser.finalizeStream();
+              }
+              if (!parserResolved && parser) {
+                if (parser.verification()) {
+                  parserResolved = true;
+                  succ({ parser, cancel });
+                } else {
+                  throw new Error("Parser verification failed");
+                }
+              }
+            }
+            break;
+          }
+          if (aborted) break;
+          receivedLength += value.length;
+          if (contentLength > 0 && loaderFunctions?.onProgress && !aborted) {
+            loaderFunctions.onProgress.call(
+              this,
+              receivedLength,
+              contentLength,
+              url,
+              parser
+            );
+          }
+          if (!aborted && typeof parser.processChunk === "function") {
+            await parser.processChunk(value, receivedLength, contentLength);
+          }
+          if (!parserResolved && !aborted && parser && parser.verification()) {
+            parserResolved = true;
+            succ({ parser, cancel });
+          }
+        }
+        if (!aborted && loaderFunctions?.onComplete) {
+          loaderFunctions.onComplete.call(this, url);
+        }
+      } catch (e) {
+        if (aborted) {
+          return;
+        }
+        if (loaderFunctions?.onError) {
+          loaderFunctions.onError(e);
+        }
+        fail(e);
+      } finally {
+        if (reader && !aborted) {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+        }
+      }
+    });
+  }
+}
+
 function computeAABBFromPositions(position) {
   const min = [Infinity, Infinity, Infinity];
   const max = [-Infinity, -Infinity, -Infinity];
@@ -61041,6 +61927,314 @@ function parsePlyPointCloudASCII(buffer, header) {
   };
 }
 
+class PlyStreamParser {
+  _header = null;
+  _headerBuffer = new Uint8Array(4096);
+  _headerLength = 0;
+  _headerParsed = false;
+  // Data parsing state
+  _dataBuffer = null;
+  _dataOffset = 0;
+  _processedVertices = 0;
+  _vertexStride = 0;
+  _propOffsets = [];
+  _properties = [];
+  // Callbacks
+  _onHeaderParsed = null;
+  _onSplatParsed = null;
+  _batchSize = 1e3;
+  _cancelled = false;
+  constructor(onHeaderParsed, onSplatParsed, batchSize = 1e3) {
+    this._onHeaderParsed = onHeaderParsed;
+    this._onSplatParsed = onSplatParsed;
+    this._batchSize = batchSize;
+  }
+  /**
+   * Process incoming data chunk
+   */
+  processChunk(chunk) {
+    if (this._cancelled) return;
+    if (!this._headerParsed) {
+      this._processHeaderChunk(chunk);
+    } else {
+      this._processDataChunk(chunk);
+    }
+  }
+  /**
+   * Cancel parsing
+   * Stops processing new chunks
+   */
+  cancel() {
+    this._cancelled = true;
+  }
+  /**
+   * Check if parsing is cancelled
+   */
+  isCancelled() {
+    return this._cancelled;
+  }
+  /**
+   * Process header chunk
+   */
+  _processHeaderChunk(chunk) {
+    const needed = this._headerLength + chunk.length;
+    if (needed > this._headerBuffer.length) {
+      const newBuffer = new Uint8Array(Math.max(needed, this._headerBuffer.length * 2));
+      newBuffer.set(this._headerBuffer.subarray(0, this._headerLength));
+      this._headerBuffer = newBuffer;
+    }
+    this._headerBuffer.set(chunk, this._headerLength);
+    this._headerLength += chunk.length;
+    const headerText = new TextDecoder("utf-8").decode(
+      this._headerBuffer.subarray(0, this._headerLength)
+    );
+    const headerEnd = headerText.indexOf("end_header\n");
+    if (headerEnd >= 0) {
+      const headerEndPos = headerEnd + "end_header\n".length;
+      const headerBuffer = this._headerBuffer.subarray(0, headerEndPos);
+      const headerArrayBuffer = headerBuffer.buffer.slice(headerBuffer.byteOffset, headerBuffer.byteOffset + headerBuffer.byteLength);
+      const header = this._parseHeader(headerArrayBuffer);
+      this._header = header;
+      this._headerParsed = true;
+      this._initializeDataParsing(header);
+      if (this._onHeaderParsed) {
+        this._onHeaderParsed(header);
+      }
+      const chunkStartInHeader = this._headerLength - chunk.length;
+      const remainingStartInChunk = headerEndPos - chunkStartInHeader;
+      if (remainingStartInChunk > 0 && remainingStartInChunk < chunk.length) {
+        const remainingChunk = chunk.subarray(remainingStartInChunk);
+        this._processDataChunk(remainingChunk);
+      } else if (remainingStartInChunk === 0) {
+        this._processDataChunk(chunk);
+      }
+    }
+  }
+  /**
+   * Parse PLY header from buffer
+   */
+  _parseHeader(buffer) {
+    const ascii = new TextDecoder("utf-8").decode(new Uint8Array(buffer));
+    const headerEnd = ascii.indexOf("end_header\n");
+    if (headerEnd < 0) {
+      throw new Error("PLY: Invalid PLY header");
+    }
+    const headerText = ascii.substring(0, headerEnd + "end_header\n".length);
+    const lines = headerText.split(/\r?\n/);
+    let format = "";
+    let vertexCount = 0;
+    let faceCount = 0;
+    const properties = [];
+    const faceProperties = [];
+    const textureFiles = [];
+    let inVertexElement = false;
+    let inFaceElement = false;
+    for (const line of lines) {
+      if (line.startsWith("format ")) {
+        format = line.split(/\s+/)[1];
+      } else if (line.startsWith("comment TextureFile ")) {
+        const texturePath = line.substring("comment TextureFile ".length).trim();
+        if (texturePath) {
+          textureFiles.push(texturePath);
+        }
+      } else if (line.startsWith("element ")) {
+        const toks = line.split(/\s+/);
+        inVertexElement = toks[1] === "vertex";
+        inFaceElement = toks[1] === "face";
+        if (inVertexElement) {
+          vertexCount = parseInt(toks[2]);
+          inFaceElement = false;
+        }
+        if (inFaceElement) {
+          faceCount = parseInt(toks[2]);
+          inVertexElement = false;
+        }
+      } else if (inVertexElement && line.startsWith("property ")) {
+        const toks = line.split(/\s+/);
+        const type = toks[1];
+        const name = toks[2];
+        properties.push({ name, type });
+      } else if (inFaceElement && line.startsWith("property ")) {
+        const toks = line.split(/\s+/);
+        if (toks[1] === "list") {
+          const countType = toks[2];
+          const itemType = toks[3];
+          const name = toks[4];
+          faceProperties.push({ name, type: `list ${countType} ${itemType}` });
+        } else {
+          const type = toks[1];
+          const name = toks[2];
+          faceProperties.push({ name, type });
+        }
+      }
+    }
+    if (format !== "binary_little_endian" && format !== "ascii") {
+      throw new Error(`PLY: Unsupported format: ${format}`);
+    }
+    let splatPropertyCount = 0;
+    let splatPropertyColorCount = 0;
+    for (const property of properties) {
+      if (splatProperties.includes(property.name)) {
+        splatPropertyCount++;
+      }
+      if (splatColorProperties.includes(property.name)) {
+        splatPropertyColorCount++;
+      }
+    }
+    let mode;
+    if (faceCount > 0) {
+      mode = PlyMode.Mesh;
+    } else if (splatPropertyCount === splatProperties.length && splatPropertyColorCount === 3) {
+      mode = PlyMode.Splat;
+    } else {
+      mode = PlyMode.PointCloud;
+    }
+    return {
+      format,
+      vertexCount,
+      faceCount,
+      properties,
+      faceProperties: faceProperties.length > 0 ? faceProperties : void 0,
+      textureFiles,
+      headerByteLength: headerText.length,
+      mode
+    };
+  }
+  /**
+   * Initialize data parsing structures
+   */
+  _initializeDataParsing(header) {
+    this._properties = header.properties;
+    this._propOffsets = [];
+    this._vertexStride = 0;
+    for (const p of this._properties) {
+      this._propOffsets.push(this._vertexStride);
+      this._vertexStride += byteSizeOfType(p.type);
+    }
+    const estimatedSize = header.vertexCount * this._vertexStride;
+    this._dataBuffer = new Uint8Array(Math.min(estimatedSize, 1024 * 1024 * 10));
+    this._dataOffset = 0;
+    this._processedVertices = 0;
+  }
+  /**
+   * Process data chunk
+   */
+  _processDataChunk(chunk) {
+    if (!this._header || !this._dataBuffer) return;
+    const needed = this._dataOffset + chunk.length;
+    if (needed > this._dataBuffer.length) {
+      const newSize = Math.max(needed, this._dataBuffer.length * 2);
+      const newBuffer = new Uint8Array(newSize);
+      newBuffer.set(this._dataBuffer);
+      this._dataBuffer = newBuffer;
+    }
+    this._dataBuffer.set(chunk, this._dataOffset);
+    this._dataOffset += chunk.length;
+    this._parseVertices();
+  }
+  /**
+   * Parse vertices from current data buffer
+   */
+  _parseVertices() {
+    if (!this._header || !this._dataBuffer) return;
+    const payload = new DataView(this._dataBuffer.buffer, this._dataBuffer.byteOffset, this._dataBuffer.byteLength);
+    const vertexCount = this._header.vertexCount;
+    const has = (n) => this._properties.find((p) => p.name === n) != null;
+    const propIndex = (n) => this._properties.findIndex((p) => p.name === n);
+    while (this._processedVertices < vertexCount && !this._cancelled) {
+      const v = this._processedVertices;
+      const vOffset = v * this._vertexStride;
+      if (vOffset + this._vertexStride > this._dataOffset) {
+        break;
+      }
+      if (this._cancelled) {
+        break;
+      }
+      const ix = propIndex("x");
+      const iy = propIndex("y");
+      const iz = propIndex("z");
+      if (ix < 0 || iy < 0 || iz < 0) {
+        throw new Error("PLY: Missing required x/y/z properties for vertex");
+      }
+      const splatData = {
+        position: [
+          readByType(payload, vOffset + this._propOffsets[ix], this._properties[ix].type),
+          readByType(payload, vOffset + this._propOffsets[iy], this._properties[iy].type),
+          readByType(payload, vOffset + this._propOffsets[iz], this._properties[iz].type)
+        ]
+      };
+      if (has("scale_0")) {
+        splatData.scale = [
+          readByType(payload, vOffset + this._propOffsets[propIndex("scale_0")], this._properties[propIndex("scale_0")].type),
+          readByType(payload, vOffset + this._propOffsets[propIndex("scale_1")], this._properties[propIndex("scale_1")].type),
+          readByType(payload, vOffset + this._propOffsets[propIndex("scale_2")], this._properties[propIndex("scale_2")].type)
+        ];
+      }
+      if (has("rot_0")) {
+        const w = readByType(payload, vOffset + this._propOffsets[propIndex("rot_0")], this._properties[propIndex("rot_0")].type);
+        const x = readByType(payload, vOffset + this._propOffsets[propIndex("rot_1")], this._properties[propIndex("rot_1")].type);
+        const y = readByType(payload, vOffset + this._propOffsets[propIndex("rot_2")], this._properties[propIndex("rot_2")].type);
+        const z = readByType(payload, vOffset + this._propOffsets[propIndex("rot_3")], this._properties[propIndex("rot_3")].type);
+        splatData.rotation = [x, y, z, w];
+      }
+      if (has("opacity")) {
+        splatData.opacity = readByType(payload, vOffset + this._propOffsets[propIndex("opacity")], this._properties[propIndex("opacity")].type);
+      }
+      const dcIdx = [propIndex("f_dc_0"), propIndex("f_dc_1"), propIndex("f_dc_2")];
+      if (dcIdx[0] >= 0 && dcIdx[1] >= 0 && dcIdx[2] >= 0) {
+        const restIndices = [];
+        for (let i = 0; i < this._properties.length; i++) {
+          if (this._properties[i].name.startsWith("f_rest_")) restIndices.push(i);
+        }
+        const coeffsPerColor = 1 + restIndices.length / 3;
+        const coeffs = new Float32Array(coeffsPerColor * 3);
+        coeffs[0] = readByType(payload, vOffset + this._propOffsets[dcIdx[0]], this._properties[dcIdx[0]].type);
+        coeffs[coeffsPerColor + 0] = readByType(payload, vOffset + this._propOffsets[dcIdx[1]], this._properties[dcIdx[1]].type);
+        coeffs[2 * coeffsPerColor + 0] = readByType(payload, vOffset + this._propOffsets[dcIdx[2]], this._properties[dcIdx[2]].type);
+        let rPtr = 1;
+        let gPtr = 1;
+        let bPtr = 1;
+        for (let i = 0; i < restIndices.length; i += 3) {
+          const ri = restIndices[i + 0];
+          const gi = restIndices[i + 1];
+          const bi = restIndices[i + 2];
+          coeffs[rPtr] = readByType(payload, vOffset + this._propOffsets[ri], this._properties[ri].type);
+          coeffs[coeffsPerColor + gPtr] = readByType(payload, vOffset + this._propOffsets[gi], this._properties[gi].type);
+          coeffs[2 * coeffsPerColor + bPtr] = readByType(payload, vOffset + this._propOffsets[bi], this._properties[bi].type);
+          rPtr++;
+          gPtr++;
+          bPtr++;
+        }
+        splatData.sh = {
+          order: Math.floor(Math.sqrt(coeffsPerColor)),
+          coeffs
+        };
+      }
+      if (this._onSplatParsed) {
+        this._onSplatParsed(splatData, v);
+      }
+      this._processedVertices++;
+      if (this._processedVertices % this._batchSize === 0) {
+        setTimeout(() => {
+          this._parseVertices();
+        }, 0);
+        return;
+      }
+    }
+  }
+  /**
+   * Get current parsing progress
+   */
+  getProgress() {
+    const total = this._header?.vertexCount || 0;
+    return {
+      processed: this._processedVertices,
+      total,
+      percentage: total > 0 ? this._processedVertices / total * 100 : 0
+    };
+  }
+}
+
 class GaussianSplatParser extends ParserBase {
   static format = ParserFormat.BIN;
   async parseBuffer(buffer) {
@@ -61076,6 +62270,95 @@ class GaussianSplatParser extends ParserBase {
   }
 }
 
+class StreamingGaussianSplatParser extends ParserBase {
+  static format = ParserFormat.BIN;
+  _streamParser = null;
+  _streamingRenderer = null;
+  _rendererObject = null;
+  _chunksPerBatch = 1e3;
+  // Number of splats to process per batch
+  _headerParsed = false;
+  _onHeaderParsed = null;
+  _cancelled = false;
+  /**
+   * Initialize streaming parser
+   * @param contentLength Total content length (if known)
+   * @param onHeaderParsed Optional callback when header is parsed (parser is ready)
+   */
+  async initStream(contentLength, onHeaderParsed) {
+    this._onHeaderParsed = onHeaderParsed || null;
+    this._rendererObject = new Object3D();
+    this._rendererObject.name = "StreamingGaussianSplat";
+    this._streamingRenderer = this._rendererObject.addComponent(GSplatStreamRenderer);
+    this._streamParser = new PlyStreamParser(
+      (header) => {
+        if (this._streamingRenderer) {
+          this._streamingRenderer.initCount(header.vertexCount);
+        }
+        if (this._rendererObject) {
+          this.data = this._rendererObject;
+        }
+        this._headerParsed = true;
+        if (this._onHeaderParsed) {
+          this._onHeaderParsed();
+        }
+      },
+      (splatData, index) => {
+        if (this._streamingRenderer) {
+          this._streamingRenderer.setSplatData(index, splatData);
+        }
+      },
+      this._chunksPerBatch
+    );
+  }
+  /**
+   * Process incoming data chunk
+   * @param chunk Data chunk
+   * @param receivedLength Total bytes received so far
+   * @param contentLength Total content length (if known)
+   */
+  async processChunk(chunk, receivedLength, contentLength) {
+    if (this._cancelled || !this._streamParser) return;
+    this._streamParser.processChunk(chunk);
+  }
+  /**
+   * Cancel streaming loading
+   * Stops processing new chunks and cleans up resources
+   */
+  cancel() {
+    this._cancelled = true;
+    if (this._streamParser) {
+      this._streamParser.cancel();
+    }
+  }
+  /**
+   * Check if loading is cancelled
+   */
+  isCancelled() {
+    return this._cancelled;
+  }
+  /**
+   * Finalize streaming parsing
+   */
+  async finalizeStream() {
+    if (this._rendererObject) {
+      this.data = this._rendererObject;
+    }
+  }
+  /**
+   * Get parsing progress
+   */
+  getProgress() {
+    if (this._streamParser) {
+      return this._streamParser.getProgress();
+    }
+    return { processed: 0, total: 0, percentage: 0 };
+  }
+  verification() {
+    return this._headerParsed && !!this.data && !!this._streamingRenderer;
+  }
+}
+
 var GeoType = /* @__PURE__ */ ((GeoType2) => {
   GeoType2["Point"] = "Point";
   GeoType2["LineString"] = "LineString";
@@ -71686,4 +72969,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, BoundingVolume, 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, DRACO_DECODER_GLTF_JS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FAILED, 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, LASLoader, LASParser, LASUtils, LASVisualizationMode, LDRTextureCube, LOADED, LOADING, LRUCache, 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, PARSING, PBRLItShader, PBRLitSSSShader, PLUGIN_REGISTERED, PNTSLoader, PNTSLoaderBase, PNTSParser, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PlyMode, PlyParser, PointClassification, PointCloudGeometry, PointCloudMaterial, PointCloudRenderer, PointCloudShader, PointCloud_FS, PointCloud_VS, 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, PriorityQueue, 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, Tile, 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, UNLOADED, 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, WGS84_FLATTENING, WGS84_HEIGHT, WGS84_RADIUS, 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, lruPriorityCallback, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, markUsedSetLeaves, markUsedTiles, markVisibleTiles, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, parsePlyMesh, parsePlyPointCloud, perm, post, priorityCallback, 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, splatColorProperties, splatProperties, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, throttle, toHalfFloat, toggleTiles, traverseAncestors, traverseSet, 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, BoundingVolume, 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, DRACO_DECODER_GLTF_JS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FAILED, 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, GSplatStreamRenderer, 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, LASLoader, LASParser, LASUtils, LASVisualizationMode, LDRTextureCube, LOADED, LOADING, LRUCache, 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, PARSING, PBRLItShader, PBRLitSSSShader, PLUGIN_REGISTERED, PNTSLoader, PNTSLoaderBase, PNTSParser, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PlyMode, PlyParser, PlyStreamParser, PointClassification, PointCloudGeometry, PointCloudMaterial, PointCloudRenderer, PointCloudShader, PointCloud_FS, PointCloud_VS, 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, PriorityQueue, 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, StreamLoader, StreamingGaussianSplatParser, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, Tile, 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, UNLOADED, 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, WGS84_FLATTENING, WGS84_HEIGHT, WGS84_RADIUS, 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, lruPriorityCallback, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, markUsedSetLeaves, markUsedTiles, markVisibleTiles, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, parsePlyMesh, parsePlyPointCloud, perm, post, priorityCallback, 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, splatColorProperties, splatProperties, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, throttle, toHalfFloat, toggleTiles, traverseAncestors, traverseSet, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };