@galacean/engine-core 1.6.2 → 1.6.3

package/dist/module.js

@@ -6878,7 +6878,6 @@ __decorate([
     function RenderContext() {
         this._projectionParams = new Vector4();
         this.flipProjection = false;
-        this.rendererUpdateFlag = 0;
     }
     var _proto = RenderContext.prototype;
     _proto.applyVirtualCamera = function applyVirtualCamera(virtualCamera, flipProjection) {
@@ -14636,6 +14635,7 @@ Shader.create("FinalAntiAliasing", blitVs, FinalAntiAliasingFS);
         this.renderQueueType = renderQueueType;
         this.elements = new Array();
         this.batchedSubElements = new Array();
+        this.rendererUpdateFlag = ContextRendererUpdateFlag.None;
     }
     var _proto = RenderQueue.prototype;
     _proto.pushRenderElement = function pushRenderElement(element) {
@@ -14655,8 +14655,7 @@ Shader.create("FinalAntiAliasing", blitVs, FinalAntiAliasingFS);
         if (length === 0) {
             return;
         }
-        var rendererUpdateFlag = context.rendererUpdateFlag, camera = context.camera;
-        var engine = camera.engine, scene = camera.scene, cameraId = camera.instanceId, cameraData = camera.shaderData;
+        var _context_camera = context.camera, engine = _context_camera.engine, scene = _context_camera.scene, cameraId = _context_camera.instanceId, cameraData = _context_camera.shaderData;
         var sceneId = scene.instanceId, sceneData = scene.shaderData, maskManager = scene._maskManager;
         var renderCount = engine._renderCount;
         var rhi = engine._hardwareRenderer;
@@ -14666,11 +14665,11 @@ Shader.create("FinalAntiAliasing", blitVs, FinalAntiAliasingFS);
             var subElement = batchedSubElements[i];
             var renderer = subElement.component, batched = subElement.batched, material = subElement.material;
             // @todo: Can optimize update view projection matrix updated
-            if (rendererUpdateFlag & ContextRendererUpdateFlag.WorldViewMatrix || renderer._batchedTransformShaderData != batched) {
+            if (this.rendererUpdateFlag & ContextRendererUpdateFlag.WorldViewMatrix || renderer._batchedTransformShaderData != batched) {
                 // Update world matrix and view matrix and model matrix
                 renderer._updateTransformShaderData(context, false, batched);
                 renderer._batchedTransformShaderData = batched;
-            } else if (rendererUpdateFlag & ContextRendererUpdateFlag.ProjectionMatrix) {
+            } else if (this.rendererUpdateFlag & ContextRendererUpdateFlag.ProjectionMatrix) {
                 // Only projection matrix need updated
                 renderer._updateTransformShaderData(context, true, batched);
             }
@@ -14774,6 +14773,7 @@ Shader.create("FinalAntiAliasing", blitVs, FinalAntiAliasingFS);
                 rhi.drawPrimitive(primitive, subElement.subPrimitive, program);
             }
         }
+        this.rendererUpdateFlag = ContextRendererUpdateFlag.None;
     };
     _proto.clear = function clear() {
         this.elements.length = 0;
@@ -15571,7 +15571,9 @@ ShadowUtils.atlasBorderSize = 4.0;
         sceneShaderData.setVector2(CascadedShadowCasterPass._lightShadowBiasProperty, this._shadowBias);
         sceneShaderData.setVector3(CascadedShadowCasterPass._lightDirectionProperty, light.direction);
         // Every light use self virtual camera
-        context.rendererUpdateFlag |= ContextRendererUpdateFlag.viewProjectionMatrix;
+        var _context_camera__renderPipeline__cullingResults = context.camera._renderPipeline._cullingResults, opaqueQueue = _context_camera__renderPipeline__cullingResults.opaqueQueue, alphaTestQueue = _context_camera__renderPipeline__cullingResults.alphaTestQueue;
+        opaqueQueue.rendererUpdateFlag |= ContextRendererUpdateFlag.viewProjectionMatrix;
+        alphaTestQueue.rendererUpdateFlag |= ContextRendererUpdateFlag.viewProjectionMatrix;
         context.applyVirtualCamera(virtualCamera, true);
     };
     return CascadedShadowCasterPass;
@@ -15610,6 +15612,11 @@ CascadedShadowCasterPass._tempMatrix0 = new Matrix();
         this.alphaTestQueue.sortBatch(RenderQueue.compareForOpaque, batcherManager);
         this.transparentQueue.sortBatch(RenderQueue.compareForTransparent, batcherManager);
     };
+    _proto.setRenderUpdateFlagTrue = function setRenderUpdateFlagTrue(rendererUpdateFlag) {
+        this.opaqueQueue.rendererUpdateFlag |= rendererUpdateFlag;
+        this.transparentQueue.rendererUpdateFlag |= rendererUpdateFlag;
+        this.alphaTestQueue.rendererUpdateFlag |= rendererUpdateFlag;
+    };
     _proto.destroy = function destroy() {
         this.opaqueQueue.destroy();
         this.transparentQueue.destroy();
@@ -15716,7 +15723,7 @@ CascadedShadowCasterPass._tempMatrix0 = new Matrix();
    * @param mipLevel - Set mip level the data want to write
    * @param ignoreClear - Ignore clear flag
    */ _proto.render = function render(context, cubeFace, mipLevel, ignoreClear) {
-        context.rendererUpdateFlag = ContextRendererUpdateFlag.All;
+        this._cullingResults.setRenderUpdateFlagTrue(ContextRendererUpdateFlag.All);
         var camera = this._camera;
         var scene = camera.scene, engine = camera.engine, renderTarget = camera.renderTarget;
         var independentCanvasEnabled = camera._isIndependentCanvasEnabled();
@@ -15741,12 +15748,11 @@ CascadedShadowCasterPass._tempMatrix0 = new Matrix();
         this._shouldCopyBackgroundColor = independentCanvasEnabled && !(finalClearFlags & CameraClearFlags.Color) && (!this._canUseBlitFrameBuffer || isSRGBBackground);
         if (scene.castShadows && sunlight && sunlight.shadowType !== ShadowType.None) {
             this._cascadedShadowCasterPass.onRender(context);
-            context.rendererUpdateFlag = ContextRendererUpdateFlag.None;
         }
         var batcherManager = engine._batcherManager;
         cullingResults.reset();
         // Depth use camera's view and projection matrix
-        context.rendererUpdateFlag |= ContextRendererUpdateFlag.viewProjectionMatrix;
+        this._cullingResults.setRenderUpdateFlagTrue(ContextRendererUpdateFlag.viewProjectionMatrix);
         context.applyVirtualCamera(camera._virtualCamera, depthPassEnabled);
         this._prepareRender(context);
         cullingResults.sortBatch(batcherManager);
@@ -15754,7 +15760,6 @@ CascadedShadowCasterPass._tempMatrix0 = new Matrix();
         if (depthPassEnabled) {
             depthOnlyPass.onConfig(camera);
             depthOnlyPass.onRender(context, cullingResults);
-            context.rendererUpdateFlag = ContextRendererUpdateFlag.None;
         } else {
             depthOnlyPass.release();
             camera.shaderData.setTexture(Camera._cameraDepthTextureProperty, engine._basicResources.whiteTexture2D);
@@ -15820,7 +15825,7 @@ CascadedShadowCasterPass._tempMatrix0 = new Matrix();
         var needFlipProjection = !!internalColorTarget || camera.renderTarget && cubeFace == undefined;
         if (context.flipProjection !== needFlipProjection) {
             // Just add projection matrix update type is enough
-            context.rendererUpdateFlag |= ContextRendererUpdateFlag.ProjectionMatrix;
+            cullingResults.setRenderUpdateFlagTrue(ContextRendererUpdateFlag.ProjectionMatrix);
             context.applyVirtualCamera(camera._virtualCamera, needFlipProjection);
         }
         context.setRenderTarget(colorTarget, colorViewport, mipLevel, cubeFace);
@@ -25981,7 +25986,7 @@ var UIUtils = /*#__PURE__*/ function() {
                 viewE[12] = -position.x, viewE[13] = -position.y;
                 Matrix.multiply(virtualCamera.projectionMatrix, virtualCamera.viewMatrix, virtualCamera.viewProjectionMatrix);
                 renderContext.applyVirtualCamera(virtualCamera, false);
-                renderContext.rendererUpdateFlag |= ContextRendererUpdateFlag.ProjectionMatrix;
+                uiRenderQueue.rendererUpdateFlag |= ContextRendererUpdateFlag.ProjectionMatrix;
                 uiCanvas._prepareRender(renderContext);
                 uiRenderQueue.pushRenderElement(uiCanvas._renderElement);
                 uiRenderQueue.batch(batcherManager);