Struct Renderer

pub struct Renderer { /* private fields */ }

Implementations

impl Renderer

pub fn screen_vertex_shader(&self) -> &ScreenVertexShader

pub fn register_prepare<R: Module + Prepare>(&mut self, handle: Handle<R>)

This is not ideal, but right now it is a simple way to prepare data using the command encoder of the frame.

pub fn settings_mut(&mut self) -> &mut RendererSettings

Examples found in repository

examples/bloom.rs (line 51)

    fn new(_config: Self::Config, mut deps: Self::Dependencies) -> anyhow::Result<Self> {
        let mut blue_cubes: Vec<Transform> = vec![];
        let mut black_cubes: Vec<Transform> = vec![];

        for x in 0..30 {
            for y in 0..30 {
                for z in 0..30 {
                    let pos = vec3(
                        x as f32 * 2.0 + 20.0 + (z as f32 * 0.1).sin() * 2.0,
                        y as f32 * 2.0 - 30.0 + (z as f32).sin() * 2.0,
                        z as f32 * 2.0 - 30.0 + ((x + y) % 2) as f32,
                    );
                    if (x + y) % 2 == 0 {
                        blue_cubes.push(pos.into());
                    } else {
                        black_cubes.push(pos.into());
                    };
                }
            }
        }

        // use a very high energy green to get a nice background bloom
        deps.renderer.settings_mut().clear_color = Color::new(2.0, 8.0, 2.0);

        Ok(MyState {
            black_cubes,
            blue_cubes,
            camera_orthographic: false,
            deps,
        })
    }

pub fn register_main_pass_renderer<R: Module + MainPassRenderer>( &mut self, handle: Handle<R>, timing: Timing, )

pub fn register_post_processing_effect<R: Module + PostProcessingEffect>( &mut self, handle: Handle<R>, timing: Timing, )

pub fn register_tonemapping_effect<R: Module + PostProcessingEffect>( &mut self, handle: Handle<R>, )

pub fn register_surface_renderer<R: Module + SdrSurfaceRenderer>( &mut self, handle: Handle<R>, timing: Timing, )

registers a renderer that renders to the sdr surface after all post processing and tonemapping has been done. good for e.g. ui with egui.

Trait Implementations

impl Module for Renderer

type Config = RendererSettings

Some initial data that configures the module. Provided by the User when adding a module to an app.

type Dependencies = RendererDependencies

Other modules that are expected to be part of the app. Provided automatically during app setup, where the program resolves which dependencies each module has.

fn new(settings: Self::Config, deps: Self::Dependencies) -> Result<Self>

creates this module

fn intialize(handle: Handle<Self>) -> Result<()>

Is run once, after all modules have been initialized. This function is optional, it is given a handle to the module itself. other modules can be accessed if you cache the handles to them in the new() function. E.g. the LineRenderer could register its own handle (Handle) with a general Renderer module, if a Handle<Renderer> was part of the Self::Dependencies and cached in the new function. E.g. LineRenderer could have a field renderer: Handle<Renderer> that is populated in new.