# render_commands.rs - source
Source of the Rust file `maplibre/src/debug/render_commands.rs`.

    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

    //! Specifies the instructions which are going to be sent to the GPU. Render commands can be concatenated
    //! into a new render command which executes multiple instruction sets.
    use crate::{
        debug::{DebugPipeline, TileDebugItem},
        render::{
            eventually::{Eventually, Eventually::Initialized},
            render_phase::{PhaseItem, RenderCommand, RenderCommandResult},
            resource::TrackedRenderPass,
            tile_view_pattern::WgpuTileViewPattern,
        },
        tcs::world::World,
    };

    pub struct SetDebugPipeline;
    impl<P: PhaseItem> RenderCommand<P> for SetDebugPipeline {
        fn render<'w>(
            world: &'w World,
            _item: &P,
            pass: &mut TrackedRenderPass<'w>,
        ) -> RenderCommandResult {
            let Some(Initialized(pipeline)) = world.resources.get::<Eventually<DebugPipeline>>() else {
                return RenderCommandResult::Failure;
            };

            pass.set_render_pipeline(pipeline);
            RenderCommandResult::Success
        }
    }

    pub struct DrawDebugOutline;
    impl RenderCommand<TileDebugItem> for DrawDebugOutline {
        fn render<'w>(
            world: &'w World,
            item: &TileDebugItem,
            pass: &mut TrackedRenderPass<'w>,
        ) -> RenderCommandResult {
            let Some(Initialized(tile_view_pattern)) =
                world.resources.get::<Eventually<WgpuTileViewPattern>>()
            else {
                return RenderCommandResult::Failure;
            };

            let source_shape = &item.source_shape;

            let tile_view_pattern_buffer = source_shape
                .buffer_range()
                .expect("tile_view_pattern needs to be uploaded first"); // FIXME tcs
            pass.set_vertex_buffer(
                0,
                tile_view_pattern.buffer().slice(tile_view_pattern_buffer),
            );

            const TILE_MASK_SHADER_VERTICES: u32 = 24;
            pass.draw(0..TILE_MASK_SHADER_VERTICES, 0..1);

            RenderCommandResult::Success
        }
    }

    pub type DrawDebugOutlines = (SetDebugPipeline, DrawDebugOutline);