Struct rin::gl::DirectionalLight

pub struct DirectionalLight { /* fields omitted */ }

A light with no position that throws parallel rays on a specific direction

Methods

impl DirectionalLight

pub fn new() -> DirectionalLight

Creates a DirectionalLight

pub fn color(&self) -> &Rgb<f32>

Returns the color of this light.

pub fn strength(&self) -> f32

Returns the strength of this light, a multiplier of the color

pub fn radius(&self) -> f32

Radius of the light, defines how soft are the shadows

pub fn set_color<C: ToRgb + ToRgba>(&mut self, color: &C)

pub fn set_strength(&mut self, strength: f32)

pub fn direction(&self) -> Vec3

pub fn set_radius(&mut self, radius: f32)

pub fn data(&self) -> Data

pub fn with_shadow_maps<'l, S: DirectionalShadowMap<G>, G, B: Borrow<S>>(     &'l self,     shadow_maps: Vec<B> ) -> DirectionalLightWithShadowMap<'l, S, G, B>

Combines a reference to this light with one or more shadow maps

When drawing with the returned light, the shadows will be applied

Once can use more than one shadow map to for example draw static geometry in one map and dynamic in another so only the dynamic geometry needs to be redrawn each frame

Trait Implementations

impl NodeRef for DirectionalLight

fn node(&self) -> &Node

Returns this object's Node

fn position(&self) -> Pnt3

Returns the local position of this node

fn orientation(&self) -> UnitQuat

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

fn rotation(&self) -> Rotation3<f32>

Returns the orientation of this node as a Rotation3.

fn scale(&self) -> Vec3

Returns the current local scale

fn x_axis(&self) -> Unit<Vec3>

The node orientation x axis

fn y_axis(&self) -> Unit<Vec3>

The node orientation y axis

fn z_axis(&self) -> Unit<Vec3>

The node orientation z axis

fn local_transformation(&self) -> Mat4

Local transformation matrix

fn global_transformation(&self) -> Mat4

Global transformation matrix

fn global_position(&self) -> Pnt3

Global position of this node

fn global_orientation(&self) -> UnitQuat

Global orientation of this node

fn global_scale(&self) -> Vec3

Global scale of this node

fn inv_local_transformation(&self) -> Mat4

Inverse local transformation of this node

fn inv_global_transformation(&self) -> Mat4

Inverse global transformation of this node

impl NodeMut for DirectionalLight

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

fn set_scale(&mut self, _s: Vec3)

Sets the local scale

fn update_with_parent_flags(     &mut self,     parent: Option<&Node>,     flags: Flags ) -> bool

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

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

fn look_at(&mut self, at: &Pnt3, up: &Vec3)

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

fn rotate(&mut self, angle: Rad<f32>, axis: &Unit<Vec3>)

Rotate this note a certain angle around the axis of rotation

fn append_orientation(&mut self, rot: &UnitQuat)

Append the passed quaternion to the current local orientation

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

rotate this node around it's local x axis

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

rotate this node around it's local y axis

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

rotate this node around it's local z axis

fn translate(&mut self, t: &Vec3)

Append a translation to the current local position

fn set_position(&mut self, pos: Pnt3)

Sets the local position of this node

fn set_angle_axis(&mut self, angle: Rad<f32>, axis: &Unit<Vec3>)

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

fn set_orientation(&mut self, q: UnitQuat)

Sets the orientation for this node from a quaternion

impl Render3d for DirectionalLight

fn render<R: RenderSurface>(&self, gl: &Renderer<R>) where     Self: Sized,

impl Light for DirectionalLight

fn ty(&self) -> &str

Important traits for Vec<u8>

impl Write for Vec<u8>

fn uniforms(&self, _shadow_map_idx_offset: &mut usize) -> Vec<Uniform>

Important traits for Vec<u8>

impl Write for Vec<u8>

fn shadow_maps(&self) -> Vec<&dyn ShadowMap>