@galacean/engine 1.6.2 → 1.6.4

package/dist/browser.js

@@ -11825,7 +11825,6 @@
         function RenderContext() {
             this._projectionParams = new Vector4();
             this.flipProjection = false;
-            this.rendererUpdateFlag = 0;
         }
         var _proto = RenderContext.prototype;
         _proto.applyVirtualCamera = function applyVirtualCamera(virtualCamera, flipProjection) {
@@ -13645,7 +13644,7 @@
                 Logger.error("mipLevel only take effect in WebGL2.0");
             }
             var ignoreClearFlags;
-            if (this._cameraType !== CameraType$1.Normal && !this._renderTarget && !this._isIndependentCanvasEnabled()) {
+            if (this._cameraType !== CameraType$1.Normal && !this._renderTarget) {
                 ignoreClearFlags = engine.xrManager._getCameraIgnoreClearFlags(this._cameraType);
             }
             this._renderPipeline.render(context, cubeFace, mipLevel, ignoreClearFlags);
@@ -13779,6 +13778,9 @@
                 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);
@@ -15775,7 +15777,8 @@
         _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;
@@ -15807,15 +15810,15 @@
             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);
         };
@@ -19282,7 +19285,8 @@
             } 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
@@ -19320,7 +19324,7 @@
                 uberShaderData.disableMacro(BloomEffect._hqMacro);
             }
             uberShaderData.setTexture(BloomEffect._dirtTextureProp, dirtTexture.value);
-            if (dirtTexture) {
+            if (dirtTexture.value) {
                 uberShaderData.enableMacro(BloomEffect._dirtMacro);
             } else {
                 uberShaderData.disableMacro(BloomEffect._dirtMacro);
@@ -19453,11 +19457,12 @@
             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() {
@@ -19493,6 +19498,7 @@
             this.renderQueueType = renderQueueType;
             this.elements = new Array();
             this.batchedSubElements = new Array();
+            this.rendererUpdateFlag = ContextRendererUpdateFlag.None;
         }
         var _proto = RenderQueue.prototype;
         _proto.pushRenderElement = function pushRenderElement(element) {
@@ -19512,8 +19518,7 @@
             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;
@@ -19523,11 +19528,11 @@
                 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);
                 }
@@ -19631,6 +19636,7 @@
                     rhi.drawPrimitive(primitive, subElement.subPrimitive, program);
                 }
             }
+            this.rendererUpdateFlag = ContextRendererUpdateFlag.None;
         };
         _proto.clear = function clear() {
             this.elements.length = 0;
@@ -20420,7 +20426,9 @@
             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;
@@ -20458,6 +20466,11 @@
             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();
@@ -20561,7 +20574,7 @@
        * @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();
@@ -20586,12 +20599,11 @@
             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);
@@ -20599,7 +20611,6 @@
             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);
@@ -20665,7 +20676,7 @@
             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);
@@ -30719,7 +30730,7 @@
                     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);
@@ -44209,7 +44220,7 @@
             var yStart = flipY ? srcHeight - viewport.y * srcHeight - copyHeight : viewport.y * srcHeight;
             var _srcRT__platformRenderTarget__frameBuffer;
             // @ts-ignore
-            var frameBuffer = (_srcRT__platformRenderTarget__frameBuffer = srcRT == null ? void 0 : srcRT._platformRenderTarget._frameBuffer) != null ? _srcRT__platformRenderTarget__frameBuffer : null;
+            var frameBuffer = (_srcRT__platformRenderTarget__frameBuffer = srcRT == null ? void 0 : srcRT._platformRenderTarget._frameBuffer) != null ? _srcRT__platformRenderTarget__frameBuffer : this._mainFrameBuffer;
             // @ts-ignore
             gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
             // @ts-ignore
@@ -51602,7 +51613,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "1.6.2";
+    var version = "1.6.4";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);