Support alphaTest and opaque(transparent/transmission) in ExtendedCopyPass, Add outputColorSpace in ScreenPass(defaults to SRGBColorSpace).

src/postprocessing/ExtendedCopyPass.ts

             vertexShader: CopyShader.vertexShader,
             fragmentShader: glsl`
                 uniform float opacity;
+                uniform float alphaTest;
                 varying vec2 vUv;
                 void main() {
                     gl_FragColor = tDiffuseTexelToLinear(texture2D(tDiffuse, vUv)) * opacity;
+                    #ifdef USE_ALPHATEST
+                    if ( gl_FragColor.a < alphaTest ) discard;
+                    #endif
+                    #ifdef OPAQUE
+                    gl_FragColor.a = 1.0;
+                    #endif
                     #include <encodings_fragment>
                 }
             `,

src/postprocessing/ExtendedShaderPass.ts

         super(
             (<ShaderMaterial2>shader).isMaterial ? <ShaderMaterial2>shader : new ExtendedShaderMaterial(<Shader>shader, textureID),
             textureID.length < 1 ? ExtendedShaderPass.DEFAULT_TEX_ID : textureID[0])
+        this.setDirty = this.setDirty.bind(this)
     }
 
     render(renderer: IWebGLRenderer, writeBuffer?: WebGLMultipleRenderTargets|WebGLRenderTarget|null, readBuffer?: WebGLMultipleRenderTargets|WebGLRenderTarget, deltaTime?: number, maskActive?: boolean) {
         if (!this.enabled) return
-        super.render(renderer, writeBuffer || null, this.overrideReadBuffer || readBuffer, deltaTime, maskActive)
+        renderer.renderWithModes({
+            backgroundRender: false,
+        }, ()=>{
+            super.render(renderer, writeBuffer || null, this.overrideReadBuffer || readBuffer, deltaTime, maskActive)
+        })
     }
 
     updateShaderProperties(updater?: (IShaderPropertiesUpdater|undefined) | (IShaderPropertiesUpdater|undefined)[]) {

src/postprocessing/ScreenPass.ts

 import {ExtendedShaderPass} from './ExtendedShaderPass'
-import {Shader} from 'three'
-import {ShaderMaterial2} from '../core'
+import {ColorSpace, Shader, SRGBColorSpace, WebGLMultipleRenderTargets, WebGLRenderTarget} from 'three'
+import {IWebGLRenderer, ShaderMaterial2} from '../core'
 import {CopyShader} from 'three/examples/jsm/shaders/CopyShader.js'
 import {IPassID, IPipelinePass} from './Pass'
 import {uiFolderContainer} from 'uiconfig.js'
                 makeScreenShader(shader),
             ...textureID.length ? textureID : ['tDiffuse'])
     }
+
+    outputColorSpace: ColorSpace = SRGBColorSpace
+
+    render(renderer: IWebGLRenderer, writeBuffer?: WebGLMultipleRenderTargets | WebGLRenderTarget | null, readBuffer?: WebGLMultipleRenderTargets | WebGLRenderTarget, deltaTime?: number, maskActive?: boolean) {
+        const colorSpace = renderer.outputColorSpace
+        if (!writeBuffer || this.renderToScreen) renderer.outputColorSpace = this.outputColorSpace
+        else console.warn('ScreenPass: outputColorSpace is ignored when renderToScreen is false')
+        super.render(renderer, writeBuffer, readBuffer, deltaTime, maskActive)
+        renderer.outputColorSpace = colorSpace
+    }
 }
 
 function makeScreenShader(shader: string | [string, string] | {pars?: string; main: string} | Shader | ShaderMaterial2) {
-    const c = {
+    return {
         ...CopyShader,
         fragmentShader: `
 varying vec2 vUv;
     
     ${Array.isArray(shader) ? shader[1] : typeof shader === 'string' ? shader : (shader as any)?.main || ''}
     
-    gl_FragColor = LinearTosRGB(gl_FragColor);
+    #include <encodings_fragment>
 }`,
         uniforms: {
             tDiffuse: {value: null},
         },
     }
-    return c
 }