@rings-webgpu/core 1.0.19 → 1.0.21

package/dist/rings.umd.max.js

@@ -25047,30 +25047,32 @@ struct InstanceData {
     static genGSplatBounds(obj, bound) {
       bound ||= new BoundingBox(Vector3.ZERO, Vector3.ZERO);
       bound.setFromMinMax(this.maxVector, this.minVector);
-      let gsplatRenderer = obj.getComponent(exports.GSplatRenderer);
-      if (!gsplatRenderer) {
+      let gsplatRenderers = obj.getComponents(exports.GSplatRenderer);
+      if (!gsplatRenderers) {
         console.warn("genGSplatBounds: No GSplatRenderer found on object");
         return bound;
       }
-      const positions = gsplatRenderer.positions;
-      const count = gsplatRenderer.fullCount;
-      if (!positions || count === 0) {
-        console.warn("genGSplatBounds: No position data available");
-        return bound;
-      }
-      const matrix = obj.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);
+      for (const gsplatRenderer of gsplatRenderers) {
+        const positions = gsplatRenderer.positions;
+        const count = gsplatRenderer.fullCount;
+        if (!positions || count === 0) {
+          console.warn("genGSplatBounds: No position data available");
+          return bound;
+        }
+        const matrix = obj.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);
+        }
+        bound.setFromMinMax(bound.min, bound.max);
       }
-      bound.setFromMinMax(bound.min, bound.max);
       return bound;
     }
     static genMeshBounds(obj, bound) {
@@ -36933,6 +36935,8 @@ else if (typeof exports === 'object')
     matLibs;
     geometrys;
     activeGeo;
+    currentObjectName;
+    currentMaterialName;
     facesMaterialsIndex;
     mtl;
     mtlUrl;
@@ -36941,26 +36945,35 @@ else if (typeof exports === 'object')
       this.source_normals = [];
       this.source_tangents = [];
       this.source_textureCoords = [];
+      this.currentObjectName = "default";
+      this.currentMaterialName = "";
       this.matLibs = {};
       this.geometrys = {};
+      this.activeGeo = void 0;
       this.textData = obj;
       await Promise.all([this.parserOBJ(), this.loadMTL()]);
       this.parser_mesh();
       return `null`;
     }
     applyVector2(fi, sourceData, destData) {
-      if (sourceData[fi] && sourceData[fi].length > 0) {
+      if (fi >= 0 && sourceData[fi] && sourceData[fi].length > 0) {
         destData.push(sourceData[fi][0]);
-        destData.push(sourceData[fi][1]);
+        destData.push(-sourceData[fi][1]);
       } else {
         destData.push(0);
         destData.push(0);
       }
     }
     applyVector3(fi, sourceData, destData) {
-      destData.push(sourceData[fi][0]);
-      destData.push(sourceData[fi][1]);
-      destData.push(sourceData[fi][2]);
+      if (fi >= 0 && sourceData[fi] && sourceData[fi].length > 0) {
+        destData.push(sourceData[fi][0]);
+        destData.push(sourceData[fi][1]);
+        destData.push(sourceData[fi][2]);
+      } else {
+        destData.push(0);
+        destData.push(0);
+        destData.push(0);
+      }
     }
     applyVector4(fi, sourceData, destData) {
       destData.push(sourceData[fi][0]);
@@ -36968,12 +36981,76 @@ else if (typeof exports === 'object')
       destData.push(sourceData[fi][2]);
       destData.push(sourceData[fi][3]);
     }
+    /**
+     * Parse UV index with support for negative indices (OBJ format)
+     * Similar to Three.js parseUVIndex method
+     */
+    parseUVIndex(value, uvCount) {
+      const index = parseInt(value, 10);
+      if (index >= 0) {
+        return index - 1;
+      } else {
+        return uvCount + index;
+      }
+    }
+    /**
+     * Parse vertex index with support for negative indices (OBJ format)
+     */
+    parseVertexIndex(value, vertexCount) {
+      const index = parseInt(value, 10);
+      if (index >= 0) {
+        return index - 1;
+      } else {
+        return vertexCount + index;
+      }
+    }
+    /**
+     * Parse normal index with support for negative indices (OBJ format)
+     */
+    parseNormalIndex(value, normalCount) {
+      const index = parseInt(value, 10);
+      if (index >= 0) {
+        return index - 1;
+      } else {
+        return normalCount + index;
+      }
+    }
+    /**
+     * Calculate face normal from three vertices using cross product
+     * Similar to Three.js addFaceNormal method
+     */
+    calculateFaceNormal(v0, v1, v2) {
+      const edge1 = [
+        v1[0] - v0[0],
+        v1[1] - v0[1],
+        v1[2] - v0[2]
+      ];
+      const edge2 = [
+        v2[0] - v0[0],
+        v2[1] - v0[1],
+        v2[2] - v0[2]
+      ];
+      const normal = [
+        edge1[1] * edge2[2] - edge1[2] * edge2[1],
+        edge1[2] * edge2[0] - edge1[0] * edge2[2],
+        edge1[0] * edge2[1] - edge1[1] * edge2[0]
+      ];
+      const length = Math.sqrt(
+        normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]
+      );
+      if (length > 0) {
+        normal[0] /= length;
+        normal[1] /= length;
+        normal[2] /= length;
+      }
+      return normal;
+    }
     async loadMTL() {
       let fileLoad = new FileLoader();
       let sourceData = await fileLoad.loadTxt(this.baseUrl + this.mtlUrl);
       let sourceStr = sourceData[`data`];
       let mat;
-      let str = sourceStr.split("\r\n");
+      let str = sourceStr.split(/\r?\n/);
       for (let i = 0; i < str.length; i++) {
         let line = str[i];
         var commentStart = line.indexOf("#");
@@ -37024,20 +37101,41 @@ else if (typeof exports === 'object')
     }
     async load_textures() {
     }
+    getGeometryKey(objectName, materialName) {
+      const objName = (objectName ?? this.currentObjectName ?? "default") || "default";
+      const matName = materialName ?? this.currentMaterialName ?? "";
+      const matKey = matName.length > 0 ? matName : "default";
+      return `${objName}::${matKey}`;
+    }
+    ensureActiveGeo(objectName, materialName) {
+      const objName = (objectName ?? this.currentObjectName ?? "default") || "default";
+      const matName = materialName ?? this.currentMaterialName ?? "";
+      const geoKey = this.getGeometryKey(objName, matName);
+      if (!this.geometrys[geoKey]) {
+        this.geometrys[geoKey] = {
+          type: objName,
+          name: geoKey,
+          source_mat: matName,
+          source_faces: []
+        };
+      } else if (this.geometrys[geoKey].source_mat !== matName) {
+        this.geometrys[geoKey].source_mat = matName;
+      }
+      this.activeGeo = this.geometrys[geoKey];
+    }
     parserLine(line) {
       var commentStart = line.indexOf("#");
       if (commentStart != -1) {
         if (line.indexOf(`# object`) != -1) {
-          var splitedLine = line.split(/\s+/);
-          let type = splitedLine[1];
-          let geoName = splitedLine[2];
-          this.activeGeo = {
-            type,
-            name: geoName[1],
-            source_mat: ``,
-            source_faces: []
-          };
-          this.geometrys[geoName] = this.activeGeo;
+          const commentParts = line.split(/\s+/);
+          const type = commentParts[1] || "default";
+          const geoName = commentParts[2] || "default";
+          this.currentObjectName = geoName;
+          this.activeGeo = void 0;
+          this.ensureActiveGeo(geoName, this.currentMaterialName);
+          if (this.activeGeo) {
+            this.activeGeo.type = type;
+          }
         }
         line = line.substring(0, commentStart);
       }
@@ -37072,33 +37170,30 @@ else if (typeof exports === 'object')
           normal: []
         };
         for (var i = 1; i < splitedLine.length; ++i) {
-          var dIndex = splitedLine[i].indexOf("//");
-          var splitedFaceIndices = splitedLine[i].split(/\W+/);
-          if (dIndex > 0) {
-            face.indices.push(splitedFaceIndices[0]);
-            face.normal.push(splitedFaceIndices[1]);
-          } else {
-            if (splitedFaceIndices.length === 1) {
-              face.indices.push(splitedFaceIndices[0]);
-            } else if (splitedFaceIndices.length === 2) {
-              face.indices.push(splitedFaceIndices[0]);
-              face.texture.push(splitedFaceIndices[1]);
-            } else if (splitedFaceIndices.length === 3) {
-              face.indices.push(splitedFaceIndices[0]);
-              face.texture.push(splitedFaceIndices[1]);
-              face.normal.push(splitedFaceIndices[2]);
-            }
+          var vertexStr = splitedLine[i];
+          if (vertexStr.length === 0) continue;
+          var vertexParts = vertexStr.split("/");
+          var positionIndex = vertexParts[0] || "";
+          var textureIndex = vertexParts.length >= 2 ? vertexParts[1] || "" : "";
+          var normalIndex = vertexParts.length >= 3 ? vertexParts[2] || "" : "";
+          if (positionIndex.length === 0) {
+            continue;
           }
+          face.indices.push(positionIndex);
+          face.texture.push(textureIndex);
+          face.normal.push(normalIndex);
         }
+        this.ensureActiveGeo();
         this.activeGeo.source_faces.push(face);
       } else if (splitedLine[0] === "usemtl") {
-        this.activeGeo.source_mat = splitedLine[1];
+        this.currentMaterialName = splitedLine[1] || "";
+        this.ensureActiveGeo(this.currentObjectName, this.currentMaterialName);
       } else if (splitedLine[0] === `mtllib`) {
         this.mtlUrl = splitedLine[1];
       }
     }
     async parserOBJ() {
-      let str = this.textData.split("\r\n");
+      let str = this.textData.split(/\r?\n/);
       for (let i = 0; i < str.length; i++) {
         const element = str[i];
         this.parserLine(element);
@@ -37115,44 +37210,138 @@ else if (typeof exports === 'object')
         geoData.uv_arr = [];
         geoData.indeice_arr = [];
         let index = 0;
+        const vertexCount = this.source_vertices.length;
+        const normalCount = this.source_normals.length;
+        const uvCount = this.source_textureCoords.length;
         for (let i = 0; i < geoData.source_faces.length; i++) {
           const face = geoData.source_faces[i];
-          let f0 = parseInt(face.indices[0]) - 1;
-          let f1 = parseInt(face.indices[1]) - 1;
-          let f2 = parseInt(face.indices[2]) - 1;
-          let n0 = parseInt(face.normal[0]) - 1;
-          let n1 = parseInt(face.normal[1]) - 1;
-          let n2 = parseInt(face.normal[2]) - 1;
-          let u0 = parseInt(face.texture[0]) - 1;
-          let u1 = parseInt(face.texture[1]) - 1;
-          let u2 = parseInt(face.texture[2]) - 1;
+          let f0 = this.parseVertexIndex(face.indices[0], vertexCount);
+          let f1 = this.parseVertexIndex(face.indices[1], vertexCount);
+          let f2 = this.parseVertexIndex(face.indices[2], vertexCount);
+          const getNormalIndex = (value) => {
+            if (!value || value.length === 0) {
+              return -1;
+            }
+            const parsed = this.parseNormalIndex(value, normalCount);
+            return Number.isFinite(parsed) && parsed >= 0 && parsed < normalCount ? parsed : -1;
+          };
+          const getUVIndex = (value) => {
+            if (!value || value.length === 0) {
+              return -1;
+            }
+            const parsed = this.parseUVIndex(value, uvCount);
+            return Number.isFinite(parsed) && parsed >= 0 && parsed < uvCount ? parsed : -1;
+          };
+          let n0 = getNormalIndex(face.normal[0]);
+          let n1 = getNormalIndex(face.normal[1]);
+          let n2 = getNormalIndex(face.normal[2]);
+          const needsFaceNormal = n0 < 0 || n1 < 0 || n2 < 0;
+          let faceNormal = null;
+          if (needsFaceNormal && f0 >= 0 && f1 >= 0 && f2 >= 0 && this.source_vertices[f0] && this.source_vertices[f1] && this.source_vertices[f2]) {
+            faceNormal = this.calculateFaceNormal(
+              this.source_vertices[f0],
+              this.source_vertices[f1],
+              this.source_vertices[f2]
+            );
+          }
+          let u0 = getUVIndex(face.texture[0]);
+          let u1 = getUVIndex(face.texture[1]);
+          let u2 = getUVIndex(face.texture[2]);
           this.applyVector3(f0, this.source_vertices, geoData.vertex_arr);
-          this.applyVector3(n0, this.source_normals, geoData.normal_arr);
-          this.applyVector2(u0, this.source_textureCoords, geoData.uv_arr);
+          if (n0 >= 0) {
+            this.applyVector3(n0, this.source_normals, geoData.normal_arr);
+          } else if (faceNormal) {
+            geoData.normal_arr.push(faceNormal[0], faceNormal[1], faceNormal[2]);
+          } else {
+            geoData.normal_arr.push(0, 0, 0);
+          }
+          if (u0 >= 0) {
+            this.applyVector2(u0, this.source_textureCoords, geoData.uv_arr);
+          } else {
+            geoData.uv_arr.push(0, 0);
+          }
           geoData.indeice_arr[index] = index++;
           this.applyVector3(f1, this.source_vertices, geoData.vertex_arr);
-          this.applyVector3(n1, this.source_normals, geoData.normal_arr);
-          this.applyVector2(u1, this.source_textureCoords, geoData.uv_arr);
+          if (n1 >= 0) {
+            this.applyVector3(n1, this.source_normals, geoData.normal_arr);
+          } else if (faceNormal) {
+            geoData.normal_arr.push(faceNormal[0], faceNormal[1], faceNormal[2]);
+          } else {
+            geoData.normal_arr.push(0, 0, 0);
+          }
+          if (u1 >= 0) {
+            this.applyVector2(u1, this.source_textureCoords, geoData.uv_arr);
+          } else {
+            geoData.uv_arr.push(0, 0);
+          }
           geoData.indeice_arr[index] = index++;
           this.applyVector3(f2, this.source_vertices, geoData.vertex_arr);
-          this.applyVector3(n2, this.source_normals, geoData.normal_arr);
-          this.applyVector2(u2, this.source_textureCoords, geoData.uv_arr);
+          if (n2 >= 0) {
+            this.applyVector3(n2, this.source_normals, geoData.normal_arr);
+          } else if (faceNormal) {
+            geoData.normal_arr.push(faceNormal[0], faceNormal[1], faceNormal[2]);
+          } else {
+            geoData.normal_arr.push(0, 0, 0);
+          }
+          if (u2 >= 0) {
+            this.applyVector2(u2, this.source_textureCoords, geoData.uv_arr);
+          } else {
+            geoData.uv_arr.push(0, 0);
+          }
           geoData.indeice_arr[index] = index++;
           if (face.indices.length > 3) {
-            let f3 = parseInt(face.indices[3]) - 1;
-            let n3 = parseInt(face.normal[3]) - 1;
-            let u3 = parseInt(face.texture[3]) - 1;
+            let f3 = this.parseVertexIndex(face.indices[3], vertexCount);
+            let n3 = getNormalIndex(face.normal[3]);
+            let u3 = getUVIndex(face.texture[3]);
+            let faceNormal2 = null;
+            if ((n0 < 0 || n2 < 0 || n3 < 0) && f0 >= 0 && f2 >= 0 && f3 >= 0 && this.source_vertices[f0] && this.source_vertices[f2] && this.source_vertices[f3]) {
+              faceNormal2 = this.calculateFaceNormal(
+                this.source_vertices[f0],
+                this.source_vertices[f2],
+                this.source_vertices[f3]
+              );
+            }
             this.applyVector3(f0, this.source_vertices, geoData.vertex_arr);
-            this.applyVector3(n0, this.source_normals, geoData.normal_arr);
-            this.applyVector2(u0, this.source_textureCoords, geoData.uv_arr);
+            if (n0 >= 0) {
+              this.applyVector3(n0, this.source_normals, geoData.normal_arr);
+            } else if (faceNormal2) {
+              geoData.normal_arr.push(faceNormal2[0], faceNormal2[1], faceNormal2[2]);
+            } else {
+              geoData.normal_arr.push(0, 0, 0);
+            }
+            if (u0 >= 0) {
+              this.applyVector2(u0, this.source_textureCoords, geoData.uv_arr);
+            } else {
+              geoData.uv_arr.push(0, 0);
+            }
             geoData.indeice_arr[index] = index++;
             this.applyVector3(f2, this.source_vertices, geoData.vertex_arr);
-            this.applyVector3(n2, this.source_normals, geoData.normal_arr);
-            this.applyVector2(u2, this.source_textureCoords, geoData.uv_arr);
+            if (n2 >= 0) {
+              this.applyVector3(n2, this.source_normals, geoData.normal_arr);
+            } else if (faceNormal2) {
+              geoData.normal_arr.push(faceNormal2[0], faceNormal2[1], faceNormal2[2]);
+            } else {
+              geoData.normal_arr.push(0, 0, 0);
+            }
+            if (u2 >= 0) {
+              this.applyVector2(u2, this.source_textureCoords, geoData.uv_arr);
+            } else {
+              geoData.uv_arr.push(0, 0);
+            }
             geoData.indeice_arr[index] = index++;
             this.applyVector3(f3, this.source_vertices, geoData.vertex_arr);
-            this.applyVector3(n3, this.source_normals, geoData.normal_arr);
-            this.applyVector2(u3, this.source_textureCoords, geoData.uv_arr);
+            if (n3 >= 0) {
+              this.applyVector3(n3, this.source_normals, geoData.normal_arr);
+            } else if (faceNormal2) {
+              geoData.normal_arr.push(faceNormal2[0], faceNormal2[1], faceNormal2[2]);
+            } else {
+              geoData.normal_arr.push(0, 0, 0);
+            }
+            if (u3 >= 0) {
+              this.applyVector2(u3, this.source_textureCoords, geoData.uv_arr);
+            } else {
+              geoData.uv_arr.push(0, 0);
+            }
             geoData.indeice_arr[index] = index++;
           }
         }
@@ -37184,10 +37373,17 @@ else if (typeof exports === 'object')
           topology: 0
         });
         let mat = new LitMaterial();
-        let matData = this.matLibs[geoData.source_mat];
-        mat.baseMap = Engine3D.res.getTexture(
-          StringUtil.normalizePath(this.baseUrl + matData.map_Kd)
-        );
+        const matName = geoData.source_mat;
+        const matData = matName ? this.matLibs[matName] : void 0;
+        if (matData && matData.map_Kd) {
+          const texturePath = StringUtil.normalizePath(
+            this.baseUrl + matData.map_Kd
+          );
+          const texture = Engine3D.res.getTexture(texturePath);
+          if (texture) {
+            mat.baseMap = texture;
+          }
+        }
         let obj = new exports.Object3D();
         let mr = obj.addComponent(exports.MeshRenderer);
         mr.geometry = geo;
@@ -41064,7 +41260,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.19";
+  const version = "1.0.20";
 
   class Engine3D {
     /**

package/dist/types/index.d.ts

@@ -381,9 +381,6 @@ export * from "./loader/LoaderManager";
 export * from "./loader/parser/3dgs/GaussianSplatAsset";
 export * from "./loader/parser/3dgs/GaussianSplatParser";
 export * from "./loader/parser/3dgs/loaders/FormatDetector";
-export * from "./loader/parser/3dgs/loaders/ply/PlyLoader";
-export * from "./loader/parser/3dgs/loaders/ply/PlyTypes";
-export * from "./loader/parser/3dgs/loaders/ply/PlyUtils";
 export * from "./loader/parser/AtlasParser";
 export * from "./loader/parser/B3DMParser";
 export * from "./loader/parser/FontParser";
@@ -429,6 +426,9 @@ export * from "./loader/parser/kmz/dataDef/global";
 export * from "./loader/parser/kmz/dataDef/point";
 export * from "./loader/parser/kmz/dataDef/template";
 export * from "./loader/parser/kmz/dataDef/wayline";
+export * from "./loader/parser/ply/PlyLoader";
+export * from "./loader/parser/ply/PlyTypes";
+export * from "./loader/parser/ply/PlyUtils";
 export * from "./loader/parser/prefab/PrefabAvatarParser";
 export * from "./loader/parser/prefab/PrefabMaterialParser";
 export * from "./loader/parser/prefab/PrefabMeshParser";

package/dist/types/loader/parser/3dgs/loaders/index.d.ts

@@ -7,4 +7,3 @@
  * - KSPLAT: Compressed format (TODO)
  */
 export * from './FormatDetector';
-export * from './ply';

package/dist/types/loader/parser/OBJParser.d.ts

@@ -47,6 +47,8 @@ export declare class OBJParser extends ParserBase {
         [name: string]: GeometryData;
     };
     private activeGeo;
+    private currentObjectName;
+    private currentMaterialName;
     facesMaterialsIndex: {
         materialName: string;
         materialStartIndex: number;
@@ -57,8 +59,28 @@ export declare class OBJParser extends ParserBase {
     private applyVector2;
     private applyVector3;
     private applyVector4;
+    /**
+     * Parse UV index with support for negative indices (OBJ format)
+     * Similar to Three.js parseUVIndex method
+     */
+    private parseUVIndex;
+    /**
+     * Parse vertex index with support for negative indices (OBJ format)
+     */
+    private parseVertexIndex;
+    /**
+     * Parse normal index with support for negative indices (OBJ format)
+     */
+    private parseNormalIndex;
+    /**
+     * Calculate face normal from three vertices using cross product
+     * Similar to Three.js addFaceNormal method
+     */
+    private calculateFaceNormal;
     private loadMTL;
     private load_textures;
+    private getGeometryKey;
+    private ensureActiveGeo;
     private parserLine;
     private parserOBJ;
     private parser_mesh;

package/package.json

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