Fix text render when depth texture enabled (#2839)

* fix: text render

packages/core/src/RenderPipeline/BasicRenderPipeline.ts

@@ -83,7 +83,7 @@ export class BasicRenderPipeline {
    * @param ignoreClear - Ignore clear flag
    */
   render(context: RenderContext, cubeFace?: TextureCubeFace, mipLevel?: number, ignoreClear?: CameraClearFlags) {
-    context.rendererUpdateFlag = ContextRendererUpdateFlag.All;
+    this._cullingResults.setRenderUpdateFlagTrue(ContextRendererUpdateFlag.All);
 
     const camera = this._camera;
     const { scene, engine, renderTarget } = camera;
@@ -117,14 +117,13 @@ export class BasicRenderPipeline {
 
     if (scene.castShadows && sunlight && sunlight.shadowType !== ShadowType.None) {
       this._cascadedShadowCasterPass.onRender(context);
-      context.rendererUpdateFlag = ContextRendererUpdateFlag.None;
     }
 
     const 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);
 
@@ -134,7 +133,6 @@ export class BasicRenderPipeline {
     if (depthPassEnabled) {
       depthOnlyPass.onConfig(camera);
       depthOnlyPass.onRender(context, cullingResults);
-      context.rendererUpdateFlag = ContextRendererUpdateFlag.None;
     } else {
       depthOnlyPass.release();
       camera.shaderData.setTexture(Camera._cameraDepthTextureProperty, engine._basicResources.whiteTexture2D);
@@ -235,7 +233,7 @@ export class BasicRenderPipeline {
 
     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);
     }
 

packages/core/src/RenderPipeline/CullingResults.ts

@@ -1,5 +1,6 @@
 import { RenderQueueType } from "../shader";
 import { BatcherManager } from "./BatcherManager";
+import { ContextRendererUpdateFlag } from "./RenderContext";
 import { RenderQueue } from "./RenderQueue";
 
 /**
@@ -29,6 +30,12 @@ export class CullingResults {
     this.transparentQueue.sortBatch(RenderQueue.compareForTransparent, batcherManager);
   }
 
+  setRenderUpdateFlagTrue(rendererUpdateFlag: ContextRendererUpdateFlag): void {
+    this.opaqueQueue.rendererUpdateFlag |= rendererUpdateFlag;
+    this.transparentQueue.rendererUpdateFlag |= rendererUpdateFlag;
+    this.alphaTestQueue.rendererUpdateFlag |= rendererUpdateFlag;
+  }
+
   destroy(): void {
     this.opaqueQueue.destroy();
     this.transparentQueue.destroy();

packages/core/src/RenderPipeline/RenderContext.ts

@@ -36,7 +36,6 @@ export class RenderContext {
   viewMatrix: Matrix;
   projectionMatrix: Matrix;
   viewProjectionMatrix: Matrix;
-  rendererUpdateFlag = ContextRendererUpdateFlag.None;
 
   applyVirtualCamera(virtualCamera: VirtualCamera, flipProjection: boolean): void {
     this.virtualCamera = virtualCamera;

packages/core/src/RenderPipeline/RenderQueue.ts

@@ -23,6 +23,7 @@ export class RenderQueue {
 
   readonly elements = new Array<RenderElement>();
   readonly batchedSubElements = new Array<SubRenderElement>();
+  rendererUpdateFlag = ContextRendererUpdateFlag.None;
 
   constructor(public renderQueueType: RenderQueueType) {}
 
@@ -50,8 +51,7 @@ export class RenderQueue {
       return;
     }
 
-    const { rendererUpdateFlag, camera } = context;
-    const { engine, scene, instanceId: cameraId, shaderData: cameraData } = camera;
+    const { engine, scene, instanceId: cameraId, shaderData: cameraData } = context.camera;
     const { instanceId: sceneId, shaderData: sceneData, _maskManager: maskManager } = scene;
     const renderCount = engine._renderCount;
     const rhi = engine._hardwareRenderer;
@@ -64,13 +64,13 @@ export class RenderQueue {
 
       // @todo: Can optimize update view projection matrix updated
       if (
-        rendererUpdateFlag & ContextRendererUpdateFlag.WorldViewMatrix ||
+        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);
       }
@@ -195,6 +195,8 @@ export class RenderQueue {
         rhi.drawPrimitive(primitive, subElement.subPrimitive, program);
       }
     }
+
+    this.rendererUpdateFlag = ContextRendererUpdateFlag.None;
   }
 
   clear(): void {

packages/core/src/shadow/CascadedShadowCasterPass.ts

@@ -387,7 +387,10 @@ export class CascadedShadowCasterPass extends PipelinePass {
     sceneShaderData.setVector3(CascadedShadowCasterPass._lightDirectionProperty, light.direction);
 
     // Every light use self virtual camera
-    context.rendererUpdateFlag |= ContextRendererUpdateFlag.viewProjectionMatrix;
+    const { opaqueQueue, alphaTestQueue } = context.camera._renderPipeline._cullingResults;
+    opaqueQueue.rendererUpdateFlag |= ContextRendererUpdateFlag.viewProjectionMatrix;
+    alphaTestQueue.rendererUpdateFlag |= ContextRendererUpdateFlag.viewProjectionMatrix;
+
     context.applyVirtualCamera(virtualCamera, true);
   }
 }

packages/core/src/ui/UIUtils.ts

@@ -42,7 +42,7 @@ export class UIUtils {
         (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);