@rings-webgpu/core 1.0.19 → 1.0.21

package/dist/rings.es.max.js

@@ -25040,30 +25040,32 @@ class BoundUtil {
   static genGSplatBounds(obj, bound) {
     bound ||= new BoundingBox(Vector3.ZERO, Vector3.ZERO);
     bound.setFromMinMax(this.maxVector, this.minVector);
-    let gsplatRenderer = obj.getComponent(GSplatRenderer);
-    if (!gsplatRenderer) {
+    let gsplatRenderers = obj.getComponents(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) {
@@ -36926,6 +36928,8 @@ class OBJParser extends ParserBase {
   matLibs;
   geometrys;
   activeGeo;
+  currentObjectName;
+  currentMaterialName;
   facesMaterialsIndex;
   mtl;
   mtlUrl;
@@ -36934,26 +36938,35 @@ class OBJParser extends ParserBase {
     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]);
@@ -36961,12 +36974,76 @@ class OBJParser extends ParserBase {
     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("#");
@@ -37017,20 +37094,41 @@ class OBJParser extends ParserBase {
   }
   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);
     }
@@ -37065,33 +37163,30 @@ class OBJParser extends ParserBase {
         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);
@@ -37108,44 +37203,138 @@ class OBJParser extends ParserBase {
       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++;
         }
       }
@@ -37177,10 +37366,17 @@ class OBJParser extends ParserBase {
         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 Object3D();
       let mr = obj.addComponent(MeshRenderer);
       mr.geometry = geo;
@@ -41057,7 +41253,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.19";
+const version = "1.0.20";
 
 class Engine3D {
   /**