How can I perform a pass to two textures simultaneously, similar to a GeometryPass (for v7)?

[AndreyPrakhov]

The task is as follows: there’s a class LightPass (a subclass of Pass) that should render to two textures. Then there's a class ComposeEffect (a subclass of Effect) that should use these two textures.

It sounds straightforward, but it’s not working. Here’s the simplified code of everything.

class LightPass extends PostProcessing.Pass {
    constructor() {
        super('LightPass');

        const textureNames = ['DiffuseLight', 'SpecularLight'];

        const { width, height } = this.resolution;
        const renderTarget = new WebGLRenderTarget(width, height, {
            count: textureNames.length
        });

        for(let i = 0, l = textureNames.length; i < l; ++i) {

            const texture = renderTarget.textures[i];
            texture.name = textureNames[i];
            texture.minFilter = LinearFilter
            texture.magFilter = LinearFilter
            texture.format = RGBAFormat;
            texture.type = UnsignedByteType;
        }

        this.output.defaultBuffer = renderTarget;
        this.fullscreenMaterial = new DefferedMaterial();
    }

    render(){
        this.renderer.setRenderTarget(this.output.defaultBuffer.value);
        this.renderFullscreen();
    }
    
    //light.frag
    #include <pp_precision_fragment>

layout(location = 0) out vec4 outDiffuseColor;
layout(location = 1) out vec4 outSpecularColor;

in vec2 vUv;

void main() {
	outDiffuseColor = vec4(1.0,0.0,0.0,1.0);
	outSpecularColor = vec4(0.0,1.0,0.0,1.0);
}

class ComposePass extends PostProcessing.Effect {
    constructor() {
        super("ComposePass");
        this.fragmentShader = fs;

        const uniforms = this.input.uniforms;
        uniforms.set("diffuseLightMap", new Uniform(null));
        uniforms.set("specularLightMap", new Uniform(null));

        this.diffuseLightMap = null;
        this.specularLightMap = null;
    }

    set diffuseLightMap(value) {
        this.input.uniforms.get('diffuseLightMap').value = value;
    }

    set specularLightMap(value) {
        this.input.uniforms.get('specularLightMap').value = value;
    }
}

// compose.frag
#ifdef FRAMEBUFFER_PRECISION_HIGH

	uniform mediump sampler2D diffuseLight;
	uniform mediump sampler2D specularLight;

#else

	uniform lowp sampler2D diffuseLight;
	uniform lowp sampler2D specularLight;

#endif

vec4 mainImage(const in vec4 inputColor, const in vec2 uv, const in GData gData)
{
	vec3 texel = texture(specularLight, uv).rgb;
    return vec4(texel.rgb, 1.0);
}

//-----------
lightPass = new LightPass();
composePass = new ComposePass();

renderPipeline = new RenderPipeline(renderer);
renderPipeline.add( lightPass, new EffectPass(composePass));
            
composePass.diffuseLightMap = lightPass.output.defaultBuffer.value.textures[0];
composePass.specularLightMap = lightPass.output.defaultBuffer.value.textures[1];

In the end, the ComposeEffect renders only using the color from one texture and doesn’t recognize the second one.

[AndreyPrakhov]

hmm, just a mistake in the assignment of the render target. Sorry, I'm closing the question