Enum MaterialSearchOptions 

pub enum MaterialSearchOptions {
    MaterialsDirectory(PathBuf),
    RecursiveUp,
    WorkingDirectory,
    UsePathDirectly,
}

Defines a way of searching materials when loading a model resource from foreign file format such as FBX.

Motivation

Most 3d model file formats store paths to external resources (textures and other things) as absolute paths, which makes it impossible to use with “location-independent” application like games. To fix that issue, the engine provides few ways of resolving paths to external resources. The engine starts resolving by stripping everything but file name from an external resource’s path, then it uses one of the following methods to find a texture with the file name. It could look up on folders hierarchy by using MaterialSearchOptions::RecursiveUp method, or even use global search starting from the working directory of your game (MaterialSearchOptions::WorkingDirectory)

Variants

MaterialsDirectory(PathBuf)

Search in specified materials directory. It is suitable for cases when your model resource use shared textures.

Platform specific

Works on every platform.

RecursiveUp

Recursive-up search. It is suitable for cases when textures are placed near your model resource. This is default option.

Platform specific

Works on every platform.

WorkingDirectory

Global search starting from working directory. Slowest option with a lot of ambiguities - it may load unexpected file in cases when there are two or more files with same name but lying in different directories.

Platform specific

WebAssembly - not supported due to lack of file system.

UsePathDirectly

Try to use paths stored in the model resource directly. This options has limited usage, it is suitable to load animations, or any other model which does not have any materials.

Important notes

RGS (native engine scenes) files should be loaded with this option by default, otherwise the engine won’t be able to correctly find materials.

Implementations

impl MaterialSearchOptions

pub const MATERIALS_DIRECTORY_F_0: &'static str = "MaterialsDirectory@0"

impl MaterialSearchOptions

pub fn materials_directory<P>(path: P) -> MaterialSearchOptions

where P: AsRef<Path>,

A helper to create MaterialsDirectory variant.

Trait Implementations

impl AsRef<str> for MaterialSearchOptions

fn as_ref(&self) -> &str

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

impl Clone for MaterialSearchOptions

fn clone(&self) -> MaterialSearchOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MaterialSearchOptions

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

Formats the value using the given formatter.

impl Default for MaterialSearchOptions

fn default() -> MaterialSearchOptions

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MaterialSearchOptions

fn deserialize<__D>( __deserializer: __D, ) -> Result<MaterialSearchOptions, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for MaterialSearchOptions

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl PartialEq for MaterialSearchOptions

fn eq(&self, other: &MaterialSearchOptions) -> 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 Reflect for MaterialSearchOptions

where MaterialSearchOptions: 'static, PathBuf: Reflect,

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<MaterialSearchOptions>) -> 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 + 'static)))

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

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

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

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

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

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

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 Serialize for MaterialSearchOptions

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for MaterialSearchOptions

type Error = ParseError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TypeUuidProvider for MaterialSearchOptions

fn type_uuid() -> Uuid

Return type UUID.

impl VariantNames for MaterialSearchOptions

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

Names of the variants of this enum

impl Visit for MaterialSearchOptions

where PathBuf: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

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

impl Eq for MaterialSearchOptions

impl StructuralPartialEq for MaterialSearchOptions