@babylonjs/serializers 7.12.0 → 7.13.0

package/glTF/2.0/glTFExporter.js

@@ -67,6 +67,26 @@ function convertNodeHandedness(node) {
         node.scale = scale.asArray();
     }
 }
+function getBinaryWriterFunc(binaryWriter, attributeComponentKind) {
+    switch (attributeComponentKind) {
+        case 5121 /* AccessorComponentType.UNSIGNED_BYTE */: {
+            return binaryWriter.setUInt8.bind(binaryWriter);
+        }
+        case 5123 /* AccessorComponentType.UNSIGNED_SHORT */: {
+            return binaryWriter.setUInt16.bind(binaryWriter);
+        }
+        case 5125 /* AccessorComponentType.UNSIGNED_INT */: {
+            return binaryWriter.setUInt32.bind(binaryWriter);
+        }
+        case 5126 /* AccessorComponentType.FLOAT */: {
+            return binaryWriter.setFloat32.bind(binaryWriter);
+        }
+        default: {
+            Tools.Warn("Unsupported Attribute Component kind: " + attributeComponentKind);
+            return null;
+        }
+    }
+}
 /**
  * Converts Babylon Scene into glTF 2.0.
  * @internal
@@ -600,122 +620,98 @@ export class _Exporter {
                 vertexAttributes = [];
             }
         }
-        let writeBinaryFunc;
-        switch (attributeComponentKind) {
-            case 5121 /* AccessorComponentType.UNSIGNED_BYTE */: {
-                writeBinaryFunc = binaryWriter.setUInt8.bind(binaryWriter);
-                break;
-            }
-            case 5123 /* AccessorComponentType.UNSIGNED_SHORT */: {
-                writeBinaryFunc = binaryWriter.setUInt16.bind(binaryWriter);
-                break;
-            }
-            case 5125 /* AccessorComponentType.UNSIGNED_INT */: {
-                writeBinaryFunc = binaryWriter.setUInt32.bind(binaryWriter);
-                break;
-            }
-            case 5126 /* AccessorComponentType.FLOAT */: {
-                writeBinaryFunc = binaryWriter.setFloat32.bind(binaryWriter);
-                break;
-            }
-            default: {
-                Tools.Warn("Unsupported Attribute Component kind: " + attributeComponentKind);
-                return;
-            }
-        }
-        for (const vertexAttribute of vertexAttributes) {
-            for (const component of vertexAttribute) {
-                writeBinaryFunc(component);
+        const writeBinaryFunc = getBinaryWriterFunc(binaryWriter, attributeComponentKind);
+        if (writeBinaryFunc) {
+            for (const vertexAttribute of vertexAttributes) {
+                for (const component of vertexAttribute) {
+                    writeBinaryFunc(component);
+                }
             }
         }
     }
-    /**
-     * Writes mesh attribute data to a data buffer
-     * Returns the bytelength of the data
-     * @param vertexBufferKind Indicates what kind of vertex data is being passed in
-     * @param attributeComponentKind attribute component type
-     * @param meshPrimitive the mesh primitive
-     * @param meshAttributeArray Array containing the attribute data
-     * @param morphTargetAttributeArray
-     * @param stride Specifies the space between data
-     * @param binaryWriter The buffer to write the binary data to
-     * @param minMax
-     */
-    writeMorphTargetAttributeData(vertexBufferKind, attributeComponentKind, meshPrimitive, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, minMax) {
-        let vertexAttributes = [];
-        let index;
-        let difference = new Vector3();
-        let difference4 = new Vector4(0, 0, 0, 0);
+    _createMorphTargetBufferViewKind(vertexBufferKind, accessorType, attributeComponentKind, mesh, morphTarget, binaryWriter, byteStride) {
+        let vertexCount;
+        let minMax;
+        const morphData = [];
+        const difference = TmpVectors.Vector3[0];
         switch (vertexBufferKind) {
             case VertexBuffer.PositionKind: {
-                for (let k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
-                    index = meshPrimitive.indexStart + k * stride;
-                    const vertexData = Vector3.FromArray(meshAttributeArray, index);
-                    const morphData = Vector3.FromArray(morphTargetAttributeArray, index);
-                    difference = morphData.subtractToRef(vertexData, difference);
-                    if (minMax) {
-                        minMax.min.copyFromFloats(Math.min(difference.x, minMax.min.x), Math.min(difference.y, minMax.min.y), Math.min(difference.z, minMax.min.z));
-                        minMax.max.copyFromFloats(Math.max(difference.x, minMax.max.x), Math.max(difference.y, minMax.max.y), Math.max(difference.z, minMax.max.z));
-                    }
-                    vertexAttributes.push(difference.asArray());
+                const morphPositions = morphTarget.getPositions();
+                if (!morphPositions) {
+                    return null;
+                }
+                const originalPositions = mesh.getVerticesData(VertexBuffer.PositionKind, undefined, undefined, true);
+                const vertexStart = 0;
+                const min = new Vector3(Infinity, Infinity, Infinity);
+                const max = new Vector3(-Infinity, -Infinity, -Infinity);
+                vertexCount = originalPositions.length / 3;
+                for (let i = vertexStart; i < vertexCount; ++i) {
+                    const originalPosition = Vector3.FromArray(originalPositions, i * 3);
+                    const morphPosition = Vector3.FromArray(morphPositions, i * 3);
+                    morphPosition.subtractToRef(originalPosition, difference);
+                    min.copyFromFloats(Math.min(difference.x, min.x), Math.min(difference.y, min.y), Math.min(difference.z, min.z));
+                    max.copyFromFloats(Math.max(difference.x, max.x), Math.max(difference.y, max.y), Math.max(difference.z, max.z));
+                    morphData.push(difference.x, difference.y, difference.z);
                 }
+                minMax = { min, max };
                 break;
             }
             case VertexBuffer.NormalKind: {
-                for (let k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
-                    index = meshPrimitive.indexStart + k * stride;
-                    const vertexData = Vector3.FromArray(meshAttributeArray, index).normalize();
-                    const morphData = Vector3.FromArray(morphTargetAttributeArray, index).normalize();
-                    difference = morphData.subtractToRef(vertexData, difference);
-                    vertexAttributes.push(difference.asArray());
+                const morphNormals = morphTarget.getNormals();
+                if (!morphNormals) {
+                    return null;
+                }
+                const originalNormals = mesh.getVerticesData(VertexBuffer.NormalKind, undefined, undefined, true);
+                const vertexStart = 0;
+                vertexCount = originalNormals.length / 3;
+                for (let i = vertexStart; i < vertexCount; ++i) {
+                    const originalNormal = Vector3.FromArray(originalNormals, i * 3).normalize();
+                    const morphNormal = Vector3.FromArray(morphNormals, i * 3).normalize();
+                    morphNormal.subtractToRef(originalNormal, difference);
+                    morphData.push(difference.x, difference.y, difference.z);
                 }
                 break;
             }
             case VertexBuffer.TangentKind: {
-                for (let k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
-                    index = meshPrimitive.indexStart + k * (stride + 1);
-                    const vertexData = Vector4.FromArray(meshAttributeArray, index);
-                    _GLTFUtilities._NormalizeTangentFromRef(vertexData);
-                    const morphData = Vector4.FromArray(morphTargetAttributeArray, index);
-                    _GLTFUtilities._NormalizeTangentFromRef(morphData);
-                    difference4 = morphData.subtractToRef(vertexData, difference4);
-                    vertexAttributes.push([difference4.x, difference4.y, difference4.z]);
+                const morphTangents = morphTarget.getTangents();
+                if (!morphTangents) {
+                    return null;
+                }
+                // Handedness cannot be displaced, so morph target tangents omit the w component
+                accessorType = "VEC3" /* AccessorType.VEC3 */;
+                byteStride = 12; // 3 components (x/y/z) * 4 bytes (float32)
+                const originalTangents = mesh.getVerticesData(VertexBuffer.TangentKind, undefined, undefined, true);
+                const vertexStart = 0;
+                vertexCount = originalTangents.length / 4;
+                for (let i = vertexStart; i < vertexCount; ++i) {
+                    // Only read the x, y, z components and ignore w
+                    const originalTangent = Vector3.FromArray(originalTangents, i * 4);
+                    _GLTFUtilities._NormalizeTangentFromRef(originalTangent);
+                    // Morph target tangents omit the w component so it won't be present in the data
+                    const morphTangent = Vector3.FromArray(morphTangents, i * 3);
+                    _GLTFUtilities._NormalizeTangentFromRef(morphTangent);
+                    morphTangent.subtractToRef(originalTangent, difference);
+                    morphData.push(difference.x, difference.y, difference.z);
                 }
                 break;
             }
             default: {
-                Tools.Warn("Unsupported Vertex Buffer Type: " + vertexBufferKind);
-                vertexAttributes = [];
+                return null;
             }
         }
-        let writeBinaryFunc;
-        switch (attributeComponentKind) {
-            case 5121 /* AccessorComponentType.UNSIGNED_BYTE */: {
-                writeBinaryFunc = binaryWriter.setUInt8.bind(binaryWriter);
-                break;
-            }
-            case 5123 /* AccessorComponentType.UNSIGNED_SHORT */: {
-                writeBinaryFunc = binaryWriter.setUInt16.bind(binaryWriter);
-                break;
-            }
-            case 5125 /* AccessorComponentType.UNSIGNED_INT */: {
-                writeBinaryFunc = binaryWriter.setUInt32.bind(binaryWriter);
-                break;
-            }
-            case 5126 /* AccessorComponentType.FLOAT */: {
-                writeBinaryFunc = binaryWriter.setFloat32.bind(binaryWriter);
-                break;
-            }
-            default: {
-                Tools.Warn("Unsupported Attribute Component kind: " + attributeComponentKind);
-                return;
-            }
+        const binaryWriterFunc = getBinaryWriterFunc(binaryWriter, attributeComponentKind);
+        if (!binaryWriterFunc) {
+            return null;
         }
-        for (const vertexAttribute of vertexAttributes) {
-            for (const component of vertexAttribute) {
-                writeBinaryFunc(component);
-            }
+        const typeByteLength = VertexBuffer.GetTypeByteLength(attributeComponentKind);
+        const byteLength = morphData.length * typeByteLength;
+        const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, `${vertexBufferKind} - ${morphTarget.name} (Morph Target)`);
+        this._bufferViews.push(bufferView);
+        const bufferViewIndex = this._bufferViews.length - 1;
+        for (const value of morphData) {
+            binaryWriterFunc(value);
         }
+        return { bufferViewIndex, vertexCount, accessorType, minMax };
     }
     /**
      * Generates glTF json data
@@ -1018,68 +1014,6 @@ export class _Exporter {
             }
         }
     }
-    /**
-     * Creates a bufferview based on the vertices type for the Babylon mesh
-     * @param babylonSubMesh The Babylon submesh that the morph target is applied to
-     * @param meshPrimitive
-     * @param babylonMorphTarget the morph target to be exported
-     * @param binaryWriter The buffer to write the bufferview data to
-     */
-    _setMorphTargetAttributes(babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter) {
-        if (babylonMorphTarget) {
-            if (!meshPrimitive.targets) {
-                meshPrimitive.targets = [];
-            }
-            const target = {};
-            const mesh = babylonSubMesh.getMesh();
-            if (babylonMorphTarget.hasNormals) {
-                const vertexNormals = mesh.getVerticesData(VertexBuffer.NormalKind, undefined, undefined, true);
-                const morphNormals = babylonMorphTarget.getNormals();
-                const count = babylonSubMesh.verticesCount;
-                const byteStride = 12; // 3 x 4 byte floats
-                const byteLength = count * byteStride;
-                const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
-                this._bufferViews.push(bufferView);
-                const bufferViewIndex = this._bufferViews.length - 1;
-                const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "NORMAL", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
-                this._accessors.push(accessor);
-                target.NORMAL = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.NormalKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexNormals, morphNormals, byteStride / 4, binaryWriter);
-            }
-            if (babylonMorphTarget.hasPositions) {
-                const vertexPositions = mesh.getVerticesData(VertexBuffer.PositionKind, undefined, undefined, true);
-                const morphPositions = babylonMorphTarget.getPositions();
-                const count = babylonSubMesh.verticesCount;
-                const byteStride = 12; // 3 x 4 byte floats
-                const byteLength = count * byteStride;
-                const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_POSITION");
-                this._bufferViews.push(bufferView);
-                const bufferViewIndex = this._bufferViews.length - 1;
-                const minMax = { min: new Vector3(Infinity, Infinity, Infinity), max: new Vector3(-Infinity, -Infinity, -Infinity) };
-                const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "POSITION", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
-                this._accessors.push(accessor);
-                target.POSITION = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.PositionKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexPositions, morphPositions, byteStride / 4, binaryWriter, minMax);
-                accessor.min = minMax.min.asArray();
-                accessor.max = minMax.max.asArray();
-            }
-            if (babylonMorphTarget.hasTangents) {
-                const vertexTangents = mesh.getVerticesData(VertexBuffer.TangentKind, undefined, undefined, true);
-                const morphTangents = babylonMorphTarget.getTangents();
-                const count = babylonSubMesh.verticesCount;
-                const byteStride = 12; // 3 x 4 byte floats
-                const byteLength = count * byteStride;
-                const bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, babylonMorphTarget.name + "_NORMAL");
-                this._bufferViews.push(bufferView);
-                const bufferViewIndex = this._bufferViews.length - 1;
-                const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "TANGENT", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
-                this._accessors.push(accessor);
-                target.TANGENT = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(VertexBuffer.TangentKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexTangents, morphTangents, byteStride / 4, binaryWriter);
-            }
-            meshPrimitive.targets.push(target);
-        }
-    }
     /**
      * The primitive mode of the Babylon mesh
      * @param babylonMesh The BabylonJS mesh
@@ -1143,46 +1077,46 @@ export class _Exporter {
      * @param meshPrimitive glTF mesh primitive
      * @param attributeKind vertex attribute
      */
-    _setAttributeKind(meshPrimitive, attributeKind) {
+    _setAttributeKind(attributes, attributeKind) {
         switch (attributeKind) {
             case VertexBuffer.PositionKind: {
-                meshPrimitive.attributes.POSITION = this._accessors.length - 1;
+                attributes.POSITION = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.NormalKind: {
-                meshPrimitive.attributes.NORMAL = this._accessors.length - 1;
+                attributes.NORMAL = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.ColorKind: {
-                meshPrimitive.attributes.COLOR_0 = this._accessors.length - 1;
+                attributes.COLOR_0 = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.TangentKind: {
-                meshPrimitive.attributes.TANGENT = this._accessors.length - 1;
+                attributes.TANGENT = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.UVKind: {
-                meshPrimitive.attributes.TEXCOORD_0 = this._accessors.length - 1;
+                attributes.TEXCOORD_0 = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.UV2Kind: {
-                meshPrimitive.attributes.TEXCOORD_1 = this._accessors.length - 1;
+                attributes.TEXCOORD_1 = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.MatricesIndicesKind: {
-                meshPrimitive.attributes.JOINTS_0 = this._accessors.length - 1;
+                attributes.JOINTS_0 = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.MatricesIndicesExtraKind: {
-                meshPrimitive.attributes.JOINTS_1 = this._accessors.length - 1;
+                attributes.JOINTS_1 = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.MatricesWeightsKind: {
-                meshPrimitive.attributes.WEIGHTS_0 = this._accessors.length - 1;
+                attributes.WEIGHTS_0 = this._accessors.length - 1;
                 break;
             }
             case VertexBuffer.MatricesWeightsExtraKind: {
-                meshPrimitive.attributes.WEIGHTS_1 = this._accessors.length - 1;
+                attributes.WEIGHTS_1 = this._accessors.length - 1;
                 break;
             }
             default: {
@@ -1240,6 +1174,20 @@ export class _Exporter {
                     this._createBufferViewKind(attributeKind, attributeComponentKind, babylonTransformNode, binaryWriter, attribute.byteStride);
                     attribute.bufferViewIndex = this._bufferViews.length - 1;
                     vertexAttributeBufferViews[attributeKind] = attribute.bufferViewIndex;
+                    // Write any morph target data to the buffer and create an associated buffer view
+                    if (morphTargetManager) {
+                        for (let i = 0; i < morphTargetManager.numTargets; ++i) {
+                            const morphTarget = morphTargetManager.getTarget(i);
+                            const morphTargetInfo = this._createMorphTargetBufferViewKind(attributeKind, attribute.accessorType, attributeComponentKind, bufferMesh, morphTarget, binaryWriter, attribute.byteStride);
+                            // Store info about the morph target that will be needed later when creating per-submesh accessors
+                            if (morphTargetInfo) {
+                                if (!attribute.morphTargetInfo) {
+                                    attribute.morphTargetInfo = [];
+                                }
+                                attribute.morphTargetInfo[i] = morphTargetInfo;
+                            }
+                        }
+                    }
                 }
             }
             if (bufferMesh.getTotalIndices()) {
@@ -1308,7 +1256,7 @@ export class _Exporter {
                                     }
                                     const accessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, attributeKind + " - " + babylonTransformNode.name, attribute.accessorType, attribute.accessorComponentType, vertexData.length / stride, 0, minMax.min, minMax.max);
                                     this._accessors.push(accessor);
-                                    this._setAttributeKind(meshPrimitive, attributeKind);
+                                    this._setAttributeKind(meshPrimitive.attributes, attributeKind);
                                 }
                             }
                         }
@@ -1347,6 +1295,7 @@ export class _Exporter {
                             meshPrimitive.material = materialIndex;
                         }
                     }
+                    // If there are morph targets, write out targets and associated accessors
                     if (morphTargetManager) {
                         // By convention, morph target names are stored in the mesh extras.
                         if (!mesh.extras) {
@@ -1354,9 +1303,25 @@ export class _Exporter {
                         }
                         mesh.extras.targetNames = [];
                         for (let i = 0; i < morphTargetManager.numTargets; ++i) {
-                            const target = morphTargetManager.getTarget(i);
-                            this._setMorphTargetAttributes(submesh, meshPrimitive, target, binaryWriter);
-                            mesh.extras.targetNames.push(target.name);
+                            const morphTarget = morphTargetManager.getTarget(i);
+                            mesh.extras.targetNames.push(morphTarget.name);
+                            for (const attribute of attributeData) {
+                                const morphTargetInfo = attribute.morphTargetInfo?.[i];
+                                if (morphTargetInfo) {
+                                    // Write the accessor
+                                    const byteOffset = 0;
+                                    const accessor = _GLTFUtilities._CreateAccessor(morphTargetInfo.bufferViewIndex, `${attribute.kind} - ${morphTarget.name} (Morph Target)`, morphTargetInfo.accessorType, attribute.accessorComponentType, morphTargetInfo.vertexCount, byteOffset, morphTargetInfo.minMax?.min?.asArray() ?? null, morphTargetInfo.minMax?.max?.asArray() ?? null);
+                                    this._accessors.push(accessor);
+                                    // Create a target that references the new accessor
+                                    if (!meshPrimitive.targets) {
+                                        meshPrimitive.targets = [];
+                                    }
+                                    if (!meshPrimitive.targets[i]) {
+                                        meshPrimitive.targets[i] = {};
+                                    }
+                                    this._setAttributeKind(meshPrimitive.targets[i], attribute.kind);
+                                }
+                            }
                         }
                     }
                     mesh.primitives.push(meshPrimitive);