# main_pass.rs - source
Source of the Rust file `maplibre/src/render/main_pass.rs`.
Keywords: rust, rustlang, rust-lang

      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

    //! The main render pass for this application.
    //!
    //! Right now there is only one render graph. A use case for multiple render passes would be
    //! [shadows](https://www.raywenderlich.com/books/metal-by-tutorials/v2.0/chapters/14-multipass-deferred-rendering).

    use crate::render::graph::{Node, NodeRunError, RenderContext, RenderGraphContext, SlotInfo};
    use crate::render::render_commands::{DrawMasks, DrawTiles};
    use crate::render::render_phase::{PhaseItem, RenderCommand};
    use crate::render::resource::TrackedRenderPass;
    use crate::render::util::FloatOrd;
    use crate::render::Eventually::Initialized;
    use crate::render::{draw_graph, main_graph, RenderState};
    use std::ops::{Deref, Range};

    pub mod graph {
        // Labels for input nodes
        pub mod input {}
        // Labels for non-input nodes
        pub mod node {
            pub const MAIN_PASS_DEPENDENCIES: &str = "main_pass_dependencies";
            pub const MAIN_PASS_DRIVER: &str = "main_pass_driver";
        }
    }

    pub struct MainPassNode {}

    impl MainPassNode {
        pub fn new() -> Self {
            Self {}
        }
    }

    impl Node for MainPassNode {
        fn input(&self) -> Vec<SlotInfo> {
            vec![]
        }

        fn update(&mut self, _state: &mut RenderState) {}

        fn run(
            &self,
            _graph: &mut RenderGraphContext,
            render_context: &mut RenderContext,
            state: &RenderState,
        ) -> Result<(), NodeRunError> {
            let (render_target, multisampling_texture, depth_texture) = if let (
                Initialized(render_target),
                Initialized(multisampling_texture),
                Initialized(depth_texture),
            ) = (
                &state.render_target,
                &state.multisampling_texture,
                &state.depth_texture,
            ) {
                (render_target, multisampling_texture, depth_texture)
            } else {
                return Ok(());
            };

            let color_attachment = if let Some(texture) = multisampling_texture {
                wgpu::RenderPassColorAttachment {
                    view: &texture.view,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
                        store: true,
                    },
                    resolve_target: Some(render_target.deref()),
                }
            } else {
                wgpu::RenderPassColorAttachment {
                    view: render_target.deref(),
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
                        store: true,
                    },
                    resolve_target: None,
                }
            };

            let render_pass =
                render_context
                    .command_encoder
                    .begin_render_pass(&wgpu::RenderPassDescriptor {
                        label: None,
                        color_attachments: &[color_attachment],
                        depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                            view: &depth_texture.view,
                            depth_ops: Some(wgpu::Operations {
                                load: wgpu::LoadOp::Clear(0.0),
                                store: true,
                            }),
                            stencil_ops: Some(wgpu::Operations {
                                load: wgpu::LoadOp::Clear(0),
                                store: true,
                            }),
                        }),
                    });

            let mut tracked_pass = TrackedRenderPass::new(render_pass);

            for item in &state.mask_phase.items {
                DrawMasks::render(state, item, &mut tracked_pass);
            }

            for item in &state.tile_phase.items {
                DrawTiles::render(state, item, &mut tracked_pass);
            }
            Ok(())
        }
    }

    pub struct MainPassDriverNode;

    impl Node for MainPassDriverNode {
        fn run(
            &self,
            graph: &mut RenderGraphContext,
            _render_context: &mut RenderContext,
            _state: &RenderState,
        ) -> Result<(), NodeRunError> {
            graph.run_sub_graph(draw_graph::NAME, vec![])?;

            Ok(())
        }
    }