@galacean/engine-core 1.6.2 → 1.6.4

package/dist/main.js

@@ -6882,7 +6882,6 @@ __decorate([
     function RenderContext() {
         this._projectionParams = new engineMath.Vector4();
         this.flipProjection = false;
-        this.rendererUpdateFlag = 0;
     }
     var _proto = RenderContext.prototype;
     _proto.applyVirtualCamera = function applyVirtualCamera(virtualCamera, flipProjection) {
@@ -8722,7 +8721,7 @@ exports.Camera = /*#__PURE__*/ function(Component) {
             Logger.error("mipLevel only take effect in WebGL2.0");
         }
         var ignoreClearFlags;
-        if (this._cameraType !== CameraType.Normal && !this._renderTarget && !this._isIndependentCanvasEnabled()) {
+        if (this._cameraType !== CameraType.Normal && !this._renderTarget) {
             ignoreClearFlags = engine.xrManager._getCameraIgnoreClearFlags(this._cameraType);
         }
         this._renderPipeline.render(context, cubeFace, mipLevel, ignoreClearFlags);
@@ -8856,6 +8855,9 @@ exports.Camera = /*#__PURE__*/ function(Component) {
             width = canvas.width;
             height = canvas.height;
         }
+        this._adjustPixelViewport(width, height);
+    };
+    _proto._adjustPixelViewport = function _adjustPixelViewport(width, height) {
         var viewport = this._viewport;
         this._pixelViewport.set(viewport.x * width, viewport.y * height, viewport.z * width, viewport.w * height);
         !this._customAspectRatio && this._dispatchModify(CameraModifyFlags.AspectRatio);
@@ -10869,7 +10871,7 @@ var scalableAmbientOcclusionFS = "// Ambient Occlusion, largely inspired from:\n
     _proto.onRender = function onRender(context) {
         var engine = this.engine;
         var camera = context.camera;
-        var viewport = camera.viewport, scene = camera.scene, pixelViewport = camera.pixelViewport;
+        camera.viewport; var scene = camera.scene, pixelViewport = camera.pixelViewport;
         var ambientOcclusion = scene.ambientOcclusion;
         var shaderData = this._material.shaderData;
         var projectionMatrix = context.projectionMatrix;
@@ -10901,15 +10903,15 @@ var scalableAmbientOcclusionFS = "// Ambient Occlusion, largely inspired from:\n
         var _this = this, saoTarget = _this._saoRenderTarget, material = _this._material;
         // Draw ambient occlusion texture
         var sourceTexture = this._depthRenderTarget.depthTexture;
-        Blitter.blitTexture(engine, sourceTexture, saoTarget, 0, viewport, material, 0);
+        Blitter.blitTexture(engine, sourceTexture, saoTarget, 0, undefined, material, 0);
         // Horizontal blur, saoRenderTarget -> blurRenderTarget
         var saoTexture = saoTarget.getColorTexture();
         var offsetX = this._offsetX.set(1, 1, this._blurStepPixels / saoTexture.width, 0);
-        Blitter.blitTexture(engine, saoTexture, this._blurRenderTarget, 0, viewport, material, 1, offsetX);
+        Blitter.blitTexture(engine, saoTexture, this._blurRenderTarget, 0, undefined, material, 1, offsetX);
         // Vertical blur, blurRenderTarget -> saoRenderTarget
         var horizontalBlur = this._blurRenderTarget.getColorTexture();
         var offsetY = this._offsetY.set(1, 1, 0, this._blurStepPixels / saoTexture.height);
-        Blitter.blitTexture(engine, horizontalBlur, saoTarget, 0, viewport, material, 1, offsetY);
+        Blitter.blitTexture(engine, horizontalBlur, saoTarget, 0, undefined, material, 1, offsetY);
         // Set the SAO texture
         camera.shaderData.setTexture(exports.Camera._cameraAOTextureProperty, saoTexture);
     };
@@ -14423,7 +14425,8 @@ var PostProcessUberPass = /*#__PURE__*/ function(PostProcessPass) {
         } else {
             uberShaderData.disableMacro(TonemappingEffect._enableMacro);
         }
-        Blitter.blitTexture(camera.engine, srcTexture, destTarget, 0, camera.viewport, this._uberMaterial, undefined);
+        var viewport = destTarget === camera.renderTarget ? camera.viewport : undefined;
+        Blitter.blitTexture(camera.engine, srcTexture, destTarget, 0, viewport, this._uberMaterial, undefined);
     };
     /**
    * @inheritdoc
@@ -14461,7 +14464,7 @@ var PostProcessUberPass = /*#__PURE__*/ function(PostProcessPass) {
             uberShaderData.disableMacro(BloomEffect._hqMacro);
         }
         uberShaderData.setTexture(BloomEffect._dirtTextureProp, dirtTexture.value);
-        if (dirtTexture) {
+        if (dirtTexture.value) {
             uberShaderData.enableMacro(BloomEffect._dirtMacro);
         } else {
             uberShaderData.disableMacro(BloomEffect._dirtMacro);
@@ -14598,11 +14601,12 @@ var FXAA3_11 = "//--------------------------------------------------------------
         var enableFXAA = camera.antiAliasing === AntiAliasing.FXAA;
         // Should convert to sRGB when FXAA is enabled or camera's render target is not set
         var sourceTexture = this._inputRenderTarget.getColorTexture();
-        var outputRenderTarget = enableFXAA ? this._srgbRenderTarget : renderTarget;
-        Blitter.blitTexture(engine, sourceTexture, outputRenderTarget, 0, viewport, this._sRGBmaterial);
         if (enableFXAA) {
+            Blitter.blitTexture(engine, sourceTexture, this._srgbRenderTarget, 0, undefined, this._sRGBmaterial);
             var sRGBTexture = this._srgbRenderTarget.getColorTexture();
             Blitter.blitTexture(engine, sRGBTexture, renderTarget, 0, viewport, this._antiAliasingMaterial);
+        } else {
+            Blitter.blitTexture(engine, sourceTexture, renderTarget, 0, viewport, this._sRGBmaterial);
         }
     };
     _proto.release = function release() {
@@ -14640,6 +14644,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) {
@@ -14659,8 +14664,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;
@@ -14670,11 +14674,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);
             }
@@ -14778,6 +14782,7 @@ Shader.create("FinalAntiAliasing", blitVs, FinalAntiAliasingFS);
                 rhi.drawPrimitive(primitive, subElement.subPrimitive, program);
             }
         }
+        this.rendererUpdateFlag = ContextRendererUpdateFlag.None;
     };
     _proto.clear = function clear() {
         this.elements.length = 0;
@@ -15575,7 +15580,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;
@@ -15614,6 +15621,11 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.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();
@@ -15720,7 +15732,7 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.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();
@@ -15745,12 +15757,11 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.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);
@@ -15758,7 +15769,6 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
         if (depthPassEnabled) {
             depthOnlyPass.onConfig(camera);
             depthOnlyPass.onRender(context, cullingResults);
-            context.rendererUpdateFlag = ContextRendererUpdateFlag.None;
         } else {
             depthOnlyPass.release();
             camera.shaderData.setTexture(exports.Camera._cameraDepthTextureProperty, engine._basicResources.whiteTexture2D);
@@ -15824,7 +15834,7 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.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);
@@ -25985,7 +25995,7 @@ var UIUtils = /*#__PURE__*/ function() {
                 viewE[12] = -position.x, viewE[13] = -position.y;
                 engineMath.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);