Struct Camera

pub struct Camera {
    pub resolution: (usize, usize),
    pub fov_vertical: f32,
    pub fov_horizontal: f32,
    pub vertical_focal_length: f32,
    pub horizontal_focal_length: f32,
    pub near: f32,
    pub far: f32,
    pub aspect_ratio: f32,
    pub ray_directions: Vec<Vector3<f32>>,
    pub depth_buffer: Vec<f32>,
}

Represents a camera in the simulation which is used to render the depth of the scene

Example

use peng_quad::Camera;
let camera = Camera::new((800, 600), 60.0, 0.1, 100.0);

Fields

resolution: (usize, usize)

The resolution of the camera

fov_vertical: f32

The vertical field of view of the camera

fov_horizontal: f32

The horizontal field of view of the camera

vertical_focal_length: f32

The vertical focal length of the camera

horizontal_focal_length: f32

The horizontal focal length of the camera

near: f32

The near clipping plane of the camera

far: f32

The far clipping plane of the camera

aspect_ratio: f32

The aspect ratio of the camera

ray_directions: Vec<Vector3<f32>>

The ray directions of each pixel in the camera

depth_buffer: Vec<f32>

Depth buffer

Implementations

impl Camera

Implementation of the camera

pub fn new( resolution: (usize, usize), fov_vertical: f32, near: f32, far: f32, ) -> Self

Creates a new camera with the given resolution, field of view, near and far clipping planes

Arguments

• resolution - The resolution of the camera
• fov_vertical - The vertical field of view of the camera
• near - The near clipping plane of the camera
• far - The far clipping plane of the camera

Returns

• The new camera instance

Example

use peng_quad::Camera;
let camera = Camera::new((800, 600), 1.0, 5.0, 120.0);

pub fn render_depth( &mut self, quad_position: &Vector3<f32>, quad_orientation: &UnitQuaternion<f32>, maze: &Maze, use_multi_threading: bool, ) -> Result<(), SimulationError>

Renders the depth of the scene from the perspective of the quadrotor

When the depth value is out of the near and far clipping planes, it is set to infinity When the resolution is larger than 32x24, multi-threading can accelerate the rendering

Arguments

• quad_position - The position of the quadrotor
• quad_orientation - The orientation of the quadrotor
• maze - The maze in the scene
• use_multi_threading - Whether to use multi-threading to render the depth

Errors

• If the depth buffer is not large enough to store the depth values

Example

use peng_quad::{Camera, Maze};
use nalgebra::{Vector3, UnitQuaternion};
let mut camera = Camera::new((800, 600), 60.0, 0.1, 100.0);
let quad_position = Vector3::new(0.0, 0.0, 0.0);
let quad_orientation = UnitQuaternion::identity();
let mut maze = Maze::new([-1.0, -1.0, -1.0], [1.0, 1.0, 1.0], 5, [0.1, 0.1, 0.1], [0.1, 0.5]);
let use_multi_threading = true;
camera.render_depth(&quad_position, &quad_orientation, &maze, use_multi_threading);
let use_multi_threading = false;
camera.render_depth(&quad_position, &quad_orientation, &maze, use_multi_threading);