rafx-plugins 0.0.16

Rendering framework built on an extensible asset pipeline
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use super::ModernPipelineRenderOptions;
use crate::phases::PostProcessRenderPhase;
use crate::pipelines::modern::graph_generator::luma_pass::LumaAverageHistogramPass;
use crate::pipelines::modern::ModernPipelineOutputColorSpace;
use rafx::api::RafxSwapchainColorSpace;
use rafx::framework::{DescriptorSetBindings, MaterialPassResource, ResourceArc};
use rafx::graph::*;
use rafx::render_features::RenderPhase;
use rafx::renderer::SwapchainRenderResource;

use super::ModernPipelineContext;
use super::EMPTY_VERTEX_LAYOUT;
use crate::shaders::post_adv::bloom_combine_adv_frag;

pub(super) struct BloomCombinePass {
    #[allow(dead_code)]
    pub(super) node: RenderGraphNodeId,
    pub(super) color: RenderGraphImageUsageId,
}

pub(super) fn bloom_combine_pass(
    context: &mut ModernPipelineContext,
    bloom_combine_material_pass: ResourceArc<MaterialPassResource>,
    sdr_image: RenderGraphImageUsageId,
    blurred_color: RenderGraphImageUsageId,
    luma_average_histogram_pass: &LumaAverageHistogramPass,
    swapchain_render_resource: &SwapchainRenderResource,
) -> BloomCombinePass {
    let render_options = context
        .extract_resources
        .fetch::<ModernPipelineRenderOptions>()
        .clone();
    let node = context
        .graph
        .add_renderpass_node("BloomCombine", RenderGraphQueue::DefaultGraphics);

    let color = context.graph.create_color_attachment(
        node,
        0,
        Default::default(),
        RenderGraphImageConstraint {
            format: Some(context.graph_config.swapchain_format),
            ..Default::default()
        },
        Default::default(),
    );
    context.graph.set_image_name(color, "color");

    let sdr_image =
        context
            .graph
            .sample_image(node, sdr_image, Default::default(), Default::default());
    context.graph.set_image_name(sdr_image, "sdr");

    let hdr_image =
        context
            .graph
            .sample_image(node, blurred_color, Default::default(), Default::default());
    context.graph.set_image_name(hdr_image, "hdr");

    let histogram_result = context.graph.read_storage_buffer(
        node,
        luma_average_histogram_pass.histogram_result,
        Default::default(),
    );

    let swapchain_color_space = swapchain_render_resource
        .surface_info()
        .unwrap()
        .swapchain_surface_info
        .color_space;
    let max_color_component_value = swapchain_render_resource.max_color_component_value;

    context.graph.set_renderpass_callback(node, move |args| {
        // Get the color image from before
        let sdr_image = args.graph_context.image_view(sdr_image).unwrap();
        let hdr_image = args.graph_context.image_view(hdr_image).unwrap();
        let histogram_result = args.graph_context.buffer(histogram_result).unwrap();

        // Get the pipeline
        let pipeline = args
            .graph_context
            .resource_context()
            .graphics_pipeline_cache()
            .get_or_create_graphics_pipeline(
                Some(PostProcessRenderPhase::render_phase_index()),
                &bloom_combine_material_pass,
                &args.render_target_meta,
                &EMPTY_VERTEX_LAYOUT,
            )?;

        // Set up a descriptor set pointing at the image so we can sample from it
        let mut descriptor_set_allocator = args
            .graph_context
            .resource_context()
            .create_descriptor_set_allocator();

        let output_color_space = match swapchain_color_space {
            RafxSwapchainColorSpace::Srgb => ModernPipelineOutputColorSpace::Srgb,
            RafxSwapchainColorSpace::SrgbExtended => ModernPipelineOutputColorSpace::Srgb,
            RafxSwapchainColorSpace::DisplayP3Extended => ModernPipelineOutputColorSpace::P3,
        };

        let descriptor_set_layouts = &pipeline.get_raw().descriptor_set_layouts;
        let mut bloom_combine_material_dyn_set = descriptor_set_allocator
            .create_dyn_descriptor_set(
                &descriptor_set_layouts[bloom_combine_adv_frag::IN_COLOR_DESCRIPTOR_SET_INDEX],
                bloom_combine_adv_frag::DescriptorSet0Args {
                    in_color: &sdr_image,
                    in_blur: &hdr_image,
                    config: &bloom_combine_adv_frag::ConfigStd140 {
                        tonemapper_type: render_options.tonemapper_type as i32,
                        output_color_space: output_color_space as i32,
                        max_color_component_value,
                        ..Default::default()
                    },
                },
            )?;

        bloom_combine_material_dyn_set.0.set_buffer(
            bloom_combine_adv_frag::HISTOGRAM_RESULT_DESCRIPTOR_BINDING_INDEX as u32,
            &histogram_result,
        );

        bloom_combine_material_dyn_set.flush(&mut descriptor_set_allocator)?;
        descriptor_set_allocator.flush_changes()?;

        // Draw calls
        let command_buffer = &args.command_buffer;

        command_buffer
            .cmd_bind_pipeline(&*pipeline.get_raw().pipeline)
            .unwrap();
        bloom_combine_material_dyn_set
            .0
            .bind(command_buffer)
            .unwrap();
        command_buffer.cmd_draw(3, 0).unwrap();

        Ok(())
    });

    BloomCombinePass { node, color }
}