@rings-webgpu/core 1.0.27 → 1.0.28

package/dist/rings.umd.max.js

@@ -2120,7 +2120,7 @@
   }
 
   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])
@@ -2223,10 +2223,10 @@
       return struct.__size;
     }
   };
-  __decorateClass$m([
+  __decorateClass$o([
     NonSerialize
   ], _Struct.prototype, "__refection");
-  __decorateClass$m([
+  __decorateClass$o([
     NonSerialize
   ], _Struct.prototype, "__size");
   let Struct = _Struct;
@@ -20496,6 +20496,10 @@ struct InstanceData {
       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();
@@ -20764,16 +20768,21 @@ struct InstanceData {
             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,
@@ -21963,9 +21972,9 @@ struct InstanceData {
   }
 
   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;
@@ -22563,13 +22572,13 @@ struct InstanceData {
       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");
 
@@ -22790,7 +22799,7 @@ struct InstanceData {
         @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>;
@@ -22887,7 +22896,7 @@ struct InstanceData {
         return vec4f(v1.x, -v1.y, v2.x, -v2.y);
     }
     
-    // ===== SPLAT MAIN VS (from PlayCanvas gsplat-material.js) =====
+    // ===== SPLAT MAIN VS =====
     
     @vertex
     fn VertMain(
@@ -23236,9 +23245,9 @@ struct InstanceData {
     }
   }
 
-  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;
@@ -23270,7 +23279,7 @@ struct InstanceData {
       pass.setUniform("pixelCull", new Float32Array([2, 0, 0, 0]));
     }
   };
-  exports.GSplatShader = __decorateClass$k([
+  exports.GSplatShader = __decorateClass$m([
     RegisterShader(exports.GSplatShader, "GSplatShader")
   ], exports.GSplatShader);
 
@@ -24053,7 +24062,7 @@ struct InstanceData {
         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(
         {
@@ -24085,7 +24094,7 @@ struct InstanceData {
         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(
         {
@@ -24287,9 +24296,9 @@ struct InstanceData {
     }
   }
 
-  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;
@@ -25088,10 +25097,689 @@ struct InstanceData {
       super.destroy(force);
     }
   };
-  exports.GSplatRenderer = __decorateClass$j([
+  exports.GSplatRenderer = __decorateClass$l([
     RegisterComponent(exports.GSplatRenderer, "GSplatRenderer")
   ], exports.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;
+  };
+  exports.PointCloudShader = class PointCloudShader 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 = false;
+      pass.cullMode = GPUCullMode.none;
+      pass.shaderState.transparent = true;
+      pass.shaderState.blendMode = BlendMode.NORMAL;
+      pass.shaderState.writeMasks = [15, 15];
+      pass.shaderState.castReflection = false;
+      this.addRenderPass(pass);
+      this.setDefault();
+    }
+    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]));
+    }
+  };
+  exports.PointCloudShader = __decorateClass$k([
+    RegisterShader(exports.PointCloudShader, "PointCloudShader")
+  ], exports.PointCloudShader);
+
+  class PointCloudMaterial extends Material {
+    _texParams = new Float32Array([0, 0, 0, 4]);
+    _pointParamsArray = new Float32Array([0, 0, 0, 128]);
+    constructor() {
+      super();
+      this.shader = new exports.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;
+  };
+  exports.PointCloudRenderer = class PointCloudRenderer 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);
+    }
+  };
+  exports.PointCloudRenderer = __decorateClass$j([
+    RegisterComponent(exports.PointCloudRenderer, "PointCloudRenderer")
+  ], exports.PointCloudRenderer);
+
   class BoundUtil {
     static maxVector = new Vector3(
       Number.MAX_VALUE * 0.1,
@@ -25111,6 +25799,36 @@ struct InstanceData {
       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(exports.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);
@@ -41432,7 +42150,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.26";
+  const version = "1.0.27";
 
   class Engine3D {
     /**
@@ -59925,30 +60643,372 @@ fn frag(){
       }
     };
     const position = new Float32Array(vertexCount * 3);
-    const hasNormalData = has("nx") && has("ny") && has("nz");
-    const normal = hasNormalData ? new Float32Array(vertexCount * 3) : new Float32Array(vertexCount * 3);
-    const color = (has("red") || has("r")) && (has("green") || has("g")) && (has("blue") || has("b")) ? new Float32Array(vertexCount * 3) : void 0;
-    const hasVertexUV = (has("u") || has("s")) && (has("v") || has("t"));
-    const hasTexcoord = faceProperties?.some((p) => p.name === "texcoord") || false;
-    const uv = hasVertexUV || hasTexcoord ? new Float32Array(vertexCount * 2) : void 0;
-    const faceTexcoords = /* @__PURE__ */ new Map();
-    const hasTexnumber = faceProperties?.some((p) => p.name === "texnumber") || false;
-    const faceTexnumbers = hasTexnumber ? new Array(faceCount) : [];
-    const indices = [];
-    const triangleTexnumbers = [];
-    const faceVertexUvs = [];
+    const hasNormalData = has("nx") && has("ny") && has("nz");
+    const normal = hasNormalData ? new Float32Array(vertexCount * 3) : new Float32Array(vertexCount * 3);
+    const color = (has("red") || has("r")) && (has("green") || has("g")) && (has("blue") || has("b")) ? new Float32Array(vertexCount * 3) : void 0;
+    const hasVertexUV = (has("u") || has("s")) && (has("v") || has("t"));
+    const hasTexcoord = faceProperties?.some((p) => p.name === "texcoord") || false;
+    const uv = hasVertexUV || hasTexcoord ? new Float32Array(vertexCount * 2) : void 0;
+    const faceTexcoords = /* @__PURE__ */ new Map();
+    const hasTexnumber = faceProperties?.some((p) => p.name === "texnumber") || false;
+    const faceTexnumbers = hasTexnumber ? new Array(faceCount) : [];
+    const indices = [];
+    const triangleTexnumbers = [];
+    const faceVertexUvs = [];
+    const propIndex = (n) => properties.findIndex((p) => p.name === n);
+    const xIdx = propIndex("x");
+    const yIdx = propIndex("y");
+    const zIdx = propIndex("z");
+    const nxIdx = hasNormalData ? propIndex("nx") : -1;
+    const nyIdx = hasNormalData ? propIndex("ny") : -1;
+    const nzIdx = hasNormalData ? propIndex("nz") : -1;
+    const rIdx = color ? propIndex("red") >= 0 ? propIndex("red") : propIndex("r") : -1;
+    const gIdx = color ? propIndex("green") >= 0 ? propIndex("green") : propIndex("g") : -1;
+    const bIdx = color ? propIndex("blue") >= 0 ? propIndex("blue") : propIndex("b") : -1;
+    const uIdx = uv && hasVertexUV ? propIndex("u") >= 0 ? propIndex("u") : propIndex("s") : -1;
+    const vIdx = uv && hasVertexUV ? propIndex("v") >= 0 ? propIndex("v") : propIndex("t") : -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 === nxIdx) {
+          normal[v * 3 + 0] = value;
+        } else if (pIdx === nyIdx) {
+          normal[v * 3 + 1] = value;
+        } else if (pIdx === nzIdx) {
+          normal[v * 3 + 2] = value;
+        } else if (pIdx === rIdx && color) {
+          color[v * 3 + 0] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+        } else if (pIdx === gIdx && color) {
+          color[v * 3 + 1] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+        } else if (pIdx === bIdx && color) {
+          color[v * 3 + 2] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+        } else if (pIdx === uIdx && uv) {
+          uv[v * 2 + 0] = value;
+        } else if (pIdx === vIdx && uv) {
+          uv[v * 2 + 1] = value;
+        }
+      }
+    }
+    for (let f = 0; f < faceCount; f++) {
+      let faceIndices = [];
+      let faceTexcoordArray = void 0;
+      let faceTexnum = 0;
+      for (const prop of faceProperties || []) {
+        if (prop.name === "vertex_indices") {
+          const parts = prop.type.split(" ");
+          const countType = parts[1];
+          const itemType = parts[2];
+          const vertexCountInFace2 = parseASCIINumber(countType);
+          faceIndices = [];
+          for (let i = 0; i < vertexCountInFace2; i++) {
+            faceIndices.push(parseASCIINumber(itemType));
+          }
+        } else if (prop.name === "texcoord") {
+          const parts = prop.type.split(" ");
+          const countType = parts[1];
+          const itemType = parts[2];
+          const texcoordCount = parseASCIINumber(countType);
+          faceTexcoordArray = new Float32Array(texcoordCount);
+          for (let i = 0; i < texcoordCount; i++) {
+            faceTexcoordArray[i] = parseASCIINumber(itemType);
+          }
+          faceTexcoords.set(f, faceTexcoordArray);
+        } else if (prop.name === "texnumber") {
+          faceTexnum = parseASCIINumber(prop.type);
+          faceTexnumbers[f] = faceTexnum;
+        }
+      }
+      const vertexCountInFace = faceIndices.length;
+      const texnum = hasTexnumber ? faceTexnumbers[f] ?? 0 : 0;
+      if (vertexCountInFace === 3) {
+        indices.push(faceIndices[0], faceIndices[1], faceIndices[2]);
+        if (hasTexnumber) {
+          triangleTexnumbers.push(texnum);
+        }
+        if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= 6) {
+          faceVertexUvs.push(
+            faceTexcoordArray[0],
+            1 - faceTexcoordArray[1],
+            faceTexcoordArray[2],
+            1 - faceTexcoordArray[3],
+            faceTexcoordArray[4],
+            1 - faceTexcoordArray[5]
+          );
+        }
+      } else {
+        for (let i = 1; i < vertexCountInFace - 1; i++) {
+          indices.push(faceIndices[0], faceIndices[i], faceIndices[i + 1]);
+          if (hasTexnumber) {
+            triangleTexnumbers.push(texnum);
+          }
+          if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= vertexCountInFace * 2) {
+            faceVertexUvs.push(
+              faceTexcoordArray[0],
+              1 - faceTexcoordArray[1],
+              faceTexcoordArray[i * 2 + 0],
+              1 - faceTexcoordArray[i * 2 + 1],
+              faceTexcoordArray[(i + 1) * 2 + 0],
+              1 - faceTexcoordArray[(i + 1) * 2 + 1]
+            );
+          }
+        }
+      }
+    }
+    if (!hasNormalData) {
+      for (let i = 0; i < vertexCount * 3; i++) {
+        normal[i] = 0;
+      }
+      for (let i = 0; i < indices.length; i += 3) {
+        const i0 = indices[i];
+        const i1 = indices[i + 1];
+        const i2 = indices[i + 2];
+        const v0x = position[i0 * 3 + 0];
+        const v0y = position[i0 * 3 + 1];
+        const v0z = position[i0 * 3 + 2];
+        const v1x = position[i1 * 3 + 0];
+        const v1y = position[i1 * 3 + 1];
+        const v1z = position[i1 * 3 + 2];
+        const v2x = position[i2 * 3 + 0];
+        const v2y = position[i2 * 3 + 1];
+        const v2z = position[i2 * 3 + 2];
+        const edge1x = v1x - v0x;
+        const edge1y = v1y - v0y;
+        const edge1z = v1z - v0z;
+        const edge2x = v2x - v0x;
+        const edge2y = v2y - v0y;
+        const edge2z = v2z - v0z;
+        const nx = edge1y * edge2z - edge1z * edge2y;
+        const ny = edge1z * edge2x - edge1x * edge2z;
+        const nz = edge1x * edge2y - edge1y * edge2x;
+        normal[i0 * 3 + 0] += nx;
+        normal[i0 * 3 + 1] += ny;
+        normal[i0 * 3 + 2] += nz;
+        normal[i1 * 3 + 0] += nx;
+        normal[i1 * 3 + 1] += ny;
+        normal[i1 * 3 + 2] += nz;
+        normal[i2 * 3 + 0] += nx;
+        normal[i2 * 3 + 1] += ny;
+        normal[i2 * 3 + 2] += nz;
+      }
+      for (let v = 0; v < vertexCount; v++) {
+        const nx = normal[v * 3 + 0];
+        const ny = normal[v * 3 + 1];
+        const nz = normal[v * 3 + 2];
+        const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+        if (length > 1e-5) {
+          normal[v * 3 + 0] = nx / length;
+          normal[v * 3 + 1] = ny / length;
+          normal[v * 3 + 2] = nz / length;
+        } else {
+          normal[v * 3 + 0] = 0;
+          normal[v * 3 + 1] = 1;
+          normal[v * 3 + 2] = 0;
+        }
+      }
+    }
+    let finalPosition = position;
+    let finalNormal = normal;
+    let finalColor = color;
+    let finalUv = void 0;
+    let finalIndices = void 0;
+    if (hasTexcoord && faceVertexUvs.length > 0) {
+      const triangleCount = indices.length / 3;
+      const expandedPosition = new Float32Array(triangleCount * 3 * 3);
+      const expandedNormal = new Float32Array(triangleCount * 3 * 3);
+      const expandedColor = color ? new Float32Array(triangleCount * 3 * 3) : void 0;
+      finalUv = new Float32Array(faceVertexUvs);
+      for (let i = 0; i < triangleCount; i++) {
+        const baseIdx = i * 3;
+        const i0 = indices[baseIdx + 0];
+        const i1 = indices[baseIdx + 1];
+        const i2 = indices[baseIdx + 2];
+        expandedPosition[i * 9 + 0] = position[i0 * 3 + 0];
+        expandedPosition[i * 9 + 1] = position[i0 * 3 + 1];
+        expandedPosition[i * 9 + 2] = position[i0 * 3 + 2];
+        expandedPosition[i * 9 + 3] = position[i1 * 3 + 0];
+        expandedPosition[i * 9 + 4] = position[i1 * 3 + 1];
+        expandedPosition[i * 9 + 5] = position[i1 * 3 + 2];
+        expandedPosition[i * 9 + 6] = position[i2 * 3 + 0];
+        expandedPosition[i * 9 + 7] = position[i2 * 3 + 1];
+        expandedPosition[i * 9 + 8] = position[i2 * 3 + 2];
+        expandedNormal[i * 9 + 0] = normal[i0 * 3 + 0];
+        expandedNormal[i * 9 + 1] = normal[i0 * 3 + 1];
+        expandedNormal[i * 9 + 2] = normal[i0 * 3 + 2];
+        expandedNormal[i * 9 + 3] = normal[i1 * 3 + 0];
+        expandedNormal[i * 9 + 4] = normal[i1 * 3 + 1];
+        expandedNormal[i * 9 + 5] = normal[i1 * 3 + 2];
+        expandedNormal[i * 9 + 6] = normal[i2 * 3 + 0];
+        expandedNormal[i * 9 + 7] = normal[i2 * 3 + 1];
+        expandedNormal[i * 9 + 8] = normal[i2 * 3 + 2];
+        if (expandedColor && color) {
+          expandedColor[i * 9 + 0] = color[i0 * 3 + 0];
+          expandedColor[i * 9 + 1] = color[i0 * 3 + 1];
+          expandedColor[i * 9 + 2] = color[i0 * 3 + 2];
+          expandedColor[i * 9 + 3] = color[i1 * 3 + 0];
+          expandedColor[i * 9 + 4] = color[i1 * 3 + 1];
+          expandedColor[i * 9 + 5] = color[i1 * 3 + 2];
+          expandedColor[i * 9 + 6] = color[i2 * 3 + 0];
+          expandedColor[i * 9 + 7] = color[i2 * 3 + 1];
+          expandedColor[i * 9 + 8] = color[i2 * 3 + 2];
+        }
+      }
+      finalPosition = expandedPosition;
+      finalNormal = expandedNormal;
+      finalColor = expandedColor;
+      const sequentialIndices = new Uint32Array(triangleCount * 3);
+      for (let i = 0; i < triangleCount * 3; i++) {
+        sequentialIndices[i] = i;
+      }
+      finalIndices = sequentialIndices;
+    } else {
+      finalIndices = new Uint32Array(indices);
+      finalUv = uv;
+    }
+    return {
+      vertexCount: hasTexcoord && faceVertexUvs.length > 0 ? finalPosition.length / 3 : vertexCount,
+      faceCount,
+      position: finalPosition,
+      normal: finalNormal,
+      color: finalColor,
+      uv: finalUv,
+      indices: finalIndices,
+      textureFiles: textureFiles.length > 0 ? textureFiles : void 0,
+      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 nxIdx = hasNormalData ? propIndex("nx") : -1;
-    const nyIdx = hasNormalData ? propIndex("ny") : -1;
-    const nzIdx = hasNormalData ? propIndex("nz") : -1;
-    const rIdx = color ? propIndex("red") >= 0 ? propIndex("red") : propIndex("r") : -1;
-    const gIdx = color ? propIndex("green") >= 0 ? propIndex("green") : propIndex("g") : -1;
-    const bIdx = color ? propIndex("blue") >= 0 ? propIndex("blue") : propIndex("b") : -1;
-    const uIdx = uv && hasVertexUV ? propIndex("u") >= 0 ? propIndex("u") : propIndex("s") : -1;
-    const vIdx = uv && hasVertexUV ? propIndex("v") >= 0 ? propIndex("v") : propIndex("t") : -1;
+    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];
@@ -59959,210 +61019,28 @@ fn frag(){
           position[v * 3 + 1] = value;
         } else if (pIdx === zIdx) {
           position[v * 3 + 2] = value;
-        } else if (pIdx === nxIdx) {
-          normal[v * 3 + 0] = value;
-        } else if (pIdx === nyIdx) {
-          normal[v * 3 + 1] = value;
-        } else if (pIdx === nzIdx) {
-          normal[v * 3 + 2] = value;
         } else if (pIdx === rIdx && color) {
-          color[v * 3 + 0] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+          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) {
-          color[v * 3 + 1] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+          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) {
-          color[v * 3 + 2] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
-        } else if (pIdx === uIdx && uv) {
-          uv[v * 2 + 0] = value;
-        } else if (pIdx === vIdx && uv) {
-          uv[v * 2 + 1] = value;
-        }
-      }
-    }
-    for (let f = 0; f < faceCount; f++) {
-      let faceIndices = [];
-      let faceTexcoordArray = void 0;
-      let faceTexnum = 0;
-      for (const prop of faceProperties || []) {
-        if (prop.name === "vertex_indices") {
-          const parts = prop.type.split(" ");
-          const countType = parts[1];
-          const itemType = parts[2];
-          const vertexCountInFace2 = parseASCIINumber(countType);
-          faceIndices = [];
-          for (let i = 0; i < vertexCountInFace2; i++) {
-            faceIndices.push(parseASCIINumber(itemType));
-          }
-        } else if (prop.name === "texcoord") {
-          const parts = prop.type.split(" ");
-          const countType = parts[1];
-          const itemType = parts[2];
-          const texcoordCount = parseASCIINumber(countType);
-          faceTexcoordArray = new Float32Array(texcoordCount);
-          for (let i = 0; i < texcoordCount; i++) {
-            faceTexcoordArray[i] = parseASCIINumber(itemType);
-          }
-          faceTexcoords.set(f, faceTexcoordArray);
-        } else if (prop.name === "texnumber") {
-          faceTexnum = parseASCIINumber(prop.type);
-          faceTexnumbers[f] = faceTexnum;
-        }
-      }
-      const vertexCountInFace = faceIndices.length;
-      const texnum = hasTexnumber ? faceTexnumbers[f] ?? 0 : 0;
-      if (vertexCountInFace === 3) {
-        indices.push(faceIndices[0], faceIndices[1], faceIndices[2]);
-        if (hasTexnumber) {
-          triangleTexnumbers.push(texnum);
-        }
-        if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= 6) {
-          faceVertexUvs.push(
-            faceTexcoordArray[0],
-            1 - faceTexcoordArray[1],
-            faceTexcoordArray[2],
-            1 - faceTexcoordArray[3],
-            faceTexcoordArray[4],
-            1 - faceTexcoordArray[5]
-          );
-        }
-      } else {
-        for (let i = 1; i < vertexCountInFace - 1; i++) {
-          indices.push(faceIndices[0], faceIndices[i], faceIndices[i + 1]);
-          if (hasTexnumber) {
-            triangleTexnumbers.push(texnum);
-          }
-          if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= vertexCountInFace * 2) {
-            faceVertexUvs.push(
-              faceTexcoordArray[0],
-              1 - faceTexcoordArray[1],
-              faceTexcoordArray[i * 2 + 0],
-              1 - faceTexcoordArray[i * 2 + 1],
-              faceTexcoordArray[(i + 1) * 2 + 0],
-              1 - faceTexcoordArray[(i + 1) * 2 + 1]
-            );
-          }
-        }
-      }
-    }
-    if (!hasNormalData) {
-      for (let i = 0; i < vertexCount * 3; i++) {
-        normal[i] = 0;
-      }
-      for (let i = 0; i < indices.length; i += 3) {
-        const i0 = indices[i];
-        const i1 = indices[i + 1];
-        const i2 = indices[i + 2];
-        const v0x = position[i0 * 3 + 0];
-        const v0y = position[i0 * 3 + 1];
-        const v0z = position[i0 * 3 + 2];
-        const v1x = position[i1 * 3 + 0];
-        const v1y = position[i1 * 3 + 1];
-        const v1z = position[i1 * 3 + 2];
-        const v2x = position[i2 * 3 + 0];
-        const v2y = position[i2 * 3 + 1];
-        const v2z = position[i2 * 3 + 2];
-        const edge1x = v1x - v0x;
-        const edge1y = v1y - v0y;
-        const edge1z = v1z - v0z;
-        const edge2x = v2x - v0x;
-        const edge2y = v2y - v0y;
-        const edge2z = v2z - v0z;
-        const nx = edge1y * edge2z - edge1z * edge2y;
-        const ny = edge1z * edge2x - edge1x * edge2z;
-        const nz = edge1x * edge2y - edge1y * edge2x;
-        normal[i0 * 3 + 0] += nx;
-        normal[i0 * 3 + 1] += ny;
-        normal[i0 * 3 + 2] += nz;
-        normal[i1 * 3 + 0] += nx;
-        normal[i1 * 3 + 1] += ny;
-        normal[i1 * 3 + 2] += nz;
-        normal[i2 * 3 + 0] += nx;
-        normal[i2 * 3 + 1] += ny;
-        normal[i2 * 3 + 2] += nz;
-      }
-      for (let v = 0; v < vertexCount; v++) {
-        const nx = normal[v * 3 + 0];
-        const ny = normal[v * 3 + 1];
-        const nz = normal[v * 3 + 2];
-        const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
-        if (length > 1e-5) {
-          normal[v * 3 + 0] = nx / length;
-          normal[v * 3 + 1] = ny / length;
-          normal[v * 3 + 2] = nz / length;
-        } else {
-          normal[v * 3 + 0] = 0;
-          normal[v * 3 + 1] = 1;
-          normal[v * 3 + 2] = 0;
+          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));
         }
       }
-    }
-    let finalPosition = position;
-    let finalNormal = normal;
-    let finalColor = color;
-    let finalUv = void 0;
-    let finalIndices = void 0;
-    if (hasTexcoord && faceVertexUvs.length > 0) {
-      const triangleCount = indices.length / 3;
-      const expandedPosition = new Float32Array(triangleCount * 3 * 3);
-      const expandedNormal = new Float32Array(triangleCount * 3 * 3);
-      const expandedColor = color ? new Float32Array(triangleCount * 3 * 3) : void 0;
-      finalUv = new Float32Array(faceVertexUvs);
-      for (let i = 0; i < triangleCount; i++) {
-        const baseIdx = i * 3;
-        const i0 = indices[baseIdx + 0];
-        const i1 = indices[baseIdx + 1];
-        const i2 = indices[baseIdx + 2];
-        expandedPosition[i * 9 + 0] = position[i0 * 3 + 0];
-        expandedPosition[i * 9 + 1] = position[i0 * 3 + 1];
-        expandedPosition[i * 9 + 2] = position[i0 * 3 + 2];
-        expandedPosition[i * 9 + 3] = position[i1 * 3 + 0];
-        expandedPosition[i * 9 + 4] = position[i1 * 3 + 1];
-        expandedPosition[i * 9 + 5] = position[i1 * 3 + 2];
-        expandedPosition[i * 9 + 6] = position[i2 * 3 + 0];
-        expandedPosition[i * 9 + 7] = position[i2 * 3 + 1];
-        expandedPosition[i * 9 + 8] = position[i2 * 3 + 2];
-        expandedNormal[i * 9 + 0] = normal[i0 * 3 + 0];
-        expandedNormal[i * 9 + 1] = normal[i0 * 3 + 1];
-        expandedNormal[i * 9 + 2] = normal[i0 * 3 + 2];
-        expandedNormal[i * 9 + 3] = normal[i1 * 3 + 0];
-        expandedNormal[i * 9 + 4] = normal[i1 * 3 + 1];
-        expandedNormal[i * 9 + 5] = normal[i1 * 3 + 2];
-        expandedNormal[i * 9 + 6] = normal[i2 * 3 + 0];
-        expandedNormal[i * 9 + 7] = normal[i2 * 3 + 1];
-        expandedNormal[i * 9 + 8] = normal[i2 * 3 + 2];
-        if (expandedColor && color) {
-          expandedColor[i * 9 + 0] = color[i0 * 3 + 0];
-          expandedColor[i * 9 + 1] = color[i0 * 3 + 1];
-          expandedColor[i * 9 + 2] = color[i0 * 3 + 2];
-          expandedColor[i * 9 + 3] = color[i1 * 3 + 0];
-          expandedColor[i * 9 + 4] = color[i1 * 3 + 1];
-          expandedColor[i * 9 + 5] = color[i1 * 3 + 2];
-          expandedColor[i * 9 + 6] = color[i2 * 3 + 0];
-          expandedColor[i * 9 + 7] = color[i2 * 3 + 1];
-          expandedColor[i * 9 + 8] = color[i2 * 3 + 2];
-        }
+      if (color && aIdx < 0) {
+        color[v * 4 + 3] = 255;
       }
-      finalPosition = expandedPosition;
-      finalNormal = expandedNormal;
-      finalColor = expandedColor;
-      const sequentialIndices = new Uint32Array(triangleCount * 3);
-      for (let i = 0; i < triangleCount * 3; i++) {
-        sequentialIndices[i] = i;
-      }
-      finalIndices = sequentialIndices;
-    } else {
-      finalIndices = new Uint32Array(indices);
-      finalUv = uv;
     }
     return {
-      vertexCount: hasTexcoord && faceVertexUvs.length > 0 ? finalPosition.length / 3 : vertexCount,
-      faceCount,
-      position: finalPosition,
-      normal: finalNormal,
-      color: finalColor,
-      uv: finalUv,
-      indices: finalIndices,
-      textureFiles: textureFiles.length > 0 ? textureFiles : void 0,
-      triangleTexnumbers: triangleTexnumbers.length > 0 ? triangleTexnumbers : void 0
+      vertexCount,
+      position,
+      color
     };
   }
 
@@ -60297,6 +61175,23 @@ fn frag(){
           break;
         }
         case PlyMode.PointCloud: {
+          const plyData = parsePlyPointCloud(buffer);
+          const pointCloudObj = new exports.Object3D();
+          pointCloudObj.name = "PLYPointCloud";
+          const pointCloudObjRoot = new exports.Object3D();
+          pointCloudObjRoot.name = "PLYPointCloudRoot";
+          pointCloudObj.addChild(pointCloudObjRoot);
+          const renderer = pointCloudObjRoot.addComponent(exports.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: {
@@ -68536,69 +69431,6 @@ fn frag(){
     }
   }
 
-  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;
@@ -70386,6 +71218,10 @@ fn frag(){
   exports.PlyMode = PlyMode;
   exports.PlyParser = PlyParser;
   exports.PointClassification = PointClassification;
+  exports.PointCloudGeometry = PointCloudGeometry;
+  exports.PointCloudMaterial = PointCloudMaterial;
+  exports.PointCloud_FS = PointCloud_FS;
+  exports.PointCloud_VS = PointCloud_VS;
   exports.PointLightShadowRenderer = PointLightShadowRenderer;
   exports.PointShadowCubeCamera = PointShadowCubeCamera;
   exports.PointerEvent3D = PointerEvent3D;
@@ -70726,6 +71562,7 @@ fn frag(){
   exports.parsePlyGaussianSplat = parsePlyGaussianSplat;
   exports.parsePlyHeader = parsePlyHeader;
   exports.parsePlyMesh = parsePlyMesh;
+  exports.parsePlyPointCloud = parsePlyPointCloud;
   exports.perm = perm;
   exports.post = post;
   exports.priorityCallback = priorityCallback;