Enum fyrox::scene::base::Mobility

#[repr(u32)]
pub enum Mobility {
    Static = 0,
    Stationary = 1,
    Dynamic = 2,
}

Mobility defines a group for scene node which has direct impact on performance and capabilities of nodes.

Variants

Static = 0

Transform cannot be changed.

Scene and performance.

Nodes with Static mobility should be used all the time you need unchangeable node. Such nodes will have maximum optimization during the rendering.

Meshes

Static meshes will be baked into larger blocks to reduce draw call count per frame. Also static meshes will participate in lightmap generation.

Lights

Static lights will be baked in lightmap. They lit only static geometry! Specular lighting is not supported.

Stationary = 1

Transform cannot be changed, but other node-dependent properties are changeable.

Scene and performance.

Meshes

Same as Static.

Lights

Stationary lights have complex route for shadows:

• Shadows from Static/Stationary meshes will be baked into lightmap.
• Shadows from Dynamic lights will be re-rendered each frame into shadow map. Stationary lights support specular lighting.

Dynamic = 2

Transform can be freely changed.

Scene and performance.

Dynamic mobility should be used only for the objects that are designed to be moving in the scene, for example - objects with physics, or dynamic lights, etc.

Trait Implementations

impl AsRef<str> for Mobility

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Mobility

fn clone(&self) -> Mobility

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Mobility

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

Formats the value using the given formatter.

impl FromStr for Mobility

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Mobility, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl Ord for Mobility

fn cmp(&self, other: &Mobility) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Mobility

fn eq(&self, other: &Mobility) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Mobility

fn partial_cmp(&self, other: &Mobility) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Reflect for Mobilitywhere Self: 'static,

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn fields_info(&self, func: &mut dyn FnMut(Vec<FieldInfo<'_, '_>>))

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

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

fn as_any(&self, func: &mut dyn FnMut(&dyn Any))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any))

fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect))

fn fields(&self, func: &mut dyn FnMut(Vec<&dyn Reflect>))

fn fields_mut(&mut self, func: &mut dyn FnMut(Vec<&mut dyn Reflect>))

fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>))

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>) )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>) )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>) )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>) )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>) )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>) )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>) )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>) )

impl TryFrom<&str> for Mobility

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Mobility, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl VariantNames for Mobility

const VARIANTS: &'static [&'static str] = _

Names of the variants of this enum

impl Visit for Mobility

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult

impl Copy for Mobility

impl Eq for Mobility

impl StructuralEq for Mobility

impl StructuralPartialEq for Mobility