@galacean/engine-core 1.3.25 → 1.3.27

package/dist/main.js

@@ -4073,6 +4073,28 @@ __decorate([
    */ Shader.find = function find(name) {
         return Shader._shaderMap[name];
     };
+    /**
+   * @internal
+   */ Shader._clear = function _clear(engine) {
+        var shaderMap = Shader._shaderMap;
+        for(var key in shaderMap){
+            var shader = shaderMap[key];
+            var subShaders = shader._subShaders;
+            for(var i = 0, n = subShaders.length; i < n; i++){
+                var passes = subShaders[i].passes;
+                for(var j = 0, m = passes.length; j < m; j++){
+                    var pass = passes[j];
+                    var passShaderProgramPools = pass._shaderProgramPools;
+                    for(var k = passShaderProgramPools.length - 1; k >= 0; k--){
+                        var shaderProgramPool = passShaderProgramPools[k];
+                        if (shaderProgramPool.engine !== engine) continue;
+                        shaderProgramPool._destroy();
+                        passShaderProgramPools.splice(k, 1);
+                    }
+                }
+            }
+        }
+    };
     Shader._applyConstRenderStates = function _applyConstRenderStates(renderState, key, value) {
         switch(key){
             case exports.RenderStateDataKey.BlendStateEnabled0:
@@ -8316,6 +8338,7 @@ var /**
         program.uploadUnGroupTextures();
         (pass._renderState || blitMaterial.renderState)._applyStates(engine, false, pass._renderStateDataMap, blitMaterial.shaderData);
         rhi.drawPrimitive(blitMesh._primitive, blitMesh.subMesh, program);
+        rendererShaderData.setTexture(PipelineUtils._blitTextureProperty, null);
     };
     return PipelineUtils;
 }();
@@ -8663,6 +8686,7 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component1) {
         }
         this._renderPipeline.render(context, cubeFace, mipLevel, ignoreClearFlags);
         engine._renderCount++;
+        context.camera = null;
     };
     _proto.setReplacementShader = function setReplacementShader(shader, replacementTag, failureStrategy) {
         if (failureStrategy === void 0) failureStrategy = exports.ReplacementFailureStrategy.KeepOriginalShader;
@@ -9412,17 +9436,20 @@ var ContextRendererUpdateFlag;
     _proto._drawMask = function _drawMask(context, pipelineStageTagValue, master) {
         var incrementMaskQueue = MaskManager.getMaskIncrementRenderQueue();
         incrementMaskQueue.renderQueueType = this.renderQueueType;
-        incrementMaskQueue.clear();
         var decrementMaskQueue = MaskManager.getMaskDecrementRenderQueue();
         decrementMaskQueue.renderQueueType = this.renderQueueType;
-        decrementMaskQueue.clear();
         var camera = context.camera;
         var engine = camera.engine;
         camera.scene._maskManager.buildMaskRenderElement(master, incrementMaskQueue, decrementMaskQueue);
+        var primitiveChunkManagerMask = engine._batcherManager.primitiveChunkManagerMask;
         incrementMaskQueue._batch(engine._batcherManager);
+        primitiveChunkManagerMask.uploadBuffer();
         incrementMaskQueue.render(context, pipelineStageTagValue, 1);
+        incrementMaskQueue.clear();
         decrementMaskQueue._batch(engine._batcherManager);
+        primitiveChunkManagerMask.uploadBuffer();
         decrementMaskQueue.render(context, pipelineStageTagValue, 2);
+        decrementMaskQueue.clear();
     };
     RenderQueue.compareForOpaque = function compareForOpaque(a, b) {
         return a.priority - b.priority || a.distanceForSort - b.distanceForSort;
@@ -18763,6 +18790,7 @@ __decorate([
  * @internal
  */ var BasicResources = /*#__PURE__*/ function() {
     function BasicResources(engine) {
+        this.engine = engine;
         // prettier-ignore
         var vertices = new Float32Array([
             -1,
@@ -18822,6 +18850,11 @@ __decorate([
         }
     }
     var _proto = BasicResources.prototype;
+    /**
+   * @internal
+   */ _proto._getBlinnPhongMaterial = function _getBlinnPhongMaterial() {
+        return this._blinnPhongMaterial || (this._blinnPhongMaterial = new BlinnPhongMaterial(this.engine));
+    };
     _proto._createBlitMesh = function _createBlitMesh(engine, vertices) {
         var mesh = new ModelMesh(engine);
         mesh._addReferCount(1);
@@ -19577,12 +19610,24 @@ var AssetPromise = /*#__PURE__*/ function() {
         this._onCancelHandler && this._onCancelHandler();
         return this;
     };
-    /**
-   * Return a new resource Promise through the provided asset promise collection.
-   * The resolved of the new AssetPromise will be triggered when all the Promises in the provided set are completed.
-   * @param - Promise Collection
-   * @returns AssetPromise
-   */ AssetPromise.all = function all(promises) {
+    AssetPromise.resolve = function resolve(value) {
+        if (value === undefined) {
+            return new AssetPromise(function(resolve) {
+                return resolve();
+            });
+        } else if (_instanceof(value, AssetPromise) || _instanceof(value, Promise)) {
+            return new AssetPromise(function(resolve, reject) {
+                value.then(function(resolved) {
+                    return resolve(resolved);
+                }, reject);
+            });
+        } else {
+            return new AssetPromise(function(resolve) {
+                return resolve(value);
+            });
+        }
+    };
+    AssetPromise.all = function all(values) {
         return new AssetPromise(function(resolve, reject, setTaskCompleteProgress) {
             var onComplete = function onComplete(index, resultValue) {
                 completed++;
@@ -19593,7 +19638,7 @@ var AssetPromise = /*#__PURE__*/ function() {
                 }
             };
             var onProgress = function onProgress(promise, index) {
-                if (_instanceof(promise, Promise) || _instanceof(promise, AssetPromise)) {
+                if (_instanceof(promise, AssetPromise) || _instanceof(promise, Promise)) {
                     promise.then(function(value) {
                         onComplete(index, value);
                     }, reject);
@@ -19603,14 +19648,14 @@ var AssetPromise = /*#__PURE__*/ function() {
                     });
                 }
             };
-            var count = promises.length;
+            var count = Array.from(values).length;
             var results = new Array(count);
             var completed = 0;
             if (count === 0) {
                 return resolve(results);
             }
             for(var i = 0; i < count; i++){
-                onProgress(promises[i], i);
+                onProgress(values[i], i);
             }
         });
     };
@@ -20192,12 +20237,12 @@ var MultiExecutor = /*#__PURE__*/ function() {
         var obj = this._objectPool[refId];
         var promise;
         if (obj) {
-            promise = Promise.resolve(obj);
+            promise = AssetPromise.resolve(obj);
         } else {
             var resourceConfig = this._editorResourceConfig[refId];
             if (!resourceConfig) {
-                Logger.warn("refId:" + refId + " is not find in this._editorResourceConfig.");
-                return Promise.resolve(null);
+                Logger.warn("refId:" + refId + " is not find in this._idResourceMap.");
+                return AssetPromise.resolve(null);
             }
             var url = resourceConfig.virtualPath;
             if (key) {
@@ -21153,16 +21198,24 @@ var Collision = function Collision() {
             }
             return shape.collider.entity.layer & layerMask && shape.isSceneQuery;
         };
+        var outIDX;
+        var outDistance;
+        var outPosition;
+        var outNormal;
         if (hitResult != undefined) {
             var result = this._nativePhysicsScene.raycast(ray, distance, onRaycast, function(idx, distance, position, normal) {
-                var hitShape = _this._scene.engine._physicalObjectsMap[idx];
-                hitResult.entity = hitShape._collider.entity;
-                hitResult.shape = hitShape;
-                hitResult.distance = distance;
-                hitResult.normal.copyFrom(normal);
-                hitResult.point.copyFrom(position);
+                outIDX = idx;
+                outDistance = distance;
+                outPosition = position;
+                outNormal = normal;
             });
             if (result) {
+                var hitShape = this._scene.engine._physicalObjectsMap[outIDX];
+                hitResult.entity = hitShape._collider.entity;
+                hitResult.shape = hitShape;
+                hitResult.distance = outDistance;
+                hitResult.point.copyFrom(outPosition);
+                hitResult.normal.copyFrom(outNormal);
                 return true;
             } else {
                 hitResult.entity = null;
@@ -23886,21 +23939,15 @@ ShaderPool.init();
         var _this_xrManager;
         this._sceneManager._destroyAllScene();
         this._resourceManager._destroy();
-        this._textDefaultFont = null;
-        this._fontMap = null;
         this.inputManager._destroy();
         this._batcherManager.destroy();
         (_this_xrManager = this.xrManager) == null ? void 0 : _this_xrManager._destroy();
         this.dispatch("shutdown", this);
         // Cancel animation
         this.pause();
+        Shader._clear(this);
         this._hardwareRenderer.destroy();
         this.removeAllEventListeners();
-        this._animate = null;
-        this._sceneManager = null;
-        this._resourceManager = null;
-        this._canvas = null;
-        this._time = null;
         this._waitingDestroy = false;
         this._destroyed = true;
     };
@@ -24068,6 +24115,7 @@ ShaderPool.init();
         this._hardwareRenderer.resetState();
         this._lastRenderState = new RenderState();
         // Clear shader pools
+        Shader._clear(this);
         this._shaderProgramPools.length = 0;
         var resourceManager = this.resourceManager;
         // Restore graphic resources
@@ -27187,11 +27235,13 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
    * @param time - The time to sample an animation
    */ _proto._sampleAnimation = function _sampleAnimation(entity, time) {
         var _this = this, curveBindings = _this._curveBindings;
+        var components = AnimationCurveOwner._components;
         for(var i = curveBindings.length - 1; i >= 0; i--){
             var curve = curveBindings[i];
             var targetEntity = entity.findByPath(curve.relativePath);
             if (targetEntity) {
-                var component = curve.typeIndex > 0 ? targetEntity.getComponents(curve.type, AnimationCurveOwner._components)[curve.typeIndex] : targetEntity.getComponent(curve.type);
+                var component = curve.typeIndex > 0 ? targetEntity.getComponents(curve.type, components)[curve.typeIndex] : targetEntity.getComponent(curve.type);
+                components.length = 0;
                 if (!component) {
                     continue;
                 }
@@ -28806,13 +28856,15 @@ exports.AnimatorLayerBlendingMode = void 0;
         var curveLayerOwner = animatorStateData.curveLayerOwner;
         var _animatorState_clip = animatorState.clip, curves = _animatorState_clip._curveBindings;
         var layerCurveOwnerPool = animatorLayerData.curveOwnerPool;
+        var components = AnimationCurveOwner._components;
         for(var i = curves.length - 1; i >= 0; i--){
             var curve = curves[i];
             var relativePath = curve.relativePath;
             var targetEntity = curve.relativePath === "" ? entity : entity.findByPath(curve.relativePath);
             if (targetEntity) {
                 var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _property1;
-                var component = curve.typeIndex > 0 ? targetEntity.getComponents(curve.type, AnimationCurveOwner._components)[curve.typeIndex] : targetEntity.getComponent(curve.type);
+                var component = curve.typeIndex > 0 ? targetEntity.getComponents(curve.type, components)[curve.typeIndex] : targetEntity.getComponent(curve.type);
+                components.length = 0;
                 if (!component) {
                     continue;
                 }