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

    use crate::{
        render::{
            error::RenderError,
            settings::{RendererSettings, WgpuSettings},
            Renderer,
        },
        window::{HeadedMapWindow, MapWindowConfig},
    };

    #[derive(Clone)]
    pub struct RendererBuilder {
        wgpu_settings: Option<WgpuSettings>,
        renderer_settings: Option<RendererSettings>,
    }

    impl RendererBuilder {
        pub fn new() -> Self {
            Self {
                wgpu_settings: None,
                renderer_settings: None,
            }
        }

        pub fn with_renderer_settings(mut self, renderer_settings: RendererSettings) -> Self {
            self.renderer_settings = Some(renderer_settings);
            self
        }

        pub fn with_wgpu_settings(mut self, wgpu_settings: WgpuSettings) -> Self {
            self.wgpu_settings = Some(wgpu_settings);
            self
        }

        pub fn build(self) -> UninitializedRenderer {
            UninitializedRenderer {
                wgpu_settings: self.wgpu_settings.unwrap_or_default(),
                renderer_settings: self.renderer_settings.unwrap_or_default(),
            }
        }
    }

    impl Default for RendererBuilder {
        fn default() -> Self {
            Self::new()
        }
    }

    pub enum InitializationResult {
        Initialized(InitializedRenderer),
        Uninitialized(UninitializedRenderer),
        Gone,
    }

    impl Default for InitializationResult {
        fn default() -> Self {
            Self::Gone
        }
    }

    impl InitializationResult {
        pub fn unwrap_renderer(self) -> InitializedRenderer {
            match self {
                InitializationResult::Initialized(renderer) => renderer,
                InitializationResult::Uninitialized(_) => panic!("Renderer is not initialized"),
                InitializationResult::Gone => panic!("Initialization context is gone"),
            }
        }

        pub fn into_option(self) -> Option<Renderer> {
            match self {
                InitializationResult::Initialized(InitializedRenderer { renderer, .. }) => {
                    Some(renderer)
                }
                InitializationResult::Uninitialized(_) => None,
                InitializationResult::Gone => panic!("Initialization context is gone"),
            }
        }
    }

    pub struct UninitializedRenderer {
        pub wgpu_settings: WgpuSettings,
        pub renderer_settings: RendererSettings,
    }

    impl UninitializedRenderer {
        /// Initializes the whole rendering pipeline for the given configuration.
        /// Returns the initialized map, ready to be run.
        pub async fn initialize_renderer<MWC>(
            self,
            existing_window: &MWC::MapWindow,
        ) -> Result<InitializationResult, RenderError>
        where
            MWC: MapWindowConfig,
            <MWC as MapWindowConfig>::MapWindow: HeadedMapWindow,
        {
            let renderer = Renderer::initialize(
                existing_window,
                self.wgpu_settings.clone(),
                self.renderer_settings,
            )
            .await?;
            Ok(InitializationResult::Initialized(InitializedRenderer {
                renderer,
            }))
        }
    }

    #[cfg(feature = "headless")]
    impl UninitializedRenderer {
        pub(crate) async fn initialize_headless<MWC>(
            self,
            existing_window: &MWC::MapWindow,
        ) -> Result<Renderer, RenderError>
        where
            MWC: MapWindowConfig,
        {
            Renderer::initialize_headless(
                existing_window,
                self.wgpu_settings.clone(),
                self.renderer_settings,
            )
            .await
        }
    }

    pub struct InitializedRenderer {
        pub renderer: Renderer,
    }