@galacean/engine-physics-lite 0.9.0 → 0.9.1

package/dist/miniprogram.js

@@ -26236,21 +26236,31 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
         var vertexCount;
         var bufferBindIndex = 0;
         var positions;
-        keepMeshData && (positions = new Array(vertexCount));
+        var boneIndices;
+        var boneWeights;
+        if (keepMeshData) {
+            positions = new Array(vertexCount);
+            boneIndices = new Array(vertexCount);
+            boneWeights = new Array(vertexCount);
+        }
         for(var attribute in attributes){
             var accessor = accessors[attributes[attribute]];
             var accessorBuffer = GLTFUtil.getAccessorBuffer(context, gltf, accessor);
-            var dataElmentSize = GLTFUtil.getAccessorTypeSize(accessor.type);
-            var attributeCount = accessor.count;
+            var dataElementSize = GLTFUtil.getAccessorTypeSize(accessor.type);
+            var accessorCount = accessor.count;
             var vertices = accessorBuffer.data;
             var vertexElement = void 0;
             var meshId = mesh.instanceId;
             var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
-            var elementFormat = GLTFUtil.getElementFormat(accessor.componentType, dataElmentSize, accessor.normalized);
+            var elementNormalized = accessor.normalized;
+            var elementFormat = GLTFUtil.getElementFormat(accessor.componentType, dataElementSize, elementNormalized);
+            var scaleFactor = void 0;
+            elementNormalized && (scaleFactor = GLTFUtil.getNormalizedComponentScale(accessor.componentType));
+            var elementOffset = void 0;
             if (accessorBuffer.interleaved) {
                 var byteOffset = accessor.byteOffset || 0;
                 var stride = accessorBuffer.stride;
-                var elementOffset = byteOffset % stride;
+                elementOffset = byteOffset % stride;
                 if (vertexBindingInfos[meshId] === undefined) {
                     vertexElement = new miniprogram$5.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
                     var vertexBuffer = accessorBuffer.vertexBuffer;
@@ -26265,7 +26275,8 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
                     vertexElement = new miniprogram$5.VertexElement(attribute, elementOffset, elementFormat, vertexBindingInfos[meshId]);
                 }
             } else {
-                vertexElement = new miniprogram$5.VertexElement(attribute, 0, elementFormat, bufferBindIndex);
+                elementOffset = 0;
+                vertexElement = new miniprogram$5.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
                 var vertexBuffer1 = new miniprogram$5.Buffer(engine, miniprogram$5.BufferBindFlag.VertexBuffer, vertices.byteLength, miniprogram$5.BufferUsage.Static);
                 vertexBuffer1.setData(vertices);
                 mesh.setVertexBufferBinding(vertexBuffer1, accessorBuffer.stride, bufferBindIndex);
@@ -26273,35 +26284,60 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
             }
             vertexElements.push(vertexElement);
             if (attribute === "POSITION") {
-                vertexCount = attributeCount;
+                vertexCount = accessorCount;
                 var _mesh_bounds = mesh.bounds, min = _mesh_bounds.min, max = _mesh_bounds.max;
                 if (accessor.min && accessor.max) {
                     min.copyFromArray(accessor.min);
                     max.copyFromArray(accessor.max);
                     if (keepMeshData) {
-                        var stride1 = vertices.length / attributeCount;
-                        for(var j = 0; j < attributeCount; j++){
-                            var offset = j * stride1;
-                            positions[j] = new miniprogram$1$2.Vector3(vertices[offset], vertices[offset + 1], vertices[offset + 2]);
+                        var baseOffset = elementOffset / vertices.BYTES_PER_ELEMENT;
+                        var stride1 = vertices.length / accessorCount;
+                        for(var j = 0; j < accessorCount; j++){
+                            var offset = baseOffset + j * stride1;
+                            var position = new miniprogram$1$2.Vector3(vertices[offset], vertices[offset + 1], vertices[offset + 2]);
+                            elementNormalized && position.scale(scaleFactor);
+                            positions[j] = position;
                         }
                     }
                 } else {
-                    var position = MeshParser._tempVector3;
+                    var position1 = MeshParser._tempVector3;
                     min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
                     max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-                    var stride2 = vertices.length / attributeCount;
-                    for(var j1 = 0; j1 < attributeCount; j1++){
-                        var offset1 = j1 * stride2;
-                        position.copyFromArray(vertices, offset1);
-                        miniprogram$1$2.Vector3.min(min, position, min);
-                        miniprogram$1$2.Vector3.max(max, position, max);
-                        keepMeshData && (positions[j1] = position.clone());
+                    var baseOffset1 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                    var stride2 = vertices.length / accessorCount;
+                    for(var j1 = 0; j1 < accessorCount; j1++){
+                        var offset1 = baseOffset1 + j1 * stride2;
+                        position1.copyFromArray(vertices, offset1);
+                        miniprogram$1$2.Vector3.min(min, position1, min);
+                        miniprogram$1$2.Vector3.max(max, position1, max);
+                        if (keepMeshData) {
+                            var clonePosition = position1.clone();
+                            elementNormalized && clonePosition.scale(scaleFactor);
+                            positions[j1] = clonePosition;
+                        }
                     }
                 }
-                if (accessor.normalized) {
-                    var sacleFactor = GLTFUtil.getNormalizedComponentScale(accessor.componentType);
-                    min.scale(sacleFactor);
-                    max.scale(sacleFactor);
+                if (elementNormalized) {
+                    min.scale(scaleFactor);
+                    max.scale(scaleFactor);
+                }
+            } else if (attribute === "JOINTS_0" && keepMeshData) {
+                var baseOffset2 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                var stride3 = vertices.length / accessorCount;
+                for(var j2 = 0; j2 < accessorCount; j2++){
+                    var offset2 = baseOffset2 + j2 * stride3;
+                    var boneIndex = new miniprogram$1$2.Vector4(vertices[offset2], vertices[offset2 + 1], vertices[offset2 + 2], vertices[offset2 + 3]);
+                    elementNormalized && boneIndex.scale(scaleFactor);
+                    boneIndices[j2] = boneIndex;
+                }
+            } else if (attribute === "WEIGHTS_0" && keepMeshData) {
+                var baseOffset3 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                var stride4 = vertices.length / accessorCount;
+                for(var j3 = 0; j3 < accessorCount; j3++){
+                    var offset3 = baseOffset3 + j3 * stride4;
+                    var boneWeight = new miniprogram$1$2.Vector4(vertices[offset3], vertices[offset3 + 1], vertices[offset3 + 2], vertices[offset3 + 3]);
+                    elementNormalized && boneWeight.scale(scaleFactor);
+                    boneWeights[j3] = boneWeight;
                 }
             }
         }
@@ -26320,6 +26356,10 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
         mesh.uploadData(!keepMeshData);
         //@ts-ignore
         mesh._positions = positions;
+        //@ts-ignore
+        mesh._boneIndices = boneIndices;
+        //@ts-ignore
+        mesh._boneWeights = boneWeights;
         return Promise.resolve(mesh);
     };
     _proto._createBlendShape = function _createBlendShape(mesh, glTFMesh, glTFTargets, getBlendShapeData) {
@@ -35611,7 +35651,7 @@ function _interopNamespace(e) {
 }
 var CoreObjects__namespace = /*#__PURE__*/ _interopNamespace(CoreObjects);
 //@ts-ignore
-var version = "0.9.0";
+var version = "0.9.1";
 console.log("Galacean engine version: " + version);
 for(var key in CoreObjects__namespace){
     CoreObjects.Loader.registerClass(key, CoreObjects__namespace[key]);