@rings-webgpu/core 1.0.27 → 1.0.29

package/dist/rings.es.max.js

@@ -2113,7 +2113,7 @@ function GetShader(name) {
 }
 
 var __defProp$2 = Object.defineProperty;
-var __decorateClass$m = (decorators, target, key, kind) => {
+var __decorateClass$o = (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$m([
+__decorateClass$o([
   NonSerialize
 ], _Struct.prototype, "__refection");
-__decorateClass$m([
+__decorateClass$o([
   NonSerialize
 ], _Struct.prototype, "__size");
 let Struct = _Struct;
@@ -20489,6 +20489,10 @@ class RenderShaderPass extends ShaderPassBase {
     this.vsEntryPoint = vsEntryPoint;
     this.fsEntryPoint = fsEntryPoint;
   }
+  setUniformArray(name, value) {
+    super.setUniformArray(name, value);
+    this.materialDataUniformBuffer.onChange();
+  }
   setUniform(name, value) {
     super.setUniform(name, value);
     this.materialDataUniformBuffer.onChange();
@@ -20757,16 +20761,21 @@ class RenderShaderPass extends ShaderPassBase {
           if (buffer) {
             if (buffer.bufferType == GPUBufferType.MaterialDataUniformGPUBuffer) {
               let uniforms = [];
-              for (let i = 0; i < refs.dataFields.length; i++) {
-                const field = refs.dataFields[i];
-                if (!this.uniforms[field.name]) {
-                  console.error(
-                    `shader-${this.vsName}:${this.fsName} ${field.name}is empty`
-                  );
+              if (refs.dataFields) {
+                for (let i = 0; i < refs.dataFields.length; i++) {
+                  const field = refs.dataFields[i];
+                  if (!this.uniforms[field.name]) {
+                    console.error(
+                      `shader-${this.vsName}:${this.fsName} ${field.name}is empty`
+                    );
+                  } else {
+                    uniforms.push(this.uniforms[field.name]);
+                  }
                 }
-                uniforms.push(this.uniforms[field.name]);
               }
-              this.materialDataUniformBuffer.initDataUniform(uniforms);
+              if (uniforms.length > 0) {
+                this.materialDataUniformBuffer.initDataUniform(uniforms);
+              }
             }
             let entry = {
               binding: refs.binding,
@@ -21956,9 +21965,9 @@ class OctreeEntity {
 }
 
 var __defProp$1 = Object.defineProperty;
-var __getOwnPropDesc$l = Object.getOwnPropertyDescriptor;
-var __decorateClass$l = (decorators, target, key, kind) => {
-  var result = __getOwnPropDesc$l(target, key) ;
+var __getOwnPropDesc$n = Object.getOwnPropertyDescriptor;
+var __decorateClass$n = (decorators, target, key, kind) => {
+  var result = __getOwnPropDesc$n(target, key) ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(target, key, result) ) || result;
@@ -22556,13 +22565,13 @@ class RenderNode extends ComponentBase {
     this._combineShaderRefection = void 0;
   }
 }
-__decorateClass$l([
+__decorateClass$n([
   EditorInspector
 ], RenderNode.prototype, "materials");
-__decorateClass$l([
+__decorateClass$n([
   EditorInspector
 ], RenderNode.prototype, "castShadow");
-__decorateClass$l([
+__decorateClass$n([
   EditorInspector
 ], RenderNode.prototype, "castGI");
 
@@ -22783,7 +22792,7 @@ const GSplat_VS = (
         @location(1) vTexCoord: vec2<f32>,
     };
     
-    // Textures (like PlayCanvas)
+    // Textures
     @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>;
@@ -22880,7 +22889,7 @@ const GSplat_VS = (
         return vec4f(v1.x, -v1.y, v2.x, -v2.y);
     }
     
-    // ===== SPLAT MAIN VS (from PlayCanvas gsplat-material.js) =====
+    // ===== SPLAT MAIN VS =====
     
     @vertex
     fn VertMain(
@@ -23229,9 +23238,9 @@ class Shader {
   }
 }
 
-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$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;
@@ -23263,7 +23272,7 @@ let GSplatShader = class extends Shader {
     pass.setUniform("pixelCull", new Float32Array([2, 0, 0, 0]));
   }
 };
-GSplatShader = __decorateClass$k([
+GSplatShader = __decorateClass$m([
   RegisterShader(GSplatShader, "GSplatShader")
 ], GSplatShader);
 
@@ -24046,7 +24055,7 @@ class Uint8ArrayTexture extends Texture {
       size: data.byteLength,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
     });
-    device.queue.writeBuffer(textureDataBuffer, 0, data);
+    device.queue.writeBuffer(textureDataBuffer, 0, data.buffer);
     const commandEncoder = GPUContext.beginCommandEncoder();
     commandEncoder.copyBufferToTexture(
       {
@@ -24078,7 +24087,7 @@ class Uint8ArrayTexture extends Texture {
       size: data.byteLength,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
     });
-    device.queue.writeBuffer(textureDataBuffer, 0, data);
+    device.queue.writeBuffer(textureDataBuffer, 0, data.buffer);
     const commandEncoder = GPUContext.beginCommandEncoder();
     commandEncoder.copyBufferToTexture(
       {
@@ -24280,9 +24289,9 @@ class Float16ArrayTexture 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$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;
@@ -25081,10 +25090,689 @@ let GSplatRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-GSplatRenderer = __decorateClass$j([
+GSplatRenderer = __decorateClass$l([
   RegisterComponent(GSplatRenderer, "GSplatRenderer")
 ], GSplatRenderer);
 
+const PointCloud_VS = (
+  /* wgsl */
+  `
+    #include "GlobalUniform"
+    
+    const ALPHA_THRESHOLD: f32 = 0.00392156863;
+    
+    struct MaterialUniform {
+        modelMatrix: mat4x4<f32>,
+        tex_params: vec4<f32>,
+        pointParams: vec4<f32>,
+    };
+    @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(1) var pointColor: texture_2d<f32>;
+    @group(1) @binding(2) var pointPosition: texture_2d<f32>;
+    @group(1) @binding(3) var pointOrder: texture_2d<u32>;
+    
+    fn discardPoint() -> 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;
+    }
+    
+    fn calcPointUV(orderId: u32, textureWidth: u32, numPoints: u32) -> vec2<i32> {
+        let pointId = orderId;
+        return vec2<i32>(
+            i32(pointId % textureWidth),
+            i32(pointId / textureWidth)
+        );
+    }
+    
+    @vertex
+    fn VertMain(
+        @builtin(vertex_index) vid: u32,
+        @builtin(instance_index) iid: u32,
+        @location(0) position: vec3<f32>
+    ) -> VSOut {
+        let batchSize = max(1u, u32(materialUniform.pointParams.w));
+        let orderId = iid * batchSize + u32(position.z);
+        
+        let textureWidth = max(1u, u32(materialUniform.tex_params.y));
+        let numPoints = max(1u, u32(materialUniform.tex_params.x));
+        let safeOrderId = min(orderId, numPoints - 1u);
+        
+        let pointUV = calcPointUV(safeOrderId, textureWidth, numPoints);
+        let color = textureLoad(pointColor, pointUV, 0);
+        
+        let posData = textureLoad(pointPosition, pointUV, 0);
+        let pointPos = vec3f(
+            posData.x,
+            posData.y,
+            posData.z
+        );
+        
+        let matrix_model = materialUniform.modelMatrix;
+        let matrix_view = globalUniform.viewMat;
+        let matrix_projection = globalUniform.projMat;
+        let model_view = matrix_view * matrix_model;
+        
+        let centerClip = matrix_projection * (model_view * vec4f(pointPos, 1.0));
+        
+        let inv_w = 1.0 / centerClip.w;
+        let ndc = centerClip.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) {
+            return discardPoint();
+        }
+        
+        let viewPos = model_view * vec4f(pointPos, 1.0);
+        if (viewPos.z <= 0.0) {
+            return discardPoint();
+        }
+        
+        let pointSize = materialUniform.tex_params.w;
+        let viewport = vec2f(globalUniform.windowWidth, globalUniform.windowHeight);
+        let safeViewport = max(viewport, vec2f(1.0, 1.0));
+        let inv_viewport = 2.0 / safeViewport;
+        let offsetNDC = position.xy * pointSize * 0.5 * inv_viewport;
+        let offsetClip = vec4f(offsetNDC * centerClip.w, 0.0, 0.0);
+        
+        var o: VSOut;
+        o.member = centerClip + offsetClip;
+        o.vColor = color;
+        o.vTexCoord = position.xy;
+        return o;
+    }
+`
+);
+const PointCloud_FS = (
+  /* wgsl */
+  `
+    #include "FragmentOutput"
+    
+    const ALPHA_THRESHOLD: f32 = 0.00392156863;
+    
+    struct MaterialUniform {
+        modelMatrix: mat4x4<f32>,
+        tex_params: vec4<f32>,
+        pointParams: vec4<f32>,
+    };
+    @group(1) @binding(0) var<uniform> materialUniform: MaterialUniform;
+    
+    @fragment
+    fn FragMain(
+        @location(0) vColor: vec4<f32>,
+        @location(1) vTexCoord: vec2<f32>
+    ) -> FragmentOutput {
+        var o: FragmentOutput;
+        
+        let pointShape = materialUniform.pointParams.x;
+        let distSq = dot(vTexCoord, vTexCoord);
+        let isCircle = pointShape > 0.5;
+        let discardPixel = isCircle && distSq > 1.0;
+        
+        if (discardPixel) {
+            discard;
+        }
+        
+        o.color = vColor;
+        o.gBuffer = vec4f(0.0);
+        return o;
+    }
+`
+);
+
+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;
+  return result;
+};
+let PointCloudShader = class extends Shader {
+  constructor() {
+    super();
+    ShaderLib.register("pointcloud_vs_dc", PointCloud_VS);
+    ShaderLib.register("pointcloud_fs_dc", PointCloud_FS);
+    const pass = new RenderShaderPass("pointcloud_vs_dc", "pointcloud_fs_dc");
+    pass.passType = PassType.COLOR;
+    pass.setShaderEntry("VertMain", "FragMain");
+    pass.topology = GPUPrimitiveTopology.triangle_list;
+    pass.depthWriteEnabled = true;
+    pass.cullMode = GPUCullMode.none;
+    pass.shaderState.transparent = false;
+    pass.shaderState.blendMode = BlendMode.NORMAL;
+    pass.shaderState.writeMasks = [15, 15];
+    pass.shaderState.castReflection = false;
+    this.addRenderPass(pass);
+    this.setDefault();
+  }
+  setDefault() {
+    const pass = this.getDefaultColorShader();
+    const identityMatrix = new Matrix4();
+    pass.setUniform("modelMatrix", identityMatrix.rawData);
+    pass.setUniformArray("tex_params", new Float32Array([0, 0, 0, 4]));
+    pass.setUniformArray("pointParams", new Float32Array([0, 0, 0, 128]));
+  }
+};
+PointCloudShader = __decorateClass$k([
+  RegisterShader(PointCloudShader, "PointCloudShader")
+], PointCloudShader);
+
+class PointCloudMaterial extends Material {
+  _texParams = new Float32Array([0, 0, 0, 4]);
+  _pointParamsArray = new Float32Array([0, 0, 0, 128]);
+  constructor() {
+    super();
+    this.shader = new PointCloudShader();
+  }
+  /**
+   * Set point cloud textures
+   * @param pointPosition Position texture (RGB = xyz)
+   * @param pointColor Color texture (RGBA)
+   * @param texParams Texture parameters [numPoints, texWidth, validCount, pointSize]
+   * @param pointOrder Optional sorting texture (R32U format)
+   */
+  setPointTextures(pointPosition, pointColor, texParams, pointOrder) {
+    const pass = this.shader.getDefaultColorShader();
+    if (!pass.getUniform("modelMatrix")) {
+      const identityMatrix = new Matrix4();
+      pass.setUniform("modelMatrix", identityMatrix.rawData);
+    }
+    pass.setTexture("pointColor", pointColor);
+    pass.setTexture("pointPosition", pointPosition);
+    this._texParams[0] = texParams[0];
+    this._texParams[1] = texParams[1];
+    this._texParams[2] = texParams[2];
+    this._texParams[3] = texParams[3];
+    pass.setUniformArray("tex_params", this._texParams);
+    pass.setUniformArray("pointParams", this._pointParamsArray);
+    if (pointOrder) {
+      pass.setTexture("pointOrder", pointOrder);
+    }
+    pass.shaderState.depthCompare = GPUCompareFunction.less;
+  }
+  /**
+   * Set the model matrix for transforming points to world space
+   * @param matrix Model transformation matrix
+   */
+  setTransformMatrix(matrix) {
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniform("modelMatrix", matrix.rawData);
+  }
+  /**
+   * Set point size in pixels
+   * @param size Point size in pixels (default: 4.0)
+   */
+  setPointSize(size) {
+    this._texParams[3] = Math.max(0.1, size);
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniformArray("tex_params", this._texParams);
+  }
+  /**
+   * Set point shape
+   * @param shape Point shape: 'square' or 'circle'
+   */
+  setPointShape(shape) {
+    this._pointParamsArray[0] = shape === "circle" ? 1 : 0;
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniformArray("pointParams", this._pointParamsArray);
+  }
+  enableDebugFullScreen(enabled) {
+    this._pointParamsArray[1] = enabled ? 1 : 0;
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniformArray("pointParams", this._pointParamsArray);
+  }
+  /**
+   * Set batch size for instanced rendering
+   * @param batchSize Number of points per draw call (default: 128)
+   */
+  setBatchSize(batchSize) {
+    this._pointParamsArray[3] = Math.max(1, batchSize | 0);
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniformArray("pointParams", this._pointParamsArray);
+  }
+}
+
+class PointCloudGeometry extends GeometryBase {
+  batchSize;
+  constructor(batchSize = 128) {
+    super();
+    this.batchSize = batchSize;
+    const meshPositions = new Float32Array(12 * batchSize);
+    for (let i = 0; i < batchSize; ++i) {
+      const baseIdx = i * 12;
+      meshPositions.set([
+        -1,
+        -1,
+        i,
+        1,
+        -1,
+        i,
+        1,
+        1,
+        i,
+        -1,
+        1,
+        i
+      ], baseIdx);
+    }
+    const meshIndices = new Uint32Array(6 * batchSize);
+    for (let i = 0; i < batchSize; ++i) {
+      const baseVertex = i * 4;
+      const baseIdx = i * 6;
+      meshIndices.set([
+        0 + baseVertex,
+        1 + baseVertex,
+        2 + baseVertex,
+        0 + baseVertex,
+        2 + baseVertex,
+        3 + baseVertex
+      ], baseIdx);
+    }
+    this.setAttribute(VertexAttributeName.position, meshPositions);
+    this.setIndices(meshIndices);
+    this.addSubGeometry({
+      indexStart: 0,
+      indexCount: meshIndices.length,
+      vertexStart: 0,
+      vertexCount: meshPositions.length / 3,
+      firstStart: 0,
+      index: 0,
+      topology: 0
+    });
+  }
+}
+
+class Float32ArrayTexture extends Texture {
+  create(width, height, data, filtering = true) {
+    let device = webGPUContext.device;
+    const bytesPerRow = width * 4 * 4;
+    this.format = GPUTextureFormat.rgba32float;
+    let mipmapCount = 1;
+    this.createTextureDescriptor(width, height, mipmapCount, this.format);
+    const textureDataBuffer = device.createBuffer({
+      size: data.byteLength,
+      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+    });
+    device.queue.writeBuffer(textureDataBuffer, 0, data.buffer);
+    const commandEncoder = GPUContext.beginCommandEncoder();
+    commandEncoder.copyBufferToTexture(
+      {
+        buffer: textureDataBuffer,
+        bytesPerRow
+      },
+      {
+        texture: this.getGPUTexture()
+      },
+      {
+        width,
+        height,
+        depthOrArrayLayers: 1
+      }
+    );
+    GPUContext.endCommandEncoder(commandEncoder);
+    if (filtering) {
+      this.samplerBindingLayout.type = `non-filtering`;
+      this.textureBindingLayout.sampleType = `unfilterable-float`;
+    }
+    this.gpuSampler = device.createSampler({});
+    return this;
+  }
+  fromBuffer(width, height, textureDataBuffer) {
+    let device = webGPUContext.device;
+    const bytesPerRow = width * 4 * 4;
+    this.format = GPUTextureFormat.rgba32float;
+    this.mipmapCount = 1;
+    this.createTextureDescriptor(width, height, this.mipmapCount, this.format);
+    const commandEncoder = GPUContext.beginCommandEncoder();
+    commandEncoder.copyBufferToTexture(
+      {
+        buffer: textureDataBuffer,
+        bytesPerRow
+      },
+      {
+        texture: this.getGPUTexture()
+      },
+      {
+        width,
+        height,
+        depthOrArrayLayers: 1
+      }
+    );
+    GPUContext.endCommandEncoder(commandEncoder);
+    this.samplerBindingLayout.type = `non-filtering`;
+    this.textureBindingLayout.sampleType = `unfilterable-float`;
+    this.gpuSampler = device.createSampler({});
+    return this;
+  }
+}
+
+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;
+  return result;
+};
+let PointCloudRenderer = class extends RenderNode {
+  count = 0;
+  size = new Vector2();
+  pointColor;
+  pointPosition;
+  pointOrder;
+  texParams;
+  // [numPoints, texWidth, validCount, pointSize]
+  pointCloudMaterial;
+  _positions;
+  get positions() {
+    return this._positions;
+  }
+  _colors;
+  _orderData;
+  _fullCount = 0;
+  get fullCount() {
+    return this._fullCount;
+  }
+  _batchSize = 128;
+  instanceCount = 0;
+  _texturesInitialized = false;
+  _debugFullScreen = false;
+  _centerOffset = new Vector3();
+  get centerOffset() {
+    return this._centerOffset;
+  }
+  constructor() {
+    super();
+  }
+  /**
+   * Initialize point cloud from raw data
+   * @param positions Point positions (xyz per point, Float32Array)
+   * @param colors Point colors (rgba per point, Uint8Array)
+   * @param count Number of points
+   */
+  initFromData(positions, colors, count) {
+    if (!positions || !colors || count <= 0) {
+      console.error("PointCloudRenderer: Invalid input data");
+      return;
+    }
+    if (positions.length < count * 3) {
+      console.error("PointCloudRenderer: Positions array too small");
+      return;
+    }
+    if (colors.length < count * 4) {
+      console.error("PointCloudRenderer: Colors array too small");
+      return;
+    }
+    this.count = count;
+    this._fullCount = count;
+    this.size = this.evalTextureSize(count);
+    this._positions = positions;
+    this._colors = colors;
+    this.centerizePositions();
+    this.buildPositionTexture();
+    this.buildColorTexture();
+    this.texParams = new Float32Array([
+      this.count,
+      this.size.x,
+      this.count,
+      4
+    ]);
+    this.buildOrderTexture();
+    this.pointCloudMaterial = new PointCloudMaterial();
+    this.geometry = new PointCloudGeometry(this._batchSize);
+    this.materials = [this.pointCloudMaterial];
+    this.instanceCount = Math.ceil(this.count / this._batchSize);
+  }
+  /**
+   * Calculate texture size for given point count
+   * @param count Number of points
+   * @returns Texture dimensions (width, height)
+   */
+  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);
+  }
+  /**
+   * Centerize positions to improve precision for large values
+   * Subtracts the center point from all positions to keep values near zero
+   */
+  centerizePositions() {
+    if (this.count === 0) return;
+    let sumX = 0, sumY = 0, sumZ = 0;
+    for (let i = 0; i < this.count; i++) {
+      const idx = i * 3;
+      sumX += this._positions[idx + 0];
+      sumY += this._positions[idx + 1];
+      sumZ += this._positions[idx + 2];
+    }
+    const centerX = sumX / this.count;
+    const centerY = sumY / this.count;
+    const centerZ = sumZ / this.count;
+    this._centerOffset.set(centerX, centerY, centerZ);
+    for (let i = 0; i < this.count; i++) {
+      const idx = i * 3;
+      this._positions[idx + 0] -= centerX;
+      this._positions[idx + 1] -= centerY;
+      this._positions[idx + 2] -= centerZ;
+    }
+    this.object3D.localPosition = this._centerOffset;
+  }
+  buildPositionTexture() {
+    const w = this.size.x | 0;
+    const h = this.size.y | 0;
+    const count = this.count;
+    const data = new Float32Array(w * h * 4);
+    for (let i = 0; i < count; i++) {
+      const idx = i * 4;
+      const posIdx = i * 3;
+      data[idx + 0] = this._positions[posIdx + 0];
+      data[idx + 1] = this._positions[posIdx + 1];
+      data[idx + 2] = this._positions[posIdx + 2];
+      data[idx + 3] = 0;
+    }
+    if (count < w * h) {
+      const lastIdx = (count - 1) * 4;
+      for (let i = count; i < w * h; i++) {
+        const idx = i * 4;
+        data[idx + 0] = data[lastIdx + 0];
+        data[idx + 1] = data[lastIdx + 1];
+        data[idx + 2] = data[lastIdx + 2];
+        data[idx + 3] = 0;
+      }
+    }
+    this.pointPosition = new Float32ArrayTexture().create(w, h, data);
+    this.pointPosition.name = "pointPosition";
+    this.pointPosition.minFilter = "nearest";
+    this.pointPosition.magFilter = "nearest";
+    this.pointPosition.addressModeU = "clamp-to-edge";
+    this.pointPosition.addressModeV = "clamp-to-edge";
+  }
+  buildColorTexture() {
+    const w = this.size.x | 0;
+    const h = this.size.y | 0;
+    const count = this.count;
+    const data = new Uint8Array(w * h * 4);
+    for (let i = 0; i < count; i++) {
+      const idx = i * 4;
+      const colorIdx = i * 4;
+      data[idx + 0] = this._colors[colorIdx + 0];
+      data[idx + 1] = this._colors[colorIdx + 1];
+      data[idx + 2] = this._colors[colorIdx + 2];
+      data[idx + 3] = this._colors[colorIdx + 3];
+    }
+    if (count < w * h) {
+      const lastIdx = (count - 1) * 4;
+      for (let i = count; i < w * h; i++) {
+        const idx = i * 4;
+        data[idx + 0] = data[lastIdx + 0];
+        data[idx + 1] = data[lastIdx + 1];
+        data[idx + 2] = data[lastIdx + 2];
+        data[idx + 3] = data[lastIdx + 3];
+      }
+    }
+    this.pointColor = new Uint8ArrayTexture().create(w, h, data, false);
+    this.pointColor.name = "pointColor";
+    this.pointColor.minFilter = "nearest";
+    this.pointColor.magFilter = "nearest";
+    this.pointColor.mipmapFilter = "nearest";
+    this.pointColor.addressModeU = "clamp-to-edge";
+    this.pointColor.addressModeV = "clamp-to-edge";
+  }
+  buildOrderTexture() {
+    const total = this.size.x * this.size.y;
+    this._orderData = new Uint32Array(total);
+    for (let i = 0; i < total; i++) {
+      this._orderData[i] = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
+    }
+    this.pointOrder = new R32UintTexture().create(this.size.x, this.size.y, this._orderData);
+    this.pointOrder.name = "pointOrder";
+    this.pointOrder.minFilter = "nearest";
+    this.pointOrder.magFilter = "nearest";
+    this.pointOrder.addressModeU = "clamp-to-edge";
+    this.pointOrder.addressModeV = "clamp-to-edge";
+  }
+  /**
+   * Update node before rendering
+   */
+  nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+    const worldMatrix = this.object3D.transform.worldMatrix;
+    this.pointCloudMaterial.setTransformMatrix(worldMatrix);
+    if (!this._texturesInitialized) {
+      this.pointCloudMaterial.setPointTextures(
+        this.pointPosition,
+        this.pointColor,
+        this.texParams,
+        this.pointOrder
+      );
+      this.pointCloudMaterial.setBatchSize(this._batchSize);
+      this.pointCloudMaterial.setPointSize(this.texParams[3]);
+      this.pointCloudMaterial.enableDebugFullScreen(this._debugFullScreen);
+      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
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Set point size in pixels
+   * @param size Point size in pixels
+   */
+  setPointSize(size) {
+    this.texParams[3] = Math.max(0.1, size);
+    if (this.pointCloudMaterial) {
+      this.pointCloudMaterial.setPointSize(size);
+    }
+  }
+  /**
+   * Set point shape
+   * @param shape 'square' or 'circle'
+   */
+  setPointShape(shape) {
+    if (this.pointCloudMaterial) {
+      this.pointCloudMaterial.setPointShape(shape);
+    }
+  }
+  /**
+   * Enable a fullscreen debug quad to validate the render pipeline.
+   */
+  enableDebugFullScreen(enabled) {
+    this._debugFullScreen = enabled;
+    if (this.pointCloudMaterial) {
+      this.pointCloudMaterial.enableDebugFullScreen(enabled);
+    }
+  }
+  /**
+   * Set batch size for instanced rendering
+   * @param batchSize Number of points per draw call
+   */
+  setBatchSize(batchSize) {
+    this._batchSize = Math.max(1, batchSize | 0);
+    if (this.geometry) {
+      const oldGeometry = this.geometry;
+      Reference.getInstance().detached(oldGeometry, this);
+      if (!Reference.getInstance().hasReference(oldGeometry)) {
+        oldGeometry.destroy();
+      }
+      this.geometry = new PointCloudGeometry(this._batchSize);
+    }
+    if (this.pointCloudMaterial) {
+      this.pointCloudMaterial.setBatchSize(this._batchSize);
+      this.pointCloudMaterial.enableDebugFullScreen(this._debugFullScreen);
+    }
+    this.instanceCount = Math.ceil(this.count / this._batchSize);
+  }
+  destroy(force) {
+    if (this.pointColor) {
+      this.pointColor.destroy(force);
+      this.pointColor = null;
+    }
+    if (this.pointPosition) {
+      this.pointPosition.destroy(force);
+      this.pointPosition = null;
+    }
+    if (this.pointOrder) {
+      this.pointOrder.destroy(force);
+      this.pointOrder = null;
+    }
+    this._positions = null;
+    this._colors = null;
+    this._orderData = null;
+    this.texParams = null;
+    super.destroy(force);
+  }
+};
+PointCloudRenderer = __decorateClass$j([
+  RegisterComponent(PointCloudRenderer, "PointCloudRenderer")
+], PointCloudRenderer);
+
 class BoundUtil {
   static maxVector = new Vector3(
     Number.MAX_VALUE * 0.1,
@@ -25104,6 +25792,36 @@ class BoundUtil {
     new Vector3(),
     new Vector3()
   ];
+  static genPointCloudBounds(obj, bound) {
+    bound ||= new BoundingBox(Vector3.ZERO, Vector3.ZERO);
+    bound.setFromMinMax(this.maxVector, this.minVector);
+    let pointCloudRenderers = obj.getComponents(PointCloudRenderer);
+    if (!pointCloudRenderers) {
+      console.warn("genPointCloudBounds: No PointCloudRenderer found on object");
+      return bound;
+    }
+    for (const pointCloudRenderer of pointCloudRenderers) {
+      const positions = pointCloudRenderer.positions;
+      const count = pointCloudRenderer.fullCount;
+      if (!positions || count === 0) {
+        console.warn("genPointCloudBounds: No position data available");
+        continue;
+      }
+      const matrix = pointCloudRenderer.object3D.transform.worldMatrix;
+      const point = new Vector3();
+      for (let i = 0; i < count; i++) {
+        const idx = i * 3;
+        point.set(
+          positions[idx + 0],
+          positions[idx + 1],
+          positions[idx + 2]
+        );
+        matrix.transformPoint(point, point);
+        bound.expandByPoint(point);
+      }
+    }
+    return bound;
+  }
   static genGSplatBounds(obj, bound) {
     bound ||= new BoundingBox(Vector3.ZERO, Vector3.ZERO);
     bound.setFromMinMax(this.maxVector, this.minVector);
@@ -39081,7 +39799,10 @@ class FeatureTable {
   buffer;
   binOffset;
   binLength;
-  header;
+  _header;
+  get header() {
+    return this._header;
+  }
   constructor(buffer, start, headerLength, binLength) {
     this.buffer = buffer;
     this.binOffset = start + headerLength;
@@ -39093,13 +39814,13 @@ class FeatureTable {
     } else {
       header = {};
     }
-    this.header = header;
+    this._header = header;
   }
   getKeys() {
-    return Object.keys(this.header);
+    return Object.keys(this._header);
   }
   getData(key, count, defaultComponentType = null, defaultType = null) {
-    const header = this.header;
+    const header = this._header;
     if (!(key in header)) {
       return null;
     }
@@ -39181,7 +39902,7 @@ class FeatureTable {
   }
   destroy() {
     this.buffer = null;
-    this.header = null;
+    this._header = null;
     this.binOffset = null;
     this.binLength = null;
   }
@@ -41425,7 +42146,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.26";
+const version = "1.0.28";
 
 class Engine3D {
   /**
@@ -60158,6 +60879,166 @@ function parsePlyMeshASCII(buffer, header) {
     triangleTexnumbers: triangleTexnumbers.length > 0 ? triangleTexnumbers : void 0
   };
 }
+function parsePlyPointCloud(buffer) {
+  const header = parsePlyHeader(buffer);
+  const { format } = header;
+  if (format === "ascii") {
+    return parsePlyPointCloudASCII(buffer, header);
+  } else {
+    return parsePlyPointCloudBinary(buffer, header);
+  }
+}
+function parsePlyPointCloudBinary(buffer, header) {
+  const { vertexCount, properties, headerByteLength } = header;
+  const payload = new DataView(buffer, headerByteLength);
+  const has = (n) => properties.find((p) => p.name === n) != null;
+  const propIndex = (n) => properties.findIndex((p) => p.name === n);
+  const position = new Float32Array(vertexCount * 3);
+  const hasColor = (has("red") || has("r")) && (has("green") || has("g")) && (has("blue") || has("b"));
+  const hasAlpha = has("alpha") || has("a");
+  const color = hasColor ? new Uint8Array(vertexCount * 4) : void 0;
+  const propOffsets = [];
+  let stride = 0;
+  for (const p of properties) {
+    propOffsets.push(stride);
+    stride += byteSizeOfType(p.type);
+  }
+  let base = 0;
+  for (let v = 0; v < vertexCount; v++) {
+    const vOffset = base;
+    const ix = propIndex("x");
+    const iy = propIndex("y");
+    const iz = propIndex("z");
+    if (ix < 0 || iy < 0 || iz < 0) {
+      throw new Error("PLY: Missing x/y/z for vertex");
+    }
+    position[v * 3 + 0] = readByType(payload, vOffset + propOffsets[ix], properties[ix].type);
+    position[v * 3 + 1] = readByType(payload, vOffset + propOffsets[iy], properties[iy].type);
+    position[v * 3 + 2] = readByType(payload, vOffset + propOffsets[iz], properties[iz].type);
+    if (color) {
+      const rIdx = propIndex("red") >= 0 ? propIndex("red") : propIndex("r");
+      const gIdx = propIndex("green") >= 0 ? propIndex("green") : propIndex("g");
+      const bIdx = propIndex("blue") >= 0 ? propIndex("blue") : propIndex("b");
+      const aIdx = hasAlpha ? propIndex("alpha") >= 0 ? propIndex("alpha") : propIndex("a") : -1;
+      if (rIdx >= 0 && gIdx >= 0 && bIdx >= 0) {
+        let r = readByType(payload, vOffset + propOffsets[rIdx], properties[rIdx].type);
+        let g = readByType(payload, vOffset + propOffsets[gIdx], properties[gIdx].type);
+        let b = readByType(payload, vOffset + propOffsets[bIdx], properties[bIdx].type);
+        let a = 255;
+        if (properties[rIdx].type === "float" || properties[rIdx].type === "float32" || properties[rIdx].type === "double" || properties[rIdx].type === "float64") {
+          r = Math.round(r * 255);
+          g = Math.round(g * 255);
+          b = Math.round(b * 255);
+        }
+        if (aIdx >= 0) {
+          a = readByType(payload, vOffset + propOffsets[aIdx], properties[aIdx].type);
+          if (properties[aIdx].type === "float" || properties[aIdx].type === "float32" || properties[aIdx].type === "double" || properties[aIdx].type === "float64") {
+            a = Math.round(a * 255);
+          }
+        }
+        color[v * 4 + 0] = Math.max(0, Math.min(255, r));
+        color[v * 4 + 1] = Math.max(0, Math.min(255, g));
+        color[v * 4 + 2] = Math.max(0, Math.min(255, b));
+        color[v * 4 + 3] = Math.max(0, Math.min(255, a));
+      }
+    }
+    base += stride;
+  }
+  return {
+    vertexCount,
+    position,
+    color
+  };
+}
+function parsePlyPointCloudASCII(buffer, header) {
+  const { vertexCount, properties } = header;
+  const text = new TextDecoder("utf-8").decode(buffer);
+  const headerEnd = text.indexOf("end_header");
+  if (headerEnd < 0) {
+    throw new Error("PLY: Invalid PLY header");
+  }
+  let bodyStart = headerEnd + "end_header".length;
+  while (bodyStart < text.length && (text[bodyStart] === " " || text[bodyStart] === "\n" || text[bodyStart] === "\r")) {
+    bodyStart++;
+  }
+  const bodyText = text.substring(bodyStart);
+  const tokens = bodyText.split(/\s+/).filter((token) => token.length > 0);
+  let tokenIndex = 0;
+  const has = (n) => properties.find((p) => p.name === n) != null;
+  const parseASCIINumber = (type) => {
+    if (tokenIndex >= tokens.length) {
+      throw new Error("PLY: Unexpected end of file");
+    }
+    const value = tokens[tokenIndex++];
+    switch (type) {
+      case "char":
+      case "uchar":
+      case "short":
+      case "ushort":
+      case "int":
+      case "uint":
+      case "int8":
+      case "uint8":
+      case "int16":
+      case "uint16":
+      case "int32":
+      case "uint32":
+        return parseInt(value);
+      case "float":
+      case "double":
+      case "float32":
+      case "float64":
+        return parseFloat(value);
+      default:
+        return parseFloat(value);
+    }
+  };
+  const position = new Float32Array(vertexCount * 3);
+  const hasColor = (has("red") || has("r")) && (has("green") || has("g")) && (has("blue") || has("b"));
+  const hasAlpha = has("alpha") || has("a");
+  const color = hasColor ? new Uint8Array(vertexCount * 4) : void 0;
+  const propIndex = (n) => properties.findIndex((p) => p.name === n);
+  const xIdx = propIndex("x");
+  const yIdx = propIndex("y");
+  const zIdx = propIndex("z");
+  const rIdx = hasColor ? propIndex("red") >= 0 ? propIndex("red") : propIndex("r") : -1;
+  const gIdx = hasColor ? propIndex("green") >= 0 ? propIndex("green") : propIndex("g") : -1;
+  const bIdx = hasColor ? propIndex("blue") >= 0 ? propIndex("blue") : propIndex("b") : -1;
+  const aIdx = hasAlpha ? propIndex("alpha") >= 0 ? propIndex("alpha") : propIndex("a") : -1;
+  for (let v = 0; v < vertexCount; v++) {
+    for (let pIdx = 0; pIdx < properties.length; pIdx++) {
+      const prop = properties[pIdx];
+      const value = parseASCIINumber(prop.type);
+      if (pIdx === xIdx) {
+        position[v * 3 + 0] = value;
+      } else if (pIdx === yIdx) {
+        position[v * 3 + 1] = value;
+      } else if (pIdx === zIdx) {
+        position[v * 3 + 2] = value;
+      } else if (pIdx === rIdx && color) {
+        const r = prop.type === "uchar" || prop.type === "uint8" ? value : Math.round(value * 255);
+        color[v * 4 + 0] = Math.max(0, Math.min(255, r));
+      } else if (pIdx === gIdx && color) {
+        const g = prop.type === "uchar" || prop.type === "uint8" ? value : Math.round(value * 255);
+        color[v * 4 + 1] = Math.max(0, Math.min(255, g));
+      } else if (pIdx === bIdx && color) {
+        const b = prop.type === "uchar" || prop.type === "uint8" ? value : Math.round(value * 255);
+        color[v * 4 + 2] = Math.max(0, Math.min(255, b));
+      } else if (pIdx === aIdx && color) {
+        const a = prop.type === "uchar" || prop.type === "uint8" ? value : Math.round(value * 255);
+        color[v * 4 + 3] = Math.max(0, Math.min(255, a));
+      }
+    }
+    if (color && aIdx < 0) {
+      color[v * 4 + 3] = 255;
+    }
+  }
+  return {
+    vertexCount,
+    position,
+    color
+  };
+}
 
 class GaussianSplatParser extends ParserBase {
   static format = ParserFormat.BIN;
@@ -60290,6 +61171,23 @@ class PlyParser extends ParserBase {
         break;
       }
       case PlyMode.PointCloud: {
+        const plyData = parsePlyPointCloud(buffer);
+        const pointCloudObj = new Object3D();
+        pointCloudObj.name = "PLYPointCloud";
+        const pointCloudObjRoot = new Object3D();
+        pointCloudObjRoot.name = "PLYPointCloudRoot";
+        pointCloudObj.addChild(pointCloudObjRoot);
+        const renderer = pointCloudObjRoot.addComponent(PointCloudRenderer);
+        if (plyData.color) {
+          renderer.initFromData(plyData.position, plyData.color, plyData.vertexCount);
+        } else {
+          const defaultColors = new Uint8Array(plyData.vertexCount * 4);
+          defaultColors.fill(255);
+          renderer.initFromData(plyData.position, defaultColors, plyData.vertexCount);
+        }
+        renderer.setPointShape("circle");
+        renderer.setPointSize(4);
+        this.data = pointCloudObj;
         break;
       }
       case PlyMode.Mesh: {
@@ -60393,6 +61291,274 @@ class PlyParser extends ParserBase {
   }
 }
 
+class PNTSLoaderBase {
+  async parse(buffer) {
+    const dataView = new DataView(buffer);
+    const magic = readMagicBytes(dataView);
+    console.assert(magic === "pnts");
+    const version = dataView.getUint32(4, true);
+    console.assert(version === 1);
+    const byteLength = dataView.getUint32(8, true);
+    console.assert(byteLength === buffer.byteLength);
+    const featureTableJSONByteLength = dataView.getUint32(12, true);
+    const featureTableBinaryByteLength = dataView.getUint32(16, true);
+    const batchTableJSONByteLength = dataView.getUint32(20, true);
+    const batchTableBinaryByteLength = dataView.getUint32(24, true);
+    const featureTableStart = 28;
+    const featureTable = new FeatureTable(
+      buffer,
+      featureTableStart,
+      featureTableJSONByteLength,
+      featureTableBinaryByteLength
+    );
+    const batchTableStart = featureTableStart + featureTableJSONByteLength + featureTableBinaryByteLength;
+    const pointsLength = featureTable.header.POINTS_LENGTH || 0;
+    const batchTable = new BatchTable(
+      buffer,
+      pointsLength,
+      batchTableStart,
+      batchTableJSONByteLength,
+      batchTableBinaryByteLength
+    );
+    return {
+      version,
+      featureTable,
+      batchTable
+    };
+  }
+}
+
+class PNTSLoader extends PNTSLoaderBase {
+  async parse(buffer) {
+    const pnts = await super.parse(buffer);
+    const { featureTable, batchTable } = pnts;
+    const pointsLength = featureTable.header.POINTS_LENGTH;
+    if (!pointsLength || pointsLength <= 0) {
+      throw new Error("PNTSLoader: POINTS_LENGTH must be defined and greater than zero");
+    }
+    const extensions = featureTable.header.extensions;
+    const dracoExtension = extensions?.["3DTILES_draco_point_compression"];
+    let positions;
+    let colors;
+    if (dracoExtension) {
+      const dracoData = await this.parseDraco(
+        featureTable,
+        dracoExtension,
+        pointsLength
+      );
+      positions = dracoData.positions;
+      colors = dracoData.colors;
+      dracoData.normals;
+    } else {
+      positions = this.parsePositions(featureTable, pointsLength);
+      colors = this.parseColors(featureTable, pointsLength);
+      this.parseNormals(featureTable, pointsLength);
+    }
+    const pointCloudObj = new Object3D();
+    const renderer = pointCloudObj.addComponent(PointCloudRenderer);
+    renderer.initFromData(positions, colors, pointsLength);
+    const rtcCenter = featureTable.getData("RTC_CENTER", 1, "FLOAT", "VEC3");
+    if (rtcCenter) {
+      pointCloudObj.transform.localPosition.set(
+        rtcCenter[0],
+        rtcCenter[1],
+        rtcCenter[2]
+      );
+    }
+    pointCloudObj["batchTable"] = batchTable;
+    pointCloudObj["featureTable"] = featureTable;
+    return pointCloudObj;
+  }
+  parsePositions(featureTable, pointsLength) {
+    let positions = featureTable.getData(
+      "POSITION",
+      pointsLength,
+      "FLOAT",
+      "VEC3"
+    );
+    if (positions) {
+      return positions;
+    }
+    const quantized = featureTable.getData(
+      "POSITION_QUANTIZED",
+      pointsLength,
+      "UNSIGNED_SHORT",
+      "VEC3"
+    );
+    if (!quantized) {
+      throw new Error(
+        "PNTSLoader: Either POSITION or POSITION_QUANTIZED must be defined"
+      );
+    }
+    const scale = featureTable.getData(
+      "QUANTIZED_VOLUME_SCALE",
+      1,
+      "FLOAT",
+      "VEC3"
+    );
+    const offset = featureTable.getData(
+      "QUANTIZED_VOLUME_OFFSET",
+      1,
+      "FLOAT",
+      "VEC3"
+    );
+    if (!scale || !offset) {
+      throw new Error(
+        "PNTSLoader: QUANTIZED_VOLUME_SCALE and QUANTIZED_VOLUME_OFFSET must be defined for quantized positions"
+      );
+    }
+    const decoded = new Float32Array(pointsLength * 3);
+    const quantizedRange = 65535;
+    for (let i = 0; i < pointsLength; i++) {
+      const idx = i * 3;
+      decoded[idx + 0] = quantized[idx + 0] / quantizedRange * scale[0] + offset[0];
+      decoded[idx + 1] = quantized[idx + 1] / quantizedRange * scale[1] + offset[1];
+      decoded[idx + 2] = quantized[idx + 2] / quantizedRange * scale[2] + offset[2];
+    }
+    return decoded;
+  }
+  parseColors(featureTable, pointsLength) {
+    let colors = featureTable.getData(
+      "RGBA",
+      pointsLength,
+      "UNSIGNED_BYTE",
+      "VEC4"
+    );
+    if (colors) {
+      return colors;
+    }
+    const rgb = featureTable.getData(
+      "RGB",
+      pointsLength,
+      "UNSIGNED_BYTE",
+      "VEC3"
+    );
+    if (rgb) {
+      const rgba2 = new Uint8Array(pointsLength * 4);
+      for (let i = 0; i < pointsLength; i++) {
+        const rgbIdx = i * 3;
+        const rgbaIdx = i * 4;
+        rgba2[rgbaIdx + 0] = rgb[rgbIdx + 0];
+        rgba2[rgbaIdx + 1] = rgb[rgbIdx + 1];
+        rgba2[rgbaIdx + 2] = rgb[rgbIdx + 2];
+        rgba2[rgbaIdx + 3] = 255;
+      }
+      return rgba2;
+    }
+    const rgb565 = featureTable.getData(
+      "RGB565",
+      pointsLength,
+      "UNSIGNED_SHORT",
+      "SCALAR"
+    );
+    if (rgb565) {
+      const rgba2 = new Uint8Array(pointsLength * 4);
+      for (let i = 0; i < pointsLength; i++) {
+        const decoded = this.decodeRGB565(rgb565[i]);
+        const idx = i * 4;
+        rgba2[idx + 0] = decoded[0];
+        rgba2[idx + 1] = decoded[1];
+        rgba2[idx + 2] = decoded[2];
+        rgba2[idx + 3] = 255;
+      }
+      return rgba2;
+    }
+    const constantRGBA = featureTable.getData(
+      "CONSTANT_RGBA",
+      1,
+      "UNSIGNED_BYTE",
+      "VEC4"
+    );
+    if (constantRGBA) {
+      const rgba2 = new Uint8Array(pointsLength * 4);
+      for (let i = 0; i < pointsLength; i++) {
+        const idx = i * 4;
+        rgba2[idx + 0] = constantRGBA[0];
+        rgba2[idx + 1] = constantRGBA[1];
+        rgba2[idx + 2] = constantRGBA[2];
+        rgba2[idx + 3] = constantRGBA[3];
+      }
+      return rgba2;
+    }
+    const rgba = new Uint8Array(pointsLength * 4);
+    rgba.fill(255);
+    return rgba;
+  }
+  parseNormals(featureTable, pointsLength) {
+    let normals = featureTable.getData(
+      "NORMAL",
+      pointsLength,
+      "FLOAT",
+      "VEC3"
+    );
+    if (normals) {
+      return normals;
+    }
+    const octNormals = featureTable.getData(
+      "NORMAL_OCT16P",
+      pointsLength,
+      "UNSIGNED_BYTE",
+      "VEC2"
+    );
+    if (octNormals) {
+      return this.decodeOctNormals(octNormals, pointsLength);
+    }
+    return null;
+  }
+  decodeRGB565(value) {
+    const r = (value >> 11 & 31) << 3;
+    const g = (value >> 5 & 63) << 2;
+    const b = (value & 31) << 3;
+    return [r, g, b];
+  }
+  decodeOctNormals(octNormals, pointsLength) {
+    const normals = new Float32Array(pointsLength * 3);
+    for (let i = 0; i < pointsLength; i++) {
+      const idx = i * 2;
+      const x = octNormals[idx] / 255;
+      const y = octNormals[idx + 1] / 255;
+      const nx = x * 2 - 1;
+      const ny = y * 2 - 1;
+      const nz = 1 - Math.abs(nx) - Math.abs(ny);
+      let tx, ty;
+      if (nz < 0) {
+        tx = (nx >= 0 ? 1 : -1) * (1 - Math.abs(ny));
+        ty = (ny >= 0 ? 1 : -1) * (1 - Math.abs(nx));
+      } else {
+        tx = nx;
+        ty = ny;
+      }
+      const length = Math.sqrt(tx * tx + ty * ty + nz * nz);
+      const nidx = i * 3;
+      normals[nidx + 0] = tx / length;
+      normals[nidx + 1] = ty / length;
+      normals[nidx + 2] = nz / length;
+    }
+    return normals;
+  }
+  async parseDraco(featureTable, dracoExtension, pointsLength) {
+    throw new Error("Draco compression not yet implemented");
+  }
+}
+
+class PNTSParser extends ParserBase {
+  static format = ParserFormat.BIN;
+  async parseBuffer(buffer) {
+    const loader = new PNTSLoader();
+    const pntsRoot = await loader.parse(buffer);
+    const pntsObj = new Object3D();
+    pntsObj.name = "PNTS";
+    pntsObj.addChild(pntsRoot);
+    this.data = pntsObj;
+  }
+  verification() {
+    if (this.data) {
+      return true;
+    }
+    throw new Error("PNTSParser: Parse failed");
+  }
+}
+
 class PrefabBoneData {
   boneName;
   bonePath;
@@ -63499,9 +64665,9 @@ class TilesRenderer {
     const extension = getUrlExtension(uri);
     const fullUrl = url;
     let scene = null;
+    const loader = new FileLoader();
     switch (extension.toLowerCase()) {
-      case "b3dm":
-        const loader = new FileLoader();
+      case "b3dm": {
         const parser = await loader.load(fullUrl, B3DMParser, {
           onProgress: (e) => {
           },
@@ -63510,29 +64676,38 @@ class TilesRenderer {
         });
         scene = parser.data;
         break;
-      case "i3dm":
-        scene = await Engine3D.res.loadI3DM(
-          fullUrl,
-          {
-            onProgress: (e) => {
-            },
-            onComplete: (e) => {
-            }
+      }
+      case "i3dm": {
+        const parser = await loader.load(fullUrl, I3DMParser, {
+          onProgress: (e) => {
+          },
+          onComplete: (e) => {
           }
-        );
+        });
+        scene = parser.data;
         break;
+      }
       case "glb":
-      case "gltf":
-        scene = await Engine3D.res.loadGltf(fullUrl, {
+      case "gltf": {
+        const parser = await loader.load(fullUrl, GLTFParser, {
           onProgress: (e) => {
           },
           onComplete: (e) => {
           }
         });
+        scene = parser.data;
         break;
-      case "pnts":
-        console.warn("PNTS format not yet supported");
+      }
+      case "pnts": {
+        const parser = await loader.load(fullUrl, PNTSParser, {
+          onProgress: (e) => {
+          },
+          onComplete: (e) => {
+          }
+        });
+        scene = parser.data;
         break;
+      }
       case "json":
         {
           try {
@@ -68529,69 +69704,6 @@ class TriGeometry extends GeometryBase {
   }
 }
 
-class Float32ArrayTexture extends Texture {
-  create(width, height, data, filtering = true) {
-    let device = webGPUContext.device;
-    const bytesPerRow = width * 4 * 4;
-    this.format = GPUTextureFormat.rgba32float;
-    let mipmapCount = 1;
-    this.createTextureDescriptor(width, height, mipmapCount, this.format);
-    const textureDataBuffer = device.createBuffer({
-      size: data.byteLength,
-      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-    });
-    device.queue.writeBuffer(textureDataBuffer, 0, data);
-    const commandEncoder = GPUContext.beginCommandEncoder();
-    commandEncoder.copyBufferToTexture(
-      {
-        buffer: textureDataBuffer,
-        bytesPerRow
-      },
-      {
-        texture: this.getGPUTexture()
-      },
-      {
-        width,
-        height,
-        depthOrArrayLayers: 1
-      }
-    );
-    GPUContext.endCommandEncoder(commandEncoder);
-    if (filtering) {
-      this.samplerBindingLayout.type = `non-filtering`;
-      this.textureBindingLayout.sampleType = `unfilterable-float`;
-    }
-    this.gpuSampler = device.createSampler({});
-  }
-  fromBuffer(width, height, textureDataBuffer) {
-    let device = webGPUContext.device;
-    const bytesPerRow = width * 4 * 4;
-    this.format = GPUTextureFormat.rgba32float;
-    this.mipmapCount = 1;
-    this.createTextureDescriptor(width, height, this.mipmapCount, this.format);
-    const commandEncoder = GPUContext.beginCommandEncoder();
-    commandEncoder.copyBufferToTexture(
-      {
-        buffer: textureDataBuffer,
-        bytesPerRow
-      },
-      {
-        texture: this.getGPUTexture()
-      },
-      {
-        width,
-        height,
-        depthOrArrayLayers: 1
-      }
-    );
-    GPUContext.endCommandEncoder(commandEncoder);
-    this.samplerBindingLayout.type = `non-filtering`;
-    this.textureBindingLayout.sampleType = `unfilterable-float`;
-    this.gpuSampler = device.createSampler({});
-    return this;
-  }
-}
-
 class SolidColorSky extends LDRTextureCube {
   _internalTexture;
   _minSize = 32;
@@ -69968,4 +71080,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, 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, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PlyMode, PlyParser, 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, 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, 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, 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, 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 };