package renderer

import "core:mem"
import "core:log"

PIPELINE_MAX_SCENE_PASSES :: 8
PIPELINE_MAX_POST_PROCESSING_PASSES :: 8

Pipeline :: struct {
    scene_passes: [PIPELINE_MAX_SCENE_PASSES]^Scene_Pass,
    amount_of_scene_passes: u8,

    post_processing_passes: [PIPELINE_MAX_POST_PROCESSING_PASSES]^Post_Processing_Pass,
    amount_of_post_processing_passes: u8,

    fullscreen_material: ^Material,
    fullscreen_mesh: ^Mesh,
}

clear_pipeline :: proc(renderer: ^Renderer) {
    assert(renderer != nil)
    p := &renderer.pipeline
    
    p.amount_of_scene_passes = 0;
    mem.set(&p.scene_passes[0], 0, PIPELINE_MAX_SCENE_PASSES * size_of(^Scene_Pass))

    p.amount_of_post_processing_passes = 0;
    mem.set(&p.post_processing_passes[0], 0, PIPELINE_MAX_POST_PROCESSING_PASSES * size_of(^Post_Processing_Pass))
}

set_pipeline :: proc(
    renderer: ^Renderer,
    fullscreen_material: ^Material, fullscreen_mesh: ^Mesh,
    scene_passes: []^Scene_Pass,
    post_processing_passes: []^Post_Processing_Pass,
){
    assert(renderer != nil)

    clear_pipeline(renderer)

    renderer.pipeline.fullscreen_material = fullscreen_material
    renderer.pipeline.fullscreen_mesh = fullscreen_mesh
    
    for p in scene_passes {
        if !add_pass_to_pipeline(renderer, p) {
            break
        }
    }

    for p in post_processing_passes {
        if !add_pass_to_pipeline(renderer, p) {
            break
        }
    }
}

add_pass_to_pipeline :: proc {
    add_scene_pass_to_pipeline,
    add_post_processing_pass_to_pipeline,
}

@(private="file") add_scene_pass_to_pipeline :: proc(renderer: ^Renderer, scene_pass: ^Scene_Pass) -> bool {
    assert(renderer != nil)
    assert(scene_pass != nil)

    pipeline := &renderer.pipeline
    
    if pipeline.amount_of_scene_passes == PIPELINE_MAX_SCENE_PASSES {
        log.warnf("Failed to add scene-pass '%v' to renderer's pipeline; hit max capacity (%v).", scene_pass.name, PIPELINE_MAX_SCENE_PASSES)
        return false
    }

    pipeline.scene_passes[pipeline.amount_of_scene_passes] = scene_pass
    pipeline.amount_of_scene_passes += 1

    return true
}

@(private="file") add_post_processing_pass_to_pipeline :: proc(renderer: ^Renderer, post_processing_pass: ^Post_Processing_Pass) -> bool {
    assert(renderer != nil)
    assert(post_processing_pass != nil)

    pipeline := &renderer.pipeline
    
    if pipeline.amount_of_post_processing_passes == PIPELINE_MAX_POST_PROCESSING_PASSES {
        log.warnf("Failed to add post-processing pass '%v' to renderer's pipeline; hit max capacity (%v).", post_processing_pass.name, PIPELINE_MAX_POST_PROCESSING_PASSES)
        return false
    }

    pipeline.post_processing_passes[pipeline.amount_of_post_processing_passes] = post_processing_pass
    pipeline.amount_of_post_processing_passes += 1

    return true
}