Struct Texture

pub struct Texture { /* private fields */ }

Actual texture data.

Implementations

impl Texture

pub const KIND: &'static str = "kind"

pub const BYTES: &'static str = "bytes"

pub const PIXEL_KIND: &'static str = "pixel_kind"

pub const MINIFICATION_FILTER: &'static str = "minification_filter"

pub const MAGNIFICATION_FILTER: &'static str = "magnification_filter"

pub const S_WRAP_MODE: &'static str = "s_wrap_mode"

pub const T_WRAP_MODE: &'static str = "t_wrap_mode"

pub const R_WRAP_MODE: &'static str = "r_wrap_mode"

pub const BASE_LEVEL: &'static str = "base_level"

pub const MAX_LEVEL: &'static str = "max_level"

pub const MIN_LOD: &'static str = "min_lod"

pub const MAX_LOD: &'static str = "max_lod"

pub const LOD_BIAS: &'static str = "lod_bias"

pub const MIP_COUNT: &'static str = "mip_count"

pub const ANISOTROPY: &'static str = "anisotropy"

pub const MODIFICATIONS_COUNTER: &'static str = "modifications_counter"

pub const IS_RENDER_TARGET: &'static str = "is_render_target"

impl Texture

pub fn load_from_memory( data: &[u8], import_options: TextureImportOptions, ) -> Result<Texture, TextureError>

Tries to load a texture from given data in one of the following formats: PNG, BMP, TGA, JPG, DDS, GIF. Use this method if you want to load a texture from embedded data.

On-demand compression and mip-map generation

The data can be compressed if needed to improve performance on GPU side. Mip-maps can be generated as well. CAVEAT: Compression and mip-map generation won’t be taken into account in case of DDS textures, because DDS can already contain such data, you should generate mips and compress DDS textures manually using some offline tool like DirectXTexTool or similar.

Important notes

Textures loaded with this method won’t be correctly serialized! It means that if you’ll made a scene with textures loaded with this method, and then save a scene, then the engine won’t be able to restore the textures if you’ll try to load the saved scene. This is essential limitation of this method, because the engine does not know where to get the data of the texture at loading. You should use ResourceManager::request_texture in majority of cases!

Use cases

Main use cases for this method are: procedural textures, icons for GUI.

pub fn from_bytes( kind: TextureKind, pixel_kind: TexturePixelKind, bytes: Vec<u8>, ) -> Option<Texture>

Creates new texture instance from given parameters.

Limitations

Currently textures with only one mip level are supported!

pub fn set_minification_filter(&mut self, filter: TextureMinificationFilter)

Sets new minification filter. It is used when texture becomes smaller.

pub fn minification_filter(&self) -> TextureMinificationFilter

Returns current minification filter.

pub fn set_magnification_filter(&mut self, filter: TextureMagnificationFilter)

Sets new magnification filter. It is used when texture is “stretching”.

pub fn magnification_filter(&self) -> TextureMagnificationFilter

Returns current magnification filter.

pub fn set_s_wrap_mode(&mut self, s_wrap_mode: TextureWrapMode)

Sets new S coordinate wrap mode.

pub fn s_wrap_mode(&self) -> TextureWrapMode

Returns current S coordinate wrap mode.

pub fn set_t_wrap_mode(&mut self, t_wrap_mode: TextureWrapMode)

Sets new T coordinate wrap mode.

pub fn t_wrap_mode(&self) -> TextureWrapMode

Returns current T coordinate wrap mode.

pub fn set_r_wrap_mode(&mut self, r_wrap_mode: TextureWrapMode)

Sets new R coordinate wrap mode.

pub fn r_wrap_mode(&self) -> TextureWrapMode

Returns current T coordinate wrap mode.

pub fn mip_count(&self) -> u32

Returns total mip count.

pub fn kind(&self) -> TextureKind

Returns texture kind.

pub fn modifications_count(&self) -> u64

Returns total amount of modifications done on the texture.

pub fn calculate_data_hash(&self) -> u64

Calculates current data hash.

pub fn pixel_kind(&self) -> TexturePixelKind

Returns current pixel kind.

pub fn base_level(&self) -> usize

Returns the index of the lowest defined mipmap level.

pub fn set_base_level(&mut self, base_level: usize)

Specifies the index of the lowest defined mipmap level. Keep in mind, that the texture data should provide the actual mip map level defined by the provided value, otherwise the rendering will be incorrect (probably just black on majority of implementations) and glitchy.

pub fn max_level(&self) -> usize

Returns the index of the highest defined mipmap level.

pub fn set_max_level(&mut self, max_level: usize)

Sets the index of the highest defined mipmap level. Keep in mind, that the texture data should provide the actual mip map level defined by the provided value, otherwise the rendering will be incorrect (probably just black on majority of implementations) and glitchy.

pub fn min_lod(&self) -> f32

Returns the minimum level-of-detail parameter. See Self::set_min_lod for more info.

pub fn set_min_lod(&mut self, min_lod: f32)

Sets the minimum level-of-detail parameter. This floating-point value limits the selection of highest resolution mipmap (lowest mipmap level). The initial value is -1000.0.

pub fn max_lod(&self) -> f32

Returns the maximum level-of-detail parameter. See Self::set_max_lod for more info.

pub fn set_max_lod(&mut self, max_lod: f32)

Sets the maximum level-of-detail parameter. This floating-point value limits the selection of the lowest resolution mipmap (highest mipmap level). The initial value is 1000.

pub fn lod_bias(&self) -> f32

Returns a fixed bias value that is to be added to the level-of-detail parameter for the texture before texture sampling. See Self::set_lod_bias for more info.

pub fn set_lod_bias(&mut self, lod_bias: f32)

Specifies a fixed bias value that is to be added to the level-of-detail parameter for the texture before texture sampling. The specified value is added to the shader-supplied bias value (if any) and subsequently clamped into the implementation-defined range −bias_max..bias_max, where bias_max is the value that can be fetched from the current graphics server. The initial value is 0.0.

pub fn data(&self) -> &[u8]

Returns current data as immutable slice.

pub fn data_of_type<T>(&self) -> Option<&[T]>

Tries to cast the internal data buffer to the given type. Type casting will succeed only if the the size of the type T is equal with the size of the pixel.

Important notes

While this function is safe, there’s no guarantee that the actual type-casted data will match the layout of your data structure. For example, you could have a pixel of type RG16, where each pixel consumes 2 bytes (4 in total) and cast it to the structure struct Rgba8 { r: u8, g: u8, b: u8, a: u8 } which is safe in terms of memory access (both are 4 bytes total), but not ok in terms of actual data. Be careful when using this method.

Keep in mind, that this method will return a reference to all data in the texture, including all mip levels. If you need to get typed data from specific mip level use Self::mip_level_data_of_type.

pub fn mip_level_data(&self, mip: usize) -> &[u8]

Returns data of the given mip level.

pub fn mip_level_data_of_type<T>(&self, mip: usize) -> Option<&[T]>

Tries to cast the specific mip level data of the internal data buffer to the given type. Type casting will succeed only if the the size of the type T is equal with the size of the pixel.

Important notes

While this function is safe, there’s no guarantee that the actual type-casted data will match the layout of your data structure. For example, you could have a pixel of type RG16, where each pixel consumes 2 bytes (4 in total) and cast it to the structure struct Rgba8 { r: u8, g: u8, b: u8, a: u8 } which is safe in terms of memory access (both are 4 bytes total), but not ok in terms of actual data. Be careful when using this method.

pub fn is_render_target(&self) -> bool

Returns true if the texture is used as render target.

pub fn set_anisotropy_level(&mut self, anisotropy: f32)

Max samples for anisotropic filtering. Default value is 16.0 (max). However real value passed to GPU will be clamped to maximum supported by current GPU. To disable anisotropic filtering set this to 1.0. Typical values are 2.0, 4.0, 8.0, 16.0.

pub fn anisotropy_level(&self) -> f32

Returns current anisotropy level.

pub fn modify(&mut self) -> TextureDataRefMut<'_>

Returns a special reference holder that provides mutable access to content of the texture and automatically calculates hash of the data in its destructor.

Trait Implementations

impl Clone for Texture

fn clone(&self) -> Texture

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Texture

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

Formats the value using the given formatter.

impl Default for Texture

fn default() -> Texture

It is very important to mention that defaults may be different for texture when you’re importing them through resource manager, see TextureImportOptions for more info.

impl Reflect for Texture

where Texture: 'static, TextureKind: Reflect, TextureBytes: Reflect, TexturePixelKind: Reflect, TextureMinificationFilter: Reflect, TextureMagnificationFilter: Reflect, TextureWrapMode: Reflect, usize: Reflect, f32: Reflect, u32: Reflect, u64: Reflect, bool: 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<Texture>) -> 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 ResourceData for Texture

fn type_uuid(&self) -> Uuid

Returns unique data type id.

fn save(&mut self, path: &Path) -> Result<(), Box<dyn Error>>

Saves the resource data a file at the specified path. This method is free to decide how the resource data is saved. This is needed, because there are multiple formats that defines various kinds of resources. For example, a rectangular texture could be saved into a bunch of formats, such as png, bmp, tga, jpg etc., but in the engine it is single Texture resource. In any case, produced file should be compatible with a respective resource loader.

fn can_be_saved(&self) -> bool

Returns true if the resource data can be saved to a file, false - otherwise. Not every resource type supports saving, for example there might be temporary resource type that is used only at runtime which does not need saving at all.

impl TypeUuidProvider for Texture

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for Texture

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.