Struct rin::gl::spot_light::SpotLight

pub struct SpotLight { /* fields omitted */ }

A light with a position and a direction that emits light with a cutoff cone

Methods

impl SpotLight

pub fn new() -> SpotLight

Creates a new default spotlight

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

Base color of the light

pub fn set_att_constant(&mut self, att: f32)

Constant attenuation

pub fn set_att_linear(&mut self, att: f32)

Linear attenuation

pub fn set_att_quadratic(&mut self, att: f32)

Quadratic attenuation

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

Strength multiplier of the base color

pub fn set_spot_angle(&mut self, angle: Deg<f32>)

Cutoff angle for the spot

pub fn set_spot_blend(&mut self, blend: f32)

0..1 value that indicates the transition from the center of the spot to the borders

0 will have hard borders while 1 will create a transition from the very center to the borders

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

Cutoff angle for the spot

pub fn strength(&self) -> f32

Strength multiplier of the base color

pub fn data(&self) -> Data

Light data to feed a UBO

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

Reference to this light with one or more shadow maps

When applied to a material will draw any object drawn with it using this light with the passed shadow(s)

Trait Implementations

impl NodeRef for SpotLight

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 SpotLight

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

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 set_scale(&mut self, s: Vec3)

Sets the local scale

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 SpotLight

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

impl Light for SpotLight

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>