Struct bevy::prelude::PointLight

pub struct PointLight {
    pub color: Color,
    pub intensity: f32,
    pub range: f32,
    pub radius: f32,
    pub shadows_enabled: bool,
    pub shadow_depth_bias: f32,
    pub shadow_normal_bias: f32,
}

A light that emits light in all directions from a central point.

Real-world values for intensity (luminous power in lumens) based on the electrical power consumption of the type of real-world light are:

Luminous Power (lumen) (i.e. the intensity member)	Incandescent non-halogen (Watts)	Incandescent halogen (Watts)	Compact fluorescent (Watts)	LED (Watts
200	25		3-5	3
450	40	29	9-11	5-8
800	60		13-15	8-12
1100	75	53	18-20	10-16
1600	100	72	24-28	14-17
2400	150		30-52	24-30
3100	200		49-75	32
4000	300		75-100	40.5

Source: Wikipedia

Fields

color: Color

intensity: f32

Luminous power in lumens, representing the amount of light emitted by this source in all directions.

range: f32

radius: f32

shadows_enabled: bool

shadow_depth_bias: f32

shadow_normal_bias: f32

A bias applied along the direction of the fragment’s surface normal. It is scaled to the shadow map’s texel size so that it can be small close to the camera and gets larger further away.

Implementations

impl PointLight

pub const DEFAULT_SHADOW_DEPTH_BIAS: f32 = 0.0199999996f32

pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.600000024f32

Trait Implementations

impl Clone for PointLight

fn clone(&self) -> PointLight

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for PointLight

where PointLight: Send + Sync + 'static,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either TableStorage or SparseStorage.

impl Debug for PointLight

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

Formats the value using the given formatter.

impl Default for PointLight

fn default() -> PointLight

Returns the “default value” for a type.

impl FromReflect for PointLight

where PointLight: Any + Send + Sync, Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<PointLight>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for PointLight

where PointLight: Any + Send + Sync, Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl Reflect for PointLight

where PointLight: Any + Send + Sync, Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn into_any(self: Box<PointLight>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<PointLight>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, value: &(dyn Reflect + 'static))

Applies a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<PointLight>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Struct for PointLight

where PointLight: Any + Send + Sync, Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field named name as a &dyn Reflect.

fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for PointLight

where PointLight: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for PointLight

where PointLight: Any + Send + Sync, Color: FromReflect + TypePath, f32: FromReflect + TypePath, bool: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for PointLight