@rings-webgpu/core 1.0.28 → 1.0.30

package/dist/rings.umd.max.js

@@ -25253,9 +25253,9 @@ struct InstanceData {
       pass.passType = PassType.COLOR;
       pass.setShaderEntry("VertMain", "FragMain");
       pass.topology = GPUPrimitiveTopology.triangle_list;
-      pass.depthWriteEnabled = false;
+      pass.depthWriteEnabled = true;
       pass.cullMode = GPUCullMode.none;
-      pass.shaderState.transparent = true;
+      pass.shaderState.transparent = false;
       pass.shaderState.blendMode = BlendMode.NORMAL;
       pass.shaderState.writeMasks = [15, 15];
       pass.shaderState.castReflection = false;
@@ -39806,7 +39806,10 @@ else if (typeof exports === 'object')
     buffer;
     binOffset;
     binLength;
-    header;
+    _header;
+    get header() {
+      return this._header;
+    }
     constructor(buffer, start, headerLength, binLength) {
       this.buffer = buffer;
       this.binOffset = start + headerLength;
@@ -39818,13 +39821,13 @@ else if (typeof exports === 'object')
       } 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;
       }
@@ -39906,7 +39909,7 @@ else if (typeof exports === 'object')
     }
     destroy() {
       this.buffer = null;
-      this.header = null;
+      this._header = null;
       this.binOffset = null;
       this.binLength = null;
     }
@@ -42150,7 +42153,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.27";
+  const version = "1.0.29";
 
   class Engine3D {
     /**
@@ -61295,6 +61298,276 @@ fn frag(){
     }
   }
 
+  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 exports.Object3D();
+      const renderer = pointCloudObj.addComponent(exports.PointCloudRenderer);
+      renderer.initFromData(positions, colors, pointsLength);
+      renderer.setPointShape("circle");
+      renderer.setPointSize(4);
+      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 exports.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;
@@ -64401,9 +64674,9 @@ fn frag(){
       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) => {
             },
@@ -64412,29 +64685,38 @@ fn frag(){
           });
           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 {
@@ -71197,6 +71479,9 @@ fn frag(){
   exports.PBRLItShader = PBRLItShader;
   exports.PBRLitSSSShader = PBRLitSSSShader;
   exports.PLUGIN_REGISTERED = PLUGIN_REGISTERED;
+  exports.PNTSLoader = PNTSLoader;
+  exports.PNTSLoaderBase = PNTSLoaderBase;
+  exports.PNTSParser = PNTSParser;
   exports.ParserBase = ParserBase;
   exports.ParserFormat = ParserFormat;
   exports.ParticleSystemCurveEvalMode = ParticleSystemCurveEvalMode;

package/dist/types/index.d.ts

@@ -432,6 +432,9 @@ export * from "./loader/parser/ply/PlyLoader";
 export * from "./loader/parser/ply/PlyParser";
 export * from "./loader/parser/ply/PlyTypes";
 export * from "./loader/parser/ply/PlyUtils";
+export * from "./loader/parser/pnts/PNTSLoader";
+export * from "./loader/parser/pnts/PNTSLoaderBase";
+export * from "./loader/parser/pnts/PNTSParser";
 export * from "./loader/parser/prefab/PrefabAvatarParser";
 export * from "./loader/parser/prefab/PrefabMaterialParser";
 export * from "./loader/parser/prefab/PrefabMeshParser";

package/dist/types/loader/parser/b3dm/FeatureTable.d.ts

@@ -2,7 +2,8 @@ export declare class FeatureTable {
     private buffer;
     private binOffset;
     private binLength;
-    private header;
+    private _header;
+    get header(): any;
     constructor(buffer: any, start: any, headerLength: any, binLength: any);
     getKeys(): string[];
     getData(key: any, count?: any, defaultComponentType?: any, defaultType?: any): any;

package/dist/types/loader/parser/pnts/PNTSLoader.d.ts

@@ -0,0 +1,10 @@
+import { PNTSLoaderBase } from "./PNTSLoaderBase";
+export declare class PNTSLoader extends PNTSLoaderBase {
+    parse(buffer: ArrayBuffer): Promise<any>;
+    private parsePositions;
+    private parseColors;
+    private parseNormals;
+    private decodeRGB565;
+    private decodeOctNormals;
+    private parseDraco;
+}

package/dist/types/loader/parser/pnts/PNTSLoaderBase.d.ts

@@ -0,0 +1,8 @@
+import { FeatureTable, BatchTable } from "../b3dm/FeatureTable";
+export declare class PNTSLoaderBase {
+    parse(buffer: ArrayBuffer): Promise<{
+        version: number;
+        featureTable: FeatureTable;
+        batchTable: BatchTable;
+    }>;
+}

package/dist/types/loader/parser/pnts/PNTSParser.d.ts

@@ -0,0 +1,7 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+export declare class PNTSParser extends ParserBase {
+    static format: ParserFormat;
+    parseBuffer(buffer: ArrayBuffer): Promise<void>;
+    verification(): boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rings-webgpu/core",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {