@galacean/engine 0.9.0 → 0.9.2

package/dist/browser.js

@@ -17730,6 +17730,7 @@
         var SkinnedMeshRenderer = function SkinnedMeshRenderer(entity) {
             var _this;
             _this = MeshRenderer.call(this, entity) || this;
+            _this._supportSkinning = false;
             _this._hasInitSkin = false;
             _this._jointDataCreateCache = new Vector2(-1, -1);
             _this._localBounds = new BoundingBox();
@@ -17739,7 +17740,7 @@
             // Limit size to 256 to avoid some problem:
             // For renderer is "Apple GPU", when uniform is large than 256 the skeleton matrix array access in shader very slow in Safari or WKWebview. This may be a apple bug, Chrome and Firefox is OK!
             // For renderer is "ANGLE (AMD, AMD Radeon(TM) Graphics Direct3011 vs_5_0 ps_5_0, D3011)", compile shader si very slow because of max uniform is 4096.
-            maxVertexUniformVectors = Math.min(maxVertexUniformVectors, 256);
+            maxVertexUniformVectors = Math.min(maxVertexUniformVectors, rhi._options._maxAllowSkinUniformVectorCount);
             _this._maxVertexUniformVectors = maxVertexUniformVectors;
             _this._onLocalBoundsChanged = _this._onLocalBoundsChanged.bind(_assert_this_initialized(_this));
             var localBounds = _this._localBounds;
@@ -17758,9 +17759,8 @@
                 this._initSkin();
                 this._hasInitSkin = true;
             }
-            var skin = this._skin;
-            if (skin) {
-                var ibms = skin.inverseBindMatrices;
+            if (this._supportSkinning) {
+                var ibms = this._skin.inverseBindMatrices;
                 var worldToLocal = this._rootBone.getInvModelMatrix();
                 var _this = this, joints = _this._jointEntities, jointMatrices = _this._jointMatrices;
                 for(var i = joints.length - 1; i >= 0; i--){
@@ -17779,8 +17779,6 @@
        * @override
        */ _proto._updateShaderData = function _updateShaderData(context) {
             var entity = this.entity;
-            var worldMatrix = this._rootBone ? this._rootBone.transform.worldMatrix : entity.transform.worldMatrix;
-            this._updateTransformShaderData(context, worldMatrix);
             var shaderData = this.shaderData;
             var mesh = this.mesh;
             var blendShapeManager = mesh._blendShapeManager;
@@ -17807,12 +17805,18 @@
                             shaderData.disableMacro("O3_JOINTS_NUM");
                             shaderData.enableMacro("O3_USE_JOINT_TEXTURE");
                             shaderData.setTexture(SkinnedMeshRenderer._jointSamplerProperty, this._jointTexture);
+                            this._supportSkinning = true;
                         } else {
-                            Logger.error("component's joints count(" + jointCount + ") greater than device's MAX_VERTEX_UNIFORM_VECTORS number " + this._maxVertexUniformVectors + ", and don't support jointTexture in this device. suggest joint count less than " + remainUniformJointCount + ".", this);
+                            var _this__jointTexture1;
+                            this._supportSkinning = false;
+                            (_this__jointTexture1 = this._jointTexture) == null ? void 0 : _this__jointTexture1.destroy();
+                            shaderData.disableMacro("O3_HAS_SKIN");
+                            Logger.warn("component's joints count(" + jointCount + ") greater than device's MAX_VERTEX_UNIFORM_VECTORS number " + this._maxVertexUniformVectors + ", and don't support jointTexture in this device. suggest joint count less than " + remainUniformJointCount + ".", this);
                         }
                     } else {
-                        var _this__jointTexture1;
-                        (_this__jointTexture1 = this._jointTexture) == null ? void 0 : _this__jointTexture1.destroy();
+                        var _this__jointTexture2;
+                        this._supportSkinning = true;
+                        (_this__jointTexture2 = this._jointTexture) == null ? void 0 : _this__jointTexture2.destroy();
                         shaderData.disableMacro("O3_USE_JOINT_TEXTURE");
                         shaderData.enableMacro("O3_JOINTS_NUM", remainUniformJointCount.toString());
                         shaderData.setFloatArray(SkinnedMeshRenderer._jointMatrixProperty, this._jointMatrices);
@@ -17823,6 +17827,8 @@
                     this._jointTexture.setPixelBuffer(this._jointMatrices);
                 }
             }
+            var worldMatrix = this._supportSkinning && this._rootBone ? this._rootBone.transform.worldMatrix : entity.transform.worldMatrix;
+            this._updateTransformShaderData(context, worldMatrix);
             var layer = entity.layer;
             this._rendererLayer.set(layer & 65535, layer >>> 16 & 65535, 0, 0);
         };
@@ -18017,6 +18023,9 @@
     (function() {
         SkinnedMeshRenderer._jointMatrixProperty = Shader.getPropertyByName("u_jointMatrix");
     })();
+    __decorate$1([
+        ignoreClone
+    ], SkinnedMeshRenderer.prototype, "_supportSkinning", void 0);
     __decorate$1([
         ignoreClone
     ], SkinnedMeshRenderer.prototype, "_hasInitSkin", void 0);
@@ -31040,7 +31049,8 @@
                 webGLMode: 0,
                 alpha: false,
                 stencil: true,
-                _forceFlush: false
+                _forceFlush: false,
+                _maxAllowSkinUniformVectorCount: 256
             }, initializeOptions);
             if (SystemInfo.platform === exports.Platform.IPhone || SystemInfo.platform === exports.Platform.IPad) {
                 var version = SystemInfo.operatingSystem.match(/(\d+).?(\d+)?.?(\d+)?/);
@@ -33126,21 +33136,31 @@
             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 VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
                         var vertexBuffer = accessorBuffer.vertexBuffer;
@@ -33155,7 +33175,8 @@
                         vertexElement = new VertexElement(attribute, elementOffset, elementFormat, vertexBindingInfos[meshId]);
                     }
                 } else {
-                    vertexElement = new VertexElement(attribute, 0, elementFormat, bufferBindIndex);
+                    elementOffset = 0;
+                    vertexElement = new VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
                     var vertexBuffer1 = new Buffer(engine, exports.BufferBindFlag.VertexBuffer, vertices.byteLength, exports.BufferUsage.Static);
                     vertexBuffer1.setData(vertices);
                     mesh.setVertexBufferBinding(vertexBuffer1, accessorBuffer.stride, bufferBindIndex);
@@ -33163,35 +33184,60 @@
                 }
                 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 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 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);
-                            Vector3.min(min, position, min);
-                            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);
+                            Vector3.min(min, position1, min);
+                            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 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 Vector4(vertices[offset3], vertices[offset3 + 1], vertices[offset3 + 2], vertices[offset3 + 3]);
+                        elementNormalized && boneWeight.scale(scaleFactor);
+                        boneWeights[j3] = boneWeight;
                     }
                 }
             }
@@ -33210,6 +33256,10 @@
             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) {
@@ -35737,7 +35787,7 @@
     }));
 
     //@ts-ignore
-    var version = "0.9.0";
+    var version = "0.9.2";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);