@onerjs/loaders 8.26.3 → 8.26.4

package/OBJ/solidParser.d.ts

@@ -94,14 +94,13 @@ export declare class SolidParser {
      * If a tuple of (position, normal) is not set, add the data into the corresponding array
      * If the tuple already exist, add only their indice
      *
-     * @param data The vertex's data
-     * * indicesPositionFromObj: The index in positions array
-     * * indicesUvsFromObj: The index in uvs array
-     * * indicesNormalFromObj: The index in normals array
-     * * positionVectorFromOBJ: The value of position at index objIndice
-     * * textureVectorFromOBJ: The value of uvs
-     * * normalsVectorFromOBJ: The value of normals at index objNormale
-     * * positionColorsFromOBJ: The value of color at index objIndice
+     * @param indicePositionFromObj Integer The index in positions array
+     * @param indiceUvsFromObj Integer The index in uvs array
+     * @param indiceNormalFromObj Integer The index in normals array
+     * @param positionVectorFromOBJ Vector3 The value of position at index objIndice
+     * @param textureVectorFromOBJ Vector3 The value of uvs
+     * @param normalsVectorFromOBJ Vector3 The value of normals at index objNormale
+     * @param positionColorsFromOBJ
      */
     private _setData;
     /**

package/OBJ/solidParser.js

@@ -78,26 +78,22 @@ export class SolidParser {
      * If a tuple of (position, normal) is not set, add the data into the corresponding array
      * If the tuple already exist, add only their indice
      *
-     * @param data The vertex's data
-     * * indicesPositionFromObj: The index in positions array
-     * * indicesUvsFromObj: The index in uvs array
-     * * indicesNormalFromObj: The index in normals array
-     * * positionVectorFromOBJ: The value of position at index objIndice
-     * * textureVectorFromOBJ: The value of uvs
-     * * normalsVectorFromOBJ: The value of normals at index objNormale
-     * * positionColorsFromOBJ: The value of color at index objIndice
+     * @param indicePositionFromObj Integer The index in positions array
+     * @param indiceUvsFromObj Integer The index in uvs array
+     * @param indiceNormalFromObj Integer The index in normals array
+     * @param positionVectorFromOBJ Vector3 The value of position at index objIndice
+     * @param textureVectorFromOBJ Vector3 The value of uvs
+     * @param normalsVectorFromOBJ Vector3 The value of normals at index objNormale
+     * @param positionColorsFromOBJ
      */
-    _setData(data) {
-        //Use default values if undefined
-        data.indiceUvsFromObj ?? (data.indiceUvsFromObj = -1);
-        data.indiceNormalFromObj ?? (data.indiceNormalFromObj = -1);
+    _setData(indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, positionVectorFromOBJ, textureVectorFromOBJ, normalsVectorFromOBJ, positionColorsFromOBJ) {
         //Check if this tuple already exists in the list of tuples
         let _index;
         if (this._loadingOptions.optimizeWithUV) {
-            _index = this._isInArrayUV(this._tuplePosNorm, [data.indicePositionFromObj, data.indiceNormalFromObj, data.indiceUvsFromObj]);
+            _index = this._isInArrayUV(this._tuplePosNorm, [indicePositionFromObj, indiceNormalFromObj, indiceUvsFromObj]);
         }
         else {
-            _index = this._isInArray(this._tuplePosNorm, [data.indicePositionFromObj, data.indiceNormalFromObj]);
+            _index = this._isInArray(this._tuplePosNorm, [indicePositionFromObj, indiceNormalFromObj]);
         }
         //If it not exists
         if (_index === -1) {
@@ -107,27 +103,25 @@ export class SolidParser {
             this._indicesForBabylon.push(this._wrappedPositionForBabylon.length);
             //Push the position of vertice for Babylon
             //Each element is a Vector3(x,y,z)
-            this._wrappedPositionForBabylon.push(data.positionVectorFromOBJ);
-            if (data.textureVectorFromOBJ !== undefined) {
-                //Push the uvs for Babylon
-                //Each element is a Vector2(u,v)
-                this._wrappedUvsForBabylon.push(data.textureVectorFromOBJ);
-            }
-            if (data.normalsVectorFromOBJ !== undefined) {
-                //Push the normals for Babylon
-                //Each element is a Vector3(x,y,z)
-                this._wrappedNormalsForBabylon.push(data.normalsVectorFromOBJ);
-            }
-            if (data.positionColorsFromOBJ !== undefined) {
+            this._wrappedPositionForBabylon.push(positionVectorFromOBJ);
+            //Push the uvs for Babylon
+            //Each element is a Vector2(u,v)
+            //If the UVs are missing, set (u,v)=(0,0)
+            textureVectorFromOBJ = textureVectorFromOBJ ?? new Vector2(0, 0);
+            this._wrappedUvsForBabylon.push(textureVectorFromOBJ);
+            //Push the normals for Babylon
+            //Each element is a Vector3(x,y,z)
+            this._wrappedNormalsForBabylon.push(normalsVectorFromOBJ);
+            if (positionColorsFromOBJ !== undefined) {
                 //Push the colors for Babylon
                 //Each element is a BABYLON.Color4(r,g,b,a)
-                this._wrappedColorsForBabylon.push(data.positionColorsFromOBJ);
+                this._wrappedColorsForBabylon.push(positionColorsFromOBJ);
             }
             //Add the tuple in the comparison list
-            this._tuplePosNorm[data.indicePositionFromObj].normals.push(data.indiceNormalFromObj);
-            this._tuplePosNorm[data.indicePositionFromObj].idx.push(this._curPositionInIndices++);
+            this._tuplePosNorm[indicePositionFromObj].normals.push(indiceNormalFromObj);
+            this._tuplePosNorm[indicePositionFromObj].idx.push(this._curPositionInIndices++);
             if (this._loadingOptions.optimizeWithUV) {
-                this._tuplePosNorm[data.indicePositionFromObj].uv.push(data.indiceUvsFromObj);
+                this._tuplePosNorm[indicePositionFromObj].uv.push(indiceUvsFromObj);
             }
         }
         else {
@@ -146,13 +140,9 @@ export class SolidParser {
             for (let l = 0; l < this._wrappedPositionForBabylon.length; l++) {
                 //Push the x, y, z values of each element in the unwrapped array
                 this._unwrappedPositionsForBabylon.push(this._wrappedPositionForBabylon[l].x * this._handednessSign, this._wrappedPositionForBabylon[l].y, this._wrappedPositionForBabylon[l].z);
-                if (this._wrappedNormalsForBabylon.length) {
-                    this._unwrappedNormalsForBabylon.push(this._wrappedNormalsForBabylon[l].x * this._handednessSign, this._wrappedNormalsForBabylon[l].y, this._wrappedNormalsForBabylon[l].z);
-                }
-                if (this._wrappedUvsForBabylon.length) {
-                    this._unwrappedUVForBabylon.push(this._wrappedUvsForBabylon[l].x, this._wrappedUvsForBabylon[l].y); //z is an optional value not supported by BABYLON
-                }
-                if (this._unwrappedColorsForBabylon.length) {
+                this._unwrappedNormalsForBabylon.push(this._wrappedNormalsForBabylon[l].x * this._handednessSign, this._wrappedNormalsForBabylon[l].y, this._wrappedNormalsForBabylon[l].z);
+                this._unwrappedUVForBabylon.push(this._wrappedUvsForBabylon[l].x, this._wrappedUvsForBabylon[l].y); //z is an optional value not supported by BABYLON
+                if (this._loadingOptions.importVertexColors) {
                     //Push the r, g, b, a values of each element in the unwrapped array
                     this._unwrappedColorsForBabylon.push(this._wrappedColorsForBabylon[l].r, this._wrappedColorsForBabylon[l].g, this._wrappedColorsForBabylon[l].b, this._wrappedColorsForBabylon[l].a);
                 }
@@ -222,11 +212,10 @@ export class SolidParser {
         for (let k = 0; k < this._triangles.length; k++) {
             // Set position indice
             const indicePositionFromObj = parseInt(this._triangles[k]) - 1;
-            this._setData({
-                indicePositionFromObj,
-                positionVectorFromOBJ: this._positions[indicePositionFromObj],
-                positionColorsFromOBJ: this._getColor(indicePositionFromObj),
-            });
+            this._setData(indicePositionFromObj, 0, 0, // In the pattern 1, normals and uvs are not defined
+            this._positions[indicePositionFromObj], // Get the vectors data
+            Vector2.Zero(), Vector3.Up(), // Create default vectors
+            this._getColor(indicePositionFromObj));
         }
         //Reset variable for the next line
         this._triangles.length = 0;
@@ -248,13 +237,10 @@ export class SolidParser {
             const indicePositionFromObj = parseInt(point[0]) - 1;
             //Set uv indice
             const indiceUvsFromObj = parseInt(point[1]) - 1;
-            this._setData({
-                indicePositionFromObj,
-                indiceUvsFromObj,
-                positionVectorFromOBJ: this._positions[indicePositionFromObj],
-                textureVectorFromOBJ: this._uvs[indiceUvsFromObj],
-                positionColorsFromOBJ: this._getColor(indicePositionFromObj),
-            });
+            this._setData(indicePositionFromObj, indiceUvsFromObj, 0, //Default value for normals
+            this._positions[indicePositionFromObj], //Get the values for each element
+            this._uvs[indiceUvsFromObj] ?? Vector2.Zero(), Vector3.Up(), //Default value for normals
+            this._getColor(indicePositionFromObj));
         }
         //Reset variable for the next line
         this._triangles.length = 0;
@@ -278,14 +264,8 @@ export class SolidParser {
             const indiceUvsFromObj = parseInt(point[1]) - 1;
             // Set normal indice
             const indiceNormalFromObj = parseInt(point[2]) - 1;
-            this._setData({
-                indicePositionFromObj,
-                indiceUvsFromObj,
-                indiceNormalFromObj,
-                positionVectorFromOBJ: this._positions[indicePositionFromObj],
-                textureVectorFromOBJ: this._uvs[indiceUvsFromObj],
-                normalsVectorFromOBJ: this._normals[indiceNormalFromObj],
-            });
+            this._setData(indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, this._positions[indicePositionFromObj], this._uvs[indiceUvsFromObj] ?? Vector2.Zero(), this._normals[indiceNormalFromObj] ?? Vector3.Up() //Set the vector for each component
+            );
         }
         //Reset variable for the next line
         this._triangles.length = 0;
@@ -305,13 +285,9 @@ export class SolidParser {
             // We check indices, and normals
             const indicePositionFromObj = parseInt(point[0]) - 1;
             const indiceNormalFromObj = parseInt(point[1]) - 1;
-            this._setData({
-                indicePositionFromObj,
-                indiceNormalFromObj,
-                positionVectorFromOBJ: this._positions[indicePositionFromObj],
-                normalsVectorFromOBJ: this._normals[indiceNormalFromObj],
-                positionColorsFromOBJ: this._getColor(indicePositionFromObj),
-            });
+            this._setData(indicePositionFromObj, 1, //Default value for uv
+            indiceNormalFromObj, this._positions[indicePositionFromObj], //Get each vector of data
+            Vector2.Zero(), this._normals[indiceNormalFromObj], this._getColor(indicePositionFromObj));
         }
         //Reset variable for the next line
         this._triangles.length = 0;
@@ -335,15 +311,8 @@ export class SolidParser {
             const indiceUvsFromObj = this._uvs.length + parseInt(point[1]);
             // Set normal indice
             const indiceNormalFromObj = this._normals.length + parseInt(point[2]);
-            this._setData({
-                indicePositionFromObj,
-                indiceUvsFromObj,
-                indiceNormalFromObj,
-                positionVectorFromOBJ: this._positions[indicePositionFromObj],
-                textureVectorFromOBJ: this._uvs[indiceUvsFromObj],
-                normalsVectorFromOBJ: this._normals[indiceNormalFromObj],
-                positionColorsFromOBJ: this._getColor(indicePositionFromObj),
-            });
+            this._setData(indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, this._positions[indicePositionFromObj], this._uvs[indiceUvsFromObj], this._normals[indiceNormalFromObj], //Set the vector for each component
+            this._getColor(indicePositionFromObj));
         }
         //Reset variable for the next line
         this._triangles.length = 0;
@@ -364,16 +333,12 @@ export class SolidParser {
             //Slice the array to avoid rewriting because of the fact this is the same var which be rewrited
             this._handledMesh.indices = this._indicesForBabylon.slice();
             this._handledMesh.positions = this._unwrappedPositionsForBabylon.slice();
-            if (this._unwrappedNormalsForBabylon.length) {
-                this._handledMesh.normals = this._unwrappedNormalsForBabylon.slice();
-            }
-            if (this._unwrappedUVForBabylon.length) {
-                this._handledMesh.uvs = this._unwrappedUVForBabylon.slice();
-            }
-            if (this._unwrappedColorsForBabylon.length) {
+            this._handledMesh.normals = this._unwrappedNormalsForBabylon.slice();
+            this._handledMesh.uvs = this._unwrappedUVForBabylon.slice();
+            this._handledMesh.hasLines = this._hasLineData;
+            if (this._loadingOptions.importVertexColors) {
                 this._handledMesh.colors = this._unwrappedColorsForBabylon.slice();
             }
-            this._handledMesh.hasLines = this._hasLineData;
             //Reset the array for the next mesh
             this._indicesForBabylon.length = 0;
             this._unwrappedPositionsForBabylon.length = 0;
@@ -712,16 +677,12 @@ export class SolidParser {
             //Set array
             this._handledMesh.indices = this._indicesForBabylon;
             this._handledMesh.positions = this._unwrappedPositionsForBabylon;
-            if (this._unwrappedNormalsForBabylon.length) {
-                this._handledMesh.normals = this._unwrappedNormalsForBabylon;
-            }
-            if (this._unwrappedUVForBabylon.length) {
-                this._handledMesh.uvs = this._unwrappedUVForBabylon;
-            }
-            if (this._unwrappedColorsForBabylon.length) {
+            this._handledMesh.normals = this._unwrappedNormalsForBabylon;
+            this._handledMesh.uvs = this._unwrappedUVForBabylon;
+            this._handledMesh.hasLines = this._hasLineData;
+            if (this._loadingOptions.importVertexColors) {
                 this._handledMesh.colors = this._unwrappedColorsForBabylon;
             }
-            this._handledMesh.hasLines = this._hasLineData;
         }
         // If any o or g keyword not found, create a mesh with a random id
         if (!this._hasMeshes) {
@@ -834,10 +795,10 @@ export class SolidParser {
             }
             const vertexData = new VertexData(); //The container for the values
             //Set the data for the babylonMesh
+            vertexData.uvs = this._handledMesh.uvs;
             vertexData.indices = this._handledMesh.indices;
             vertexData.positions = this._handledMesh.positions;
-            if (this._loadingOptions.computeNormals || !this._handledMesh.normals) {
-                // Compute normals if requested or if normals are not defined
+            if (this._loadingOptions.computeNormals) {
                 const normals = new Array();
                 VertexData.ComputeNormals(this._handledMesh.positions, this._handledMesh.indices, normals);
                 vertexData.normals = normals;
@@ -845,10 +806,7 @@ export class SolidParser {
             else {
                 vertexData.normals = this._handledMesh.normals;
             }
-            if (this._handledMesh.uvs) {
-                vertexData.uvs = this._handledMesh.uvs;
-            }
-            if (this._handledMesh.colors) {
+            if (this._loadingOptions.importVertexColors) {
                 vertexData.colors = this._handledMesh.colors;
             }
             //Set the data from the VertexBuffer to the current Mesh