Struct blue_engine::Camera

pub struct Camera {
    pub position: Vec3,
    pub target: Vec3,
    pub up: Vec3,
    pub resolution: (f32, f32),
    pub projection: Projection,
    pub near: f32,
    pub far: f32,
    pub view_data: Mat4,
    pub uniform_data: UniformBuffers,
    /* private fields */
}

Container for the camera feature. The settings here are needed for algebra equations needed for camera vision and movement. Please leave it to the renderer to handle

Fields

position: Vec3

The position of the camera in 3D space

target: Vec3

The target at which the camera should be looking

up: Vec3

The up vector of the camera. This defines the elevation of the camera

resolution: (f32, f32)

The resolution of the camera view

projection: Projection

The projection of the camera

near: f32

The closest view of camera

far: f32

The furthest view of camera

view_data: Mat4

The final data that will be sent to GPU

uniform_data: UniformBuffers

The uniform data of the camera to be sent to the gpu

Implementations

impl Camera

pub fn new( window_size: PhysicalSize<u32>, renderer: &mut Renderer ) -> Result<Self>

Creates a new camera. this should’ve been automatically done at the time of creating an engine

pub fn build_view_projection_matrix(&mut self) -> Result<()>

Updates the view uniform matrix that decides how camera works

pub fn build_view_orthographic_matrix(&mut self) -> Result<()>

Updates the view uniform matrix that decides how camera works

pub fn camera_uniform_buffer(&self) -> Result<Matrix>

Returns a matrix uniform buffer from camera data that can be sent to GPU

pub fn set_position(&mut self, x: f32, y: f32, z: f32) -> Result<()>

Sets the position of camera

Examples found in repository

examples/shapes/cube.rs (line 28)

fn main() {
    let mut engine = Engine::new().expect("win");

    cube("Cube", &mut engine.renderer, &mut engine.objects).unwrap();
    engine
        .objects
        .get_mut("Cube")
        .unwrap()
        .set_color(0f32, 0f32, 1f32, 1f32)
        .unwrap();

    let radius = 5f32;
    let start = std::time::SystemTime::now();
    engine
        .update_loop(move |_, _, _, _, camera, _| {
            let camx = start.elapsed().unwrap().as_secs_f32().sin() * radius;
            let camy = start.elapsed().unwrap().as_secs_f32().sin() * radius;
            let camz = start.elapsed().unwrap().as_secs_f32().cos() * radius;
            camera
                .set_position(camx, camy, camz)
                .expect("Couldn't update the camera eye");
        })
        .expect("Error during update loop");
}

examples/camera/rotate_around.rs (line 43)

fn main() {
    // Create the engine
    let mut engine = Engine::new().expect("win");

    // create a square
    square(
        // let's give it a name
        "Rotating Square",
        ObjectSettings {
            // and set the size
            // we need it to not cull it's back face so that it's visible on both side
            shader_settings: ShaderSettings {
                cull_mode: None,
                ..Default::default()
            },
            // and have default settings for the rest
            ..Default::default()
        },
        &mut engine.renderer,
        &mut engine.objects,
    )
    .unwrap();

    let radius = 2f32;
    let start = std::time::SystemTime::now();

    engine
        .update_loop(move |_, _, _, _, camera, _| {
            let camx = start.elapsed().unwrap().as_secs_f32().sin() * radius;
            let camz = start.elapsed().unwrap().as_secs_f32().cos() * radius;
            camera
                .set_position(camx, 0.0, camz)
                .expect("Couldn't update the camera eye");
        })
        .expect("Error during update loop");
}

pub fn set_target(&mut self, x: f32, y: f32, z: f32) -> Result<()>

Sets the target of camera

pub fn set_up(&mut self, x: f32, y: f32, z: f32) -> Result<()>

Sets the up of camera

pub fn set_far(&mut self, new_far: f32) -> Result<()>

Sets how far camera can look

pub fn set_near(&mut self, new_near: f32) -> Result<()>

Sets how near the camera can look

pub fn set_resolution(&mut self, window_size: PhysicalSize<u32>) -> Result<()>

Sets the aspect ratio of the camera

pub fn set_projection(&mut self, projection: Projection) -> Result<()>

Sets the projection of the camera

pub fn add_position_and_target(&mut self, enable: bool)

Enables adding position and target for the view target

pub fn update_view_projection(&mut self, renderer: &mut Renderer) -> Result<()>

This builds a uniform buffer data from camera view data that is sent to the GPU in next frame

pub fn update_view_projection_and_return( &mut self, renderer: &mut Renderer ) -> Result<UniformBuffers>

This builds a uniform buffer data from camera view data that is sent to the GPU in next frame, and returns the bindgroup

pub fn build_view_matrix(&self) -> Mat4

Builds a view matrix for camera projection

pub fn build_projection_matrix(&self) -> Mat4

Builds a projection matrix for camera

Trait Implementations

impl Debug for Camera

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

Formats the value using the given formatter.

impl Send for Camera

impl Sync for Camera