Custom Pipeline: Setting up two pass rendering

[panthavma]

Hello! I was trying to do a simple two pass shader in a custom pipeline as follows:

• First pass computes the lighting and exports it, the depth, and the normals to different buffers.
• Second pass takes that info, applies a toon ramp and some edge detection by accessing the depth and normal buffers.

I've been making some progress, but I'm a bit stumped as of what is the best way to do it in Malt.
At the moment, I managed to make the first pass work along with lighting. Here's my pipeline:

class PipelineName(Pipeline):

    DEFAULT_SHADER = None
    MAINSCREENPASS_SHADER = None

    def __init__(self, plugins=[]):
        super().__init__(plugins)

        self.parameters.world['Background Color'] = Parameter((0.5,0.5,0.5,1), Type.FLOAT, 4)

        if PipelineName.DEFAULT_SHADER is None:
            source = '''
            #include "Common.glsl"

            #ifdef VERTEX_SHADER
            void main()
            {
                DEFAULT_VERTEX_SHADER();
            }
            #endif

            #ifdef PIXEL_SHADER
            layout (location = 0) out vec4 RESULT;
            void main()
            {
                PIXEL_SETUP_INPUT();
                RESULT = vec4(1);
            }
            #endif
            '''
            PipelineName.DEFAULT_SHADER = self.compile_material_from_source('mesh', source)

        self.default_shader = PipelineName.DEFAULT_SHADER


        if PipelineName.MAINSCREENPASS_SHADER is None:
            source = '''
            #include "Common.glsl"

            #ifdef VERTEX_SHADER
            void main()
            {
                DEFAULT_SCREEN_VERTEX_SHADER();
            }
            #endif

            #ifdef PIXEL_SHADER
            layout (location = 0) out vec4 RESULT;
            void main()
            {
                PIXEL_SETUP_INPUT();
                RESULT = vec4(1);
            }
            #endif
            '''
            PipelineName.MAINSCREENPASS_SHADER = self.compile_material_from_source('screen', source)

        self.MainScreenPass = PipelineName.MAINSCREENPASS_SHADER
        self.parameters.world['MainScreenPassShader'] = MaterialParameter('', '.screen.glsl')

        #Setup
        self.lights_buffer = Lighting.get_lights_buffer()

    def compile_material_from_source(self, material_type, source, include_paths=[]):
        return {
            'MAIN_PASS' : self.compile_shader_from_source(
                source, include_paths, ['MAIN_PASS']
            )
        }

    def setup_render_targets(self, resolution):
        self.t_pgbuffer_depth = Texture(resolution, GL_DEPTH_COMPONENT32F)
        self.t_pgbuffer_color = Texture(resolution, GL_RGBA32F)
        self.t_pgbuffer_normals = Texture(resolution, GL_RGBA32F)
        self.rt_pgbuffer = RenderTarget([self.t_pgbuffer_color, self.t_pgbuffer_normals], self.t_pgbuffer_depth)
        self.t_finalimage = Texture(resolution, GL_RGBA32F)
        self.rt_final = RenderTarget([self.t_finalimage])

    def do_render(self, resolution, scene, is_final_render, is_new_frame):
        shader_resources = { 'COMMON_UNIFORMS' : self.common_buffer }

        self.rt_pgbuffer.clear([scene.world_parameters['Background Color'], scene.world_parameters['Background Color']], 1)

        self.lights_buffer.load(scene, 4, 0.9, 100.0)
        shader_resources['SCENE_LIGHTS'] = self.lights_buffer

        # def draw_scene_pass(self, render_target, scene_batches, pass_name=None, default_shader=None, shader_resources={}, depth_test_function=GL_LEQUAL):
        self.draw_scene_pass(self.rt_pgbuffer, scene.batches, 'MAIN_PASS', self.default_shader['MAIN_PASS'], shader_resources)

        # def draw_screen_pass(self, shader, target, blend = False):
        self.draw_screen_pass(PipelinePiShader.MAINSCREENPASS_SHADER['MAIN_PASS'], self.rt_final)
        #self.draw_screen_pass(scene.world_parameters['MainScreenPassShader']['MAIN_PASS'], self.rt_final)

        return { 'COLOR' : self.t_pgbuffer_color }


PIPELINE = PipelineName

I'm a bit confused on these points:

1. How can I cleanly load an external shader for the second pass ? The commented draw_screen_pass will make an error saying TypeError: 'MaterialProxy' object is not subscriptable
2. How do I cleanly pass my previous render target to the second pass ? I've seen the uniform dict of shaders used before, is there an easier method ?

Thanks for the help!

[pragma37]

main_screen_material = scene.world_parameters['MainScreenPassShader']
if main_screen_material and main_screen_material.shader:
    self.draw_screen_pass(main_screen_material.shader['MAIN_PASS'], self.rt_final)

main_screen_material.shader['MAIN_PASS'].textures['THE_NAME_OF_YOUR_SAMPLER2D_UNIFORM'] = self.t_pgbuffer_color

[panthavma]

Yes it works, awesome! Thanks!