Struct bevy::pbr::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

The color of this light source.

intensity: f32

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

range: f32

Cut-off for the light’s area-of-effect. Fragments outside this range will not be affected by this light at all, so it’s important to tune this together with intensity to prevent hard lighting cut-offs.

radius: f32

Simulates a light source coming from a spherical volume with the given radius. Only affects the size of specular highlights created by this light. Because of this, large values may not produce the intended result – for example, light radius does not affect shadow softness or diffuse lighting.

shadows_enabled: bool

Whether this light casts shadows.

shadow_depth_bias: f32

A bias used when sampling shadow maps to avoid “shadow-acne”, or false shadow occlusions that happen as a result of shadow-map fragments not mapping 1:1 to screen-space fragments. Too high of a depth bias can lead to shadows detaching from their casters, or “peter-panning”. This bias can be tuned together with shadow_normal_bias to correct shadow artifacts for a given scene.

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.0799999982f32

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,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_component_hooks(_hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

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 + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

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 + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Reflect for PointLight

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

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 try_apply( &mut self, value: &(dyn Reflect + 'static) ) -> Result<(), ApplyError>

Tries to apply 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 apply(&mut self, value: &(dyn Reflect + 'static))

Applies a reflected value to this value.

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 + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

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 + RegisterForReflection, f32: FromReflect + TypePath + RegisterForReflection, bool: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for PointLight