Struct rin::graphics::Camera

pub struct Camera { /* fields omitted */ }

Perspective camera that can be positioned and oriented in 3d space as a Node

Implementations

impl Camera

pub fn new(
    eye: Point<f32, U3>,
    look_at: Point<f32, U3>,
    up: Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>,
    fov: Deg<f32>,
    aspect_ratio: f32
) -> Result<Camera, Error>

Create a new camera.

pub fn new_with_frustum(
    eye: Point<f32, U3>,
    look_at: Point<f32, U3>,
    up: Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>,
    fov: Deg<f32>,
    aspect_ratio: f32,
    znear: f32,
    zfar: f32
) -> Result<Camera, Error>

Creates a new camera from frustum values.

pub fn with_pixel_coordinates(
    size: Matrix<i32, U2, U1, <DefaultAllocator as Allocator<i32, U2, U1>>::Buffer>,
    fov: Deg<f32>,
    coordinate_origin: CoordinateOrigin
) -> Camera

Creates an orthographic camera ready to be used in two dimensional applications

The resulting view will have the same coordinates as the passed size and everything drawn at z = 0 within that viewport will be visible at it’s size in pixels

pub fn projection(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Projection matrix

pub fn view(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

View matrix

pub fn projection_view(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Projection * View

pub fn fov(&self) -> Deg<f32>

Vertical field of view

pub fn hfov(&self) -> Deg<f32>

Horizontal field of view

pub fn set_fov(&mut self, fov: Deg<f32>)

Set vertical field of view

pub fn focal_length(&self) -> f32

Return the camera focal length in mm

pub fn set_focal_length(&mut self, f: f32)

Set the focal length in mm

Internally changes the field of view of the camera based on the current sensor width

pub fn set_sensor_width(&mut self, w: f32)

Set the camera sensor width in mm

Internally chanages the field of view of the camera based on the current focal length

pub fn near_far_clip(&self) -> (f32, Option<f32>)

Near and far clip planes as a tuple

pub fn near_clip(&self) -> f32

Near clip

pub fn far_clip(&self) -> Option<f32>

Far clip

pub fn set_near(&mut self, near: f32)

pub fn set_far(&mut self, far: f32)

pub fn set_far_at_infinity(&mut self)

pub fn set_reversed_z(&mut self, reversed_z: bool)

pub fn set_near_far<F>(&mut self, near: f32, far: F) where
    F: Into<Option<f32>>, 

pub fn set_aspect_ratio(&mut self, aspect: f32)

pub fn target(&self) -> &Point<f32, U3>

Target the camera will look at, the target will change if the camera is moved or re-oriented

pub fn set_target(&mut self, target: Point<f32, U3>)

pub fn enable_depth_clamp(&mut self)

Enables depth clamping

Doesn’t really change the projection or view matrices of the camera but can be use as a flag to signal a renderer to do depth clamping.

pub fn disable_depth_clamp(&mut self)

Disables depth clamping

Doesn’t really change the projection or view matrices of the camera but can be use as a flag to signal a renderer to not do depth clamping.

pub fn depth_clamp(&self) -> bool

Returns if depth clamping is enabled

Doesn’t really change the projection or view matrices of the camera but can be use as a flag to signal a renderer to do depth clamping or not.

pub fn far_at_infinity(&self) -> bool

pub fn reversed_z(&self) -> bool

pub fn set_oblique_near_clip_plane<P>(&mut self, plane: P) where
    P: Into<Option<Matrix<f32, U4, U1, <DefaultAllocator as Allocator<f32, U4, U1>>::Buffer>>>, 

Changes the projection matrix to set an oblique clip plane

Useful for reflections / refractions

pub fn oblique_clip_plane(
    &self
) -> Option<&Matrix<f32, U4, U1, <DefaultAllocator as Allocator<f32, U4, U1>>::Buffer>>

pub fn update(&mut self) -> bool

Call every frame to update the camera matrices

Returns true if the camera changed since the last udpate

Trait Implementations

impl CameraExt for Camera

pub fn projection(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

pub fn view(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

pub fn projection_view(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

pub fn fov(&self) -> Option<Deg<f32>>

pub fn width(&self) -> Option<f32>

pub fn near_far_clip(&self) -> (f32, Option<f32>)

pub fn near_clip(&self) -> f32

pub fn far_clip(&self) -> Option<f32>

pub fn set_near(&mut self, near: f32)

pub fn set_far(&mut self, far: f32)

pub fn set_near_far(&mut self, near: f32, far: f32)

pub fn set_aspect_ratio(&mut self, aspect: f32)

pub fn hfov(&self) -> Option<Deg<f32>>

Horizontal field of view

pub fn focal_length(&self) -> Option<f32>

Return the camera focal length

pub fn sensor_width_mm(&self) -> Option<f32>

Return the camera sensor width

pub fn aspect_ratio(&self) -> f32

pub fn target(&self) -> &Point<f32, U3>

pub fn up(
    &self
) -> &Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

pub fn set_target(&mut self, target: Point<f32, U3>)

pub fn enable_depth_clamp(&mut self)

Enables depth clamping

pub fn disable_depth_clamp(&mut self)

Disables depth clamping

pub fn depth_clamp(&self) -> bool

Returns if depth clamping is enabled

pub fn set_reversed_z(&mut self, reversed_z: bool)

pub fn reversed_z(&self) -> bool

pub fn far_at_infinity(&self) -> bool

pub fn update(&mut self) -> bool

impl CameraPerspective for Camera

pub fn set_fov(&mut self, fov: Deg<f32>)

pub fn set_near_with_far_at_infinity(&mut self, near: f32)

impl Clone for Camera

pub fn clone(&self) -> Camera

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Camera

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<Camera, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl NodeMut for Camera

pub fn node_mut(&mut self) -> &mut Node

pub fn update_with_parent_parts(
    &mut self,
    parent_loc: Option<&Node>,
    parent_orientation: Option<&Node>,
    parent_scale: Option<&Node>
) -> bool

Updates the internal matrices including the glonal matrices using the optional parent passed as argument and flags

pub fn look_at(
    &mut self,
    at: &Point<f32, U3>,
    up: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
) -> Result<(), Error>

Changes the orientation of the node to look at the passed position using the up vector

pub fn rotate(
    &mut self,
    angle: Rad<f32>,
    axis: &Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>
)

Rotate this note a certain angle around the axis of rotation

pub fn append_orientation(&mut self, orientation: &Unit<Quaternion<f32>>)

Append the passed quaternion to the current local orientation

pub fn tilt(&mut self, angle: Rad<f32>)

rotate this node around it’s local x axis

pub fn pan(&mut self, angle: Rad<f32>)

rotate this node around it’s local y axis

pub fn roll(&mut self, angle: Rad<f32>)

rotate this node around it’s local z axis

pub fn set_scale(
    &mut self,
    Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
)

Sets the local scale

pub fn translate(
    &mut self,
    t: &Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
)

Append a translation to the current local position

pub fn set_position(&mut self, pos: Point<f32, U3>)

Sets the local position of this node

pub fn set_angle_axis(
    &mut self,
    angle: Rad<f32>,
    axis: &Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>
)

Sets the orientation for this node from an angle and axis of rotation

pub fn set_orientation(&mut self, orientation: Unit<Quaternion<f32>>)

Sets the orientation for this node from a quaternion

pub fn update_with_parent(&mut self, parent: Option<&Node>) -> bool

Updates the internal matrices including the glonal matrices using the optional parent passed as argument

impl NodeRef for Camera

pub fn node(&self) -> &Node

Returns this object’s Node

pub fn position(&self) -> Point<f32, U3>

Returns the local position of this node

pub fn orientation(&self) -> Unit<Quaternion<f32>>

Returns the orientation of this node as a quaternion which is how it’s stored internally

pub fn rotation(&self) -> Rotation<f32, U3>

Returns the orientation of this node as a Rotation3.

pub fn scale(
    &self
) -> Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>

Returns the current local scale

pub fn local_x_axis(
    &self
) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation x axis

pub fn local_y_axis(
    &self
) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation y axis

pub fn local_z_axis(
    &self
) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation z axis

pub fn global_x_axis(
    &self
) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation x axis

pub fn global_y_axis(
    &self
) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation y axis

pub fn global_z_axis(
    &self
) -> Unit<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

The node orientation z axis

pub fn local_transformation(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Local transformation matrix

pub fn global_transformation(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Global transformation matrix

pub fn global_position(&self) -> Point<f32, U3>

Global position of this node

pub fn global_orientation(&self) -> Unit<Quaternion<f32>>

Global orientation of this node

pub fn global_scale(
    &self
) -> Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>

Global scale of this node

pub fn inv_local_transformation(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Inverse local transformation of this node

pub fn inv_global_transformation(
    &self
) -> Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>

Inverse global transformation of this node

impl Serialize for Camera

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.