Struct Renderer 

pub struct Renderer {
    pub renderer_resources: RendererResources,
    pub ui_renderer: UiRenderer,
    pub debug_renderer: DebugRenderer,
    pub screen_space_debug_renderer: DebugRenderer,
    pub scene_data_map: FxHashMap<Handle<Scene>, SceneRenderData>,
    pub texture_cache: TextureCache,
    pub uniform_buffer_cache: UniformBufferCache,
    pub ui_frame_buffers: FxHashMap<u64, GpuFrameBuffer>,
    pub dynamic_surface_cache: DynamicSurfaceCache,
    pub visibility_cache: VisibilityCache,
    pub server: SharedGraphicsServer,
    /* private fields */
}

See module docs.

Fields

renderer_resources: RendererResources

A set of textures of certain kinds that could be used as a stub in cases when you don’t have your own texture of this kind.

ui_renderer: UiRenderer

User interface renderer.

debug_renderer: DebugRenderer

Debug renderer instance can be used for debugging purposes

screen_space_debug_renderer: DebugRenderer

Screen space debug renderer instance can be used for debugging purposes to draw lines directly on screen. It is useful to debug some rendering algorithms.

scene_data_map: FxHashMap<Handle<Scene>, SceneRenderData>

A set of associated data for each scene that was rendered.

texture_cache: TextureCache

Texture cache with GPU textures.

uniform_buffer_cache: UniformBufferCache

Uniform buffer cache.

ui_frame_buffers: FxHashMap<u64, GpuFrameBuffer>

TextureId -> FrameBuffer mapping. This mapping is used for temporal frame buffers like ones used to render UI instances.

dynamic_surface_cache: DynamicSurfaceCache

Dynamic surface cache. See DynamicSurfaceCache docs for more info.

visibility_cache: VisibilityCache

Visibility cache based on occlusion query.

server: SharedGraphicsServer

Graphics server.

Implementations

impl Renderer

pub fn new( server: Rc<dyn GraphicsServer>, frame_size: (u32, u32), resource_manager: &ResourceManager, ) -> Result<Self, EngineError>

Creates a new renderer with the given graphics server.

pub fn add_render_pass(&mut self, pass: Rc<RefCell<dyn SceneRenderPass>>)

Adds a custom render pass.

pub fn remove_render_pass(&mut self, pass: Rc<RefCell<dyn SceneRenderPass>>)

Removes specified render pass.

pub fn render_passes(&self) -> &[Rc<RefCell<dyn SceneRenderPass>>]

Returns a slice with every registered render passes.

pub fn clear_render_passes(&mut self)

Removes all render passes from the renderer.

pub fn get_statistics(&self) -> Statistics

Returns statistics for last frame.

pub fn unload_texture(&mut self, texture: &TextureResource)

Unloads texture from GPU memory.

pub fn set_backbuffer_clear_color(&mut self, color: Color)

Sets color which will be used to fill screen when there is nothing to render.

pub fn graphics_server(&self) -> &dyn GraphicsServer

Returns a reference to current graphics server.

pub fn get_frame_size(&self) -> (u32, u32)

Returns current (width, height) pair of back buffer size.

pub fn get_frame_bounds(&self) -> Vector2<f32>

Returns current bounds of back buffer.

pub fn set_quality_settings( &mut self, settings: &QualitySettings, ) -> Result<(), FrameworkError>

Sets new quality settings for renderer. Never call this method in a loop, otherwise you may get significant lags. Always check if current quality setting differs from new!

pub fn get_quality_settings(&self) -> QualitySettings

Returns current quality settings.

pub fn flush(&mut self)

Removes all cached GPU data, forces renderer to re-upload data to GPU. Do not call this method until you absolutely need! It may cause significant performance lag!

pub fn render_ui( &mut self, render_info: UiRenderInfo<'_>, ) -> Result<(), FrameworkError>

Renders the given UI into specified render target. This method is especially useful if you need to have off-screen UIs. This method will render the specified UI to the given render target. If the render target is not specified (set to None), the UI will be rendered directly on screen. Keep in mind that ideally, the resolution of the render target should match the screen size of the UI. Otherwise, the rendered image will have some sort of aliasing issues.

pub fn update_caches(&mut self, resource_manager: &ResourceManager, dt: f32)

Update caches - this will remove timed out resources.

Normally, this is called from Engine::update(). You should only call this manually if you don’t use that method.

pub fn render_scene( &mut self, scene_handle: Handle<Scene>, scene: &Scene, elapsed_time: f32, dt: f32, resource_manager: &ResourceManager, ) -> Result<&SceneRenderData, FrameworkError>

Unconditionally renders a scene and returns a reference to a RenderDataContainer instance that contains rendered data (including intermediate data, such as G-Buffer content, etc.).