Enum 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 duplicate 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 Default for Mobility

fn default() -> Mobility

Returns the “default value” for a type.

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) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Mobility

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Reflect for Mobility

where Self: 'static,

fn source_path() -> &'static str

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

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

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

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[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(&[&dyn Reflect]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [&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 TypeUuidProvider for Mobility

fn type_uuid() -> Uuid

Return type UUID.

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

Read or write this value, depending on whether Visitor::is_reading() is true or false.

impl Copy for Mobility

impl Eq for Mobility

impl StructuralPartialEq for Mobility