Struct blue_engine::Renderer

pub struct Renderer {

    pub surface: Option<Surface<'static>>,
    pub instance: Instance,
    pub adapter: Adapter,
    pub device: Device,
    pub queue: Queue,
    pub config: SurfaceConfiguration,
    pub size: PhysicalSize<u32>,
    pub texture_bind_group_layout: BindGroupLayout,
    pub default_uniform_bind_group_layout: BindGroupLayout,
    pub depth_buffer: (Texture, TextureView, Sampler),
    pub default_data: Option<(Textures, Shaders, UniformBuffers)>,
    pub camera: Option<UniformBuffers>,
    pub clear_color: Color,
    pub scissor_rect: Option<(u32, u32, u32, u32)>,
}

Main renderer class. this will contain all methods and data related to the renderer

Fields

surface: Option<Surface<'static>>

A wgpu::Surface represents a platform-specific surface (e.g. a window) onto which rendered images may be presented.

instance: Instance

Context for all of the gpu objects

adapter: Adapter

Handle to a physical graphics and/or compute device.

device: Device

Open connection to a graphics and/or compute device.

queue: Queue

Handle to a command queue on a device.

config: SurfaceConfiguration

Describes a wgpu::Surface

size: PhysicalSize<u32>

The size of the window

texture_bind_group_layout: BindGroupLayout

The texture bind group layout

default_uniform_bind_group_layout: BindGroupLayout

The uniform bind group layout

depth_buffer: (Texture, TextureView, Sampler)

The depth buffer, used to render object depth

default_data: Option<(Textures, Shaders, UniformBuffers)>

The default data used within the renderer

camera: Option<UniformBuffers>

The camera used in the engine

clear_color: Color

Background clear color

scissor_rect: Option<(u32, u32, u32, u32)>

Scissor cut section of the screen to render to (x, y, width, height)

Implementations

impl Renderer

pub fn build_pipeline( &mut self, shader: Shaders, vertex_buffer: VertexBuffers, texture: Textures, uniform: Option<UniformBuffers> ) -> Result<Pipeline>

Creates a new render pipeline. Could be thought of as like materials in game engines.

pub fn build_shader( &mut self, name: impl StringBuffer, shader_source: String, uniform_layout: Option<&BindGroupLayout>, settings: ShaderSettings ) -> Result<Shaders>

Creates a shader group, the input must be spir-v compiled vertex and fragment shader

pub fn build_texture( &mut self, name: impl StringBuffer, texture_data: TextureData, texture_mode: TextureMode ) -> Result<Textures>

Creates a new texture data

Examples found in repository

examples/utils/resource_sharing.rs (lines 17-21)

fn main() {
    // Start the engine
    let mut engine = Engine::new().expect("window not initialized");

    // build a texture as an example of resource to be shared
    let texture = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    // build your main object with the texture
    square(
        "main",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of main square");

    // add the texture to the main object as normally would
    engine
        .objects
        .get_mut("main")
        .unwrap()
        .set_texture(texture)
        .expect("Error during inserting texture to the main square");
    // set position to make it visible
    engine
        .objects
        .get_mut("main")
        .expect("Error during setting the position of the main square")
        .set_position(-1.5f32, 0f32, 0f32);

    // create another object where you want to get resources shared with
    square(
        "alt",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of alt square");

    // here you can use `reference_texture` to reference the texture from the main object
    engine
        .objects
        .get_mut("alt")
        .expect("Error during copying texture of the main square")
        .reference_texture("main");
    // setting position again to make it visible
    engine
        .objects
        .get_mut("alt")
        .expect("Error during setting the position of the alt square")
        .set_position(1.5f32, 0f32, 0f32);

    engine
        .update_loop(move |_, _, _, _, _, _| {})
        .expect("Error during update loop");
}

examples/dev/dev.rs (lines 24-28)

fn main() {
    let mut engine = Engine::new_config(blue_engine::WindowDescriptor {
        power_preference: blue_engine::PowerPreference::LowPower,
        present_mode: blue_engine::wgpu::PresentMode::Immediate,
        ..Default::default()
    })
    .expect("win");

    //let test_instance = Instance::default();
    //println!("{:?}", test_instance.to_raw());

    let texture = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();
    let texture2 = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/player.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    let texture3 = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/image.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    square(
        "main",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );

    engine.objects.get_mut("main").unwrap().set_texture(texture);
    engine
        .objects
        .get_mut("main")
        .unwrap()
        .set_position(-1f32, 0f32, 0f32);

    square(
        "alt",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );
    engine.objects.get_mut("alt").unwrap().set_texture(texture2);
    engine
        .objects
        .get_mut("alt")
        .unwrap()
        .set_position(0.2f32, 0f32, 0.001f32);

    square(
        "alt2",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );
    engine
        .objects
        .get_mut("alt2")
        .unwrap()
        .set_texture(texture3);
    engine
        .objects
        .get_mut("alt2")
        .unwrap()
        .set_position(-0.2f32, 0f32, 0.001f32);

    let speed = -0.05;

    let mut last_time = std::time::Instant::now();
    let mut frames = 0;
    engine
        .update_loop(move |renderer, _window, objects, input, camera, plugins| {
            // calculate FPS
            let current_time = std::time::Instant::now();
            frames += 1;
            if current_time - last_time >= std::time::Duration::from_secs(1) {
                println!("{}ms/frame", 1000f32 / frames as f32);
                frames = 0;
                last_time = current_time;
            }

            let sprite = objects.get_mut("alt").unwrap();

            if input.key_held(blue_engine::KeyCode::ArrowUp) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y - speed,
                    sprite.position.z,
                );
                //lm.ambient_color.data = [1f32, 1f32, 1f32, 1f32];
            }
            if input.key_held(blue_engine::KeyCode::ArrowDown) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y + speed,
                    sprite.position.z,
                );
                //lm.ambient_color.data = [0.1f32, 0.1f32, 0.1f32, 1f32];
            }

            if input.key_held(blue_engine::KeyCode::ArrowLeft) {
                sprite.set_position(
                    sprite.position.x + speed,
                    sprite.position.y,
                    sprite.position.z,
                );
            }
            if input.key_held(blue_engine::KeyCode::ArrowRight) {
                sprite.set_position(
                    sprite.position.x - speed,
                    sprite.position.y,
                    sprite.position.z,
                );
            }

            if input.key_held(blue_engine::KeyCode::KeyE) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y,
                    sprite.position.z + speed,
                );
            }
            if input.key_held(blue_engine::KeyCode::KeyQ) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y,
                    sprite.position.z - speed,
                );
            }
        })
        .expect("Error during update loop");
}

pub fn build_uniform_buffer_part<T: Zeroable + Pod>( &self, name: impl StringBuffer, value: T ) -> Buffer

Creates a new uniform buffer part

This function doesn’t build the entire uniform buffers list, but rather only one of them

pub fn build_uniform_buffer( &mut self, uniforms: &Vec<Buffer> ) -> Result<(UniformBuffers, BindGroupLayout)>

Creates a new uniform buffer group, according to a list of types

pub fn build_vertex_buffer( &mut self, vertices: &Vec<Vertex>, indices: &Vec<u16> ) -> Result<VertexBuffers>

Creates a new vertex buffer and indices

pub fn build_instance(&self, instance_data: Vec<InstanceRaw>) -> Buffer

Creates a new instance buffer for the object

impl Renderer

pub fn build_object( &mut self, name: impl StringBuffer, vertices: Vec<Vertex>, indices: Vec<u16>, settings: ObjectSettings ) -> Result<Object>

Creates a new object

Is used to define a new object and add it to the storage. This offers full customizability and a framework for in-engine shapes to be developed.

Arguments

• name - The name of the object.
• vertices - A list of vertices for the object to draw with
• indices - A list of indices that references the vertices, defining draw order
• settings - The settings of the object

Trait Implementations

impl Debug for Renderer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Send for Renderer

impl Sync for Renderer