# queue_system.rs - source
Source of the Rust file `maplibre/src/vector/queue_system.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

    //! Queues [PhaseItems](crate::render::render_phase::PhaseItem) for rendering.
    use crate::{
        context::MapContext,
        render::{
            eventually::{Eventually, Eventually::Initialized},
            render_commands::DrawMasks,
            render_phase::{DrawState, LayerItem, RenderPhase, TileMaskItem},
            tile_view_pattern::WgpuTileViewPattern,
        },
        tcs::tiles::Tile,
        vector::{render_commands::DrawVectorTiles, VectorBufferPool},
    };

    pub fn queue_system(MapContext { world, .. }: &mut MapContext) {
        let Some((
            Initialized(tile_view_pattern),
            Initialized(buffer_pool),
            mask_phase,
            layer_item_phase,
        )) = world.resources.query_mut::<(
            &mut Eventually<WgpuTileViewPattern>,
            &mut Eventually<VectorBufferPool>,
            &mut RenderPhase<TileMaskItem>,
            &mut RenderPhase<LayerItem>,
        )>()
        else {
            return;
        };

        let buffer_pool_index = buffer_pool.index();

        for view_tile in tile_view_pattern.iter() {
            let coords = &view_tile.coords();
            tracing::trace!("Drawing tile at {coords}");

            // draw tile normal or the source e.g. parent or children
            view_tile.render(|source_shape| {
                // Draw masks for all source_shapes
                mask_phase.add(TileMaskItem {
                    draw_function: Box::new(DrawState::<TileMaskItem, DrawMasks>::new()),
                    source_shape: source_shape.clone(),
                });

                if let Some(layer_entries) = buffer_pool_index.get_layers(source_shape.coords()) {
                    for layer_entry in layer_entries {
                        // Draw tile
                        layer_item_phase.add(LayerItem {
                            draw_function: Box::new(DrawState::<LayerItem, DrawVectorTiles>::new()),
                            index: layer_entry.style_layer.index,
                            style_layer: layer_entry.style_layer.id.clone(),
                            tile: Tile {
                                coords: layer_entry.coords,
                            },
                            source_shape: source_shape.clone(),
                        });
                    }
                };
            });
        }
    }