@babylonjs/core 5.0.0-beta.9 → 5.0.0-rc.0

package/Meshes/mesh.vertexData.d.ts

@@ -206,7 +206,7 @@ export declare class VertexData {
      */
     merge(others: VertexData | VertexData[], use32BitsIndices?: boolean): VertexData;
     /** @hidden */
-    _mergeCoroutine(others: VertexData | VertexData[], use32BitsIndices: boolean | undefined, isAsync: boolean): Coroutine<VertexData>;
+    _mergeCoroutine(transform: Matrix | undefined, vertexDatas: (readonly [vertexData: VertexData, transform?: Matrix])[], use32BitsIndices: boolean | undefined, isAsync: boolean): Coroutine<VertexData>;
     private static _mergeElement;
     private _validate;
     /**

package/Meshes/mesh.vertexData.js

@@ -293,10 +293,12 @@ var VertexData = /** @class */ (function () {
         }
         return this;
     };
-    VertexData._TransformVector3Coordinates = function (coordinates, transformation) {
+    VertexData._TransformVector3Coordinates = function (coordinates, transformation, offset, length) {
+        if (offset === void 0) { offset = 0; }
+        if (length === void 0) { length = coordinates.length; }
         var coordinate = TmpVectors.Vector3[0];
         var transformedCoordinate = TmpVectors.Vector3[1];
-        for (var index = 0; index < coordinates.length; index += 3) {
+        for (var index = offset; index < offset + length; index += 3) {
             Vector3.FromArrayToRef(coordinates, index, coordinate);
             Vector3.TransformCoordinatesToRef(coordinate, transformation, transformedCoordinate);
             coordinates[index] = transformedCoordinate.x;
@@ -304,10 +306,12 @@ var VertexData = /** @class */ (function () {
             coordinates[index + 2] = transformedCoordinate.z;
         }
     };
-    VertexData._TransformVector3Normals = function (normals, transformation) {
+    VertexData._TransformVector3Normals = function (normals, transformation, offset, length) {
+        if (offset === void 0) { offset = 0; }
+        if (length === void 0) { length = normals.length; }
         var normal = TmpVectors.Vector3[0];
         var transformedNormal = TmpVectors.Vector3[1];
-        for (var index = 0; index < normals.length; index += 3) {
+        for (var index = offset; index < offset + length; index += 3) {
             Vector3.FromArrayToRef(normals, index, normal);
             Vector3.TransformNormalToRef(normal, transformation, transformedNormal);
             normals[index] = transformedNormal.x;
@@ -315,10 +319,12 @@ var VertexData = /** @class */ (function () {
             normals[index + 2] = transformedNormal.z;
         }
     };
-    VertexData._TransformVector4Normals = function (normals, transformation) {
+    VertexData._TransformVector4Normals = function (normals, transformation, offset, length) {
+        if (offset === void 0) { offset = 0; }
+        if (length === void 0) { length = normals.length; }
         var normal = TmpVectors.Vector4[0];
         var transformedNormal = TmpVectors.Vector4[1];
-        for (var index = 0; index < normals.length; index += 4) {
+        for (var index = offset; index < offset + length; index += 4) {
             Vector4.FromArrayToRef(normals, index, normal);
             Vector4.TransformNormalToRef(normal, transformation, transformedNormal);
             normals[index] = transformedNormal.x;
@@ -327,8 +333,10 @@ var VertexData = /** @class */ (function () {
             normals[index + 3] = transformedNormal.w;
         }
     };
-    VertexData._FlipFaces = function (indices) {
-        for (var index = 0; index < indices.length; index += 3) {
+    VertexData._FlipFaces = function (indices, offset, length) {
+        if (offset === void 0) { offset = 0; }
+        if (length === void 0) { length = indices.length; }
+        for (var index = offset; index < offset + length; index += 3) {
             var tmp = indices[index + 1];
             indices[index + 1] = indices[index + 2];
             indices[index + 2] = tmp;
@@ -363,18 +371,19 @@ var VertexData = /** @class */ (function () {
      */
     VertexData.prototype.merge = function (others, use32BitsIndices) {
         if (use32BitsIndices === void 0) { use32BitsIndices = false; }
-        return runCoroutineSync(this._mergeCoroutine(others, use32BitsIndices, false));
+        var vertexDatas = Array.isArray(others) ? others.map(function (other) { return [other, undefined]; }) : [[others, undefined]];
+        return runCoroutineSync(this._mergeCoroutine(undefined, vertexDatas, use32BitsIndices, false));
     };
     /** @hidden */
-    VertexData.prototype._mergeCoroutine = function (others, use32BitsIndices, isAsync) {
-        var _i, others_1, other, totalIndices, indicesOffset, temp, positionsOffset, _a, others_2, other, index;
-        var _b, _c, _d, _e;
+    VertexData.prototype._mergeCoroutine = function (transform, vertexDatas, use32BitsIndices, isAsync) {
+        var others, _i, others_1, other, totalIndices, indicesOffset, temp, positionsOffset, _a, vertexDatas_1, _b, other, transform_1, index;
+        var _c, _d, _e, _f;
         if (use32BitsIndices === void 0) { use32BitsIndices = false; }
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        return __generator(this, function (_g) {
+            switch (_g.label) {
                 case 0:
                     this._validate();
-                    others = Array.isArray(others) ? others : [others];
+                    others = vertexDatas.map(function (vertexData) { return vertexData[0]; });
                     for (_i = 0, others_1 = others; _i < others_1.length; _i++) {
                         other = others_1[_i];
                         other._validate();
@@ -394,9 +403,9 @@ var VertexData = /** @class */ (function () {
                             throw new Error("Cannot merge vertex data that do not have the same set of attributes");
                         }
                     }
-                    totalIndices = others.reduce(function (indexSum, vertexData) { var _a, _b; return indexSum + ((_b = (_a = vertexData.indices) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0); }, (_c = (_b = this.indices) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0);
+                    totalIndices = others.reduce(function (indexSum, vertexData) { var _a, _b; return indexSum + ((_b = (_a = vertexData.indices) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0); }, (_d = (_c = this.indices) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0);
                     if (!(totalIndices > 0)) return [3 /*break*/, 4];
-                    indicesOffset = (_e = (_d = this.indices) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+                    indicesOffset = (_f = (_e = this.indices) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
                     if (!this.indices) {
                         this.indices = new Array(totalIndices);
                     }
@@ -409,143 +418,155 @@ var VertexData = /** @class */ (function () {
                             temp.set(this.indices);
                             this.indices = temp;
                         }
+                        if (transform && transform.determinant() < 0) {
+                            VertexData._FlipFaces(this.indices, 0, indicesOffset);
+                        }
                     }
                     positionsOffset = this.positions ? this.positions.length / 3 : 0;
-                    _a = 0, others_2 = others;
-                    _f.label = 1;
+                    _a = 0, vertexDatas_1 = vertexDatas;
+                    _g.label = 1;
                 case 1:
-                    if (!(_a < others_2.length)) return [3 /*break*/, 4];
-                    other = others_2[_a];
+                    if (!(_a < vertexDatas_1.length)) return [3 /*break*/, 4];
+                    _b = vertexDatas_1[_a], other = _b[0], transform_1 = _b[1];
                     if (!other.indices) return [3 /*break*/, 3];
                     for (index = 0; index < other.indices.length; index++) {
                         this.indices[indicesOffset + index] = other.indices[index] + positionsOffset;
                     }
+                    if (transform_1 && transform_1.determinant() < 0) {
+                        VertexData._FlipFaces(this.indices, indicesOffset, other.indices.length);
+                    }
                     // The call to _validate already checked for positions
                     positionsOffset += other.positions.length / 3;
                     indicesOffset += other.indices.length;
                     if (!isAsync) return [3 /*break*/, 3];
                     return [4 /*yield*/];
                 case 2:
-                    _f.sent();
-                    _f.label = 3;
+                    _g.sent();
+                    _g.label = 3;
                 case 3:
                     _a++;
                     return [3 /*break*/, 1];
                 case 4:
-                    this.positions = VertexData._mergeElement(this.positions, others.map(function (other) { return other.positions; }));
+                    this.positions = VertexData._mergeElement(VertexBuffer.PositionKind, this.positions, transform, vertexDatas.map(function (other) { return [other[0].positions, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 6];
                     return [4 /*yield*/];
                 case 5:
-                    _f.sent();
-                    _f.label = 6;
+                    _g.sent();
+                    _g.label = 6;
                 case 6:
-                    this.normals = VertexData._mergeElement(this.normals, others.map(function (other) { return other.normals; }));
+                    this.normals = VertexData._mergeElement(VertexBuffer.NormalKind, this.normals, transform, vertexDatas.map(function (other) { return [other[0].normals, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 8];
                     return [4 /*yield*/];
                 case 7:
-                    _f.sent();
-                    _f.label = 8;
+                    _g.sent();
+                    _g.label = 8;
                 case 8:
-                    this.tangents = VertexData._mergeElement(this.tangents, others.map(function (other) { return other.tangents; }));
+                    this.tangents = VertexData._mergeElement(VertexBuffer.TangentKind, this.tangents, transform, vertexDatas.map(function (other) { return [other[0].tangents, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 10];
                     return [4 /*yield*/];
                 case 9:
-                    _f.sent();
-                    _f.label = 10;
+                    _g.sent();
+                    _g.label = 10;
                 case 10:
-                    this.uvs = VertexData._mergeElement(this.uvs, others.map(function (other) { return other.uvs; }));
+                    this.uvs = VertexData._mergeElement(VertexBuffer.UVKind, this.uvs, transform, vertexDatas.map(function (other) { return [other[0].uvs, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 12];
                     return [4 /*yield*/];
                 case 11:
-                    _f.sent();
-                    _f.label = 12;
+                    _g.sent();
+                    _g.label = 12;
                 case 12:
-                    this.uvs2 = VertexData._mergeElement(this.uvs2, others.map(function (other) { return other.uvs2; }));
+                    this.uvs2 = VertexData._mergeElement(VertexBuffer.UV2Kind, this.uvs2, transform, vertexDatas.map(function (other) { return [other[0].uvs2, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 14];
                     return [4 /*yield*/];
                 case 13:
-                    _f.sent();
-                    _f.label = 14;
+                    _g.sent();
+                    _g.label = 14;
                 case 14:
-                    this.uvs3 = VertexData._mergeElement(this.uvs3, others.map(function (other) { return other.uvs3; }));
+                    this.uvs3 = VertexData._mergeElement(VertexBuffer.UV3Kind, this.uvs3, transform, vertexDatas.map(function (other) { return [other[0].uvs3, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 16];
                     return [4 /*yield*/];
                 case 15:
-                    _f.sent();
-                    _f.label = 16;
+                    _g.sent();
+                    _g.label = 16;
                 case 16:
-                    this.uvs4 = VertexData._mergeElement(this.uvs4, others.map(function (other) { return other.uvs4; }));
+                    this.uvs4 = VertexData._mergeElement(VertexBuffer.UV4Kind, this.uvs4, transform, vertexDatas.map(function (other) { return [other[0].uvs4, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 18];
                     return [4 /*yield*/];
                 case 17:
-                    _f.sent();
-                    _f.label = 18;
+                    _g.sent();
+                    _g.label = 18;
                 case 18:
-                    this.uvs5 = VertexData._mergeElement(this.uvs5, others.map(function (other) { return other.uvs5; }));
+                    this.uvs5 = VertexData._mergeElement(VertexBuffer.UV5Kind, this.uvs5, transform, vertexDatas.map(function (other) { return [other[0].uvs5, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 20];
                     return [4 /*yield*/];
                 case 19:
-                    _f.sent();
-                    _f.label = 20;
+                    _g.sent();
+                    _g.label = 20;
                 case 20:
-                    this.uvs6 = VertexData._mergeElement(this.uvs6, others.map(function (other) { return other.uvs6; }));
+                    this.uvs6 = VertexData._mergeElement(VertexBuffer.UV6Kind, this.uvs6, transform, vertexDatas.map(function (other) { return [other[0].uvs6, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 22];
                     return [4 /*yield*/];
                 case 21:
-                    _f.sent();
-                    _f.label = 22;
+                    _g.sent();
+                    _g.label = 22;
                 case 22:
-                    this.colors = VertexData._mergeElement(this.colors, others.map(function (other) { return other.colors; }));
+                    this.colors = VertexData._mergeElement(VertexBuffer.ColorKind, this.colors, transform, vertexDatas.map(function (other) { return [other[0].colors, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 24];
                     return [4 /*yield*/];
                 case 23:
-                    _f.sent();
-                    _f.label = 24;
+                    _g.sent();
+                    _g.label = 24;
                 case 24:
-                    this.matricesIndices = VertexData._mergeElement(this.matricesIndices, others.map(function (other) { return other.matricesIndices; }));
+                    this.matricesIndices = VertexData._mergeElement(VertexBuffer.MatricesIndicesKind, this.matricesIndices, transform, vertexDatas.map(function (other) { return [other[0].matricesIndices, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 26];
                     return [4 /*yield*/];
                 case 25:
-                    _f.sent();
-                    _f.label = 26;
+                    _g.sent();
+                    _g.label = 26;
                 case 26:
-                    this.matricesWeights = VertexData._mergeElement(this.matricesWeights, others.map(function (other) { return other.matricesWeights; }));
+                    this.matricesWeights = VertexData._mergeElement(VertexBuffer.MatricesWeightsKind, this.matricesWeights, transform, vertexDatas.map(function (other) { return [other[0].matricesWeights, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 28];
                     return [4 /*yield*/];
                 case 27:
-                    _f.sent();
-                    _f.label = 28;
+                    _g.sent();
+                    _g.label = 28;
                 case 28:
-                    this.matricesIndicesExtra = VertexData._mergeElement(this.matricesIndicesExtra, others.map(function (other) { return other.matricesIndicesExtra; }));
+                    this.matricesIndicesExtra = VertexData._mergeElement(VertexBuffer.MatricesIndicesExtraKind, this.matricesIndicesExtra, transform, vertexDatas.map(function (other) { return [other[0].matricesIndicesExtra, other[1]]; }));
                     if (!isAsync) return [3 /*break*/, 30];
                     return [4 /*yield*/];
                 case 29:
-                    _f.sent();
-                    _f.label = 30;
+                    _g.sent();
+                    _g.label = 30;
                 case 30:
-                    this.matricesWeightsExtra = VertexData._mergeElement(this.matricesWeightsExtra, others.map(function (other) { return other.matricesWeightsExtra; }));
+                    this.matricesWeightsExtra = VertexData._mergeElement(VertexBuffer.MatricesWeightsExtraKind, this.matricesWeightsExtra, transform, vertexDatas.map(function (other) { return [other[0].matricesWeightsExtra, other[1]]; }));
                     return [2 /*return*/, this];
             }
         });
     };
-    VertexData._mergeElement = function (source, others) {
-        var nonNullOthers = others.filter(function (other) { return other !== null && other !== undefined; });
+    VertexData._mergeElement = function (kind, source, transform, others) {
+        var nonNullOthers = others.filter(function (other) { return other[0] !== null && other[0] !== undefined; });
         if (nonNullOthers.length === 0) {
             return source;
         }
         if (!source) {
-            return this._mergeElement(nonNullOthers[0], nonNullOthers.slice(1));
+            return this._mergeElement(kind, nonNullOthers[0][0], nonNullOthers[0][1], nonNullOthers.slice(1));
         }
-        var len = nonNullOthers.reduce(function (sumLen, elements) { return sumLen + elements.length; }, source.length);
+        var len = nonNullOthers.reduce(function (sumLen, elements) { return sumLen + elements[0].length; }, source.length);
+        var transformRange = kind === VertexBuffer.PositionKind ? VertexData._TransformVector3Coordinates :
+            kind === VertexBuffer.NormalKind ? VertexData._TransformVector3Normals :
+                kind === VertexBuffer.TangentKind ? VertexData._TransformVector4Normals :
+                    function () { };
         if (source instanceof Float32Array) {
             // use non-loop method when the source is Float32Array
             var ret32 = new Float32Array(len);
             ret32.set(source);
+            transform && transformRange(ret32, transform, 0, source.length);
             var offset = source.length;
             for (var _i = 0, nonNullOthers_1 = nonNullOthers; _i < nonNullOthers_1.length; _i++) {
-                var other = nonNullOthers_1[_i];
-                ret32.set(other, offset);
-                offset += other.length;
+                var _a = nonNullOthers_1[_i], vertexData = _a[0], transform_2 = _a[1];
+                ret32.set(vertexData, offset);
+                transform_2 && transformRange(ret32, transform_2, offset, vertexData.length);
+                offset += vertexData.length;
             }
             return ret32;
         }
@@ -555,13 +576,15 @@ var VertexData = /** @class */ (function () {
             for (var i = 0; i < source.length; i++) {
                 ret[i] = source[i];
             }
+            transform && transformRange(ret, transform, 0, source.length);
             var offset = source.length;
-            for (var _a = 0, nonNullOthers_2 = nonNullOthers; _a < nonNullOthers_2.length; _a++) {
-                var other = nonNullOthers_2[_a];
-                for (var i = 0; i < other.length; i++) {
-                    ret[offset + i] = other[i];
+            for (var _b = 0, nonNullOthers_2 = nonNullOthers; _b < nonNullOthers_2.length; _b++) {
+                var _c = nonNullOthers_2[_b], vertexData = _c[0], transform_3 = _c[1];
+                for (var i = 0; i < vertexData.length; i++) {
+                    ret[offset + i] = vertexData[i];
                 }
-                offset += other.length;
+                transform_3 && transformRange(ret, transform_3, offset, vertexData.length);
+                offset += vertexData.length;
             }
             return ret;
         }