Struct bevy_internal::sprite::prelude::TextureSlicer

pub struct TextureSlicer {
    pub border: BorderRect,
    pub center_scale_mode: SliceScaleMode,
    pub sides_scale_mode: SliceScaleMode,
    pub max_corner_scale: f32,
}

Slices a texture using the 9-slicing technique. This allows to reuse an image at various sizes without needing to prepare multiple assets. The associated texture will be split into nine portions, so that on resize the different portions scale or tile in different ways to keep the texture in proportion.

For example, when resizing a 9-sliced texture the corners will remain unscaled while the other sections will be scaled or tiled.

See 9-sliced textures.

Fields

border: BorderRect

The sprite borders, defining the 9 sections of the image

center_scale_mode: SliceScaleMode

Defines how the center part of the 9 slices will scale

sides_scale_mode: SliceScaleMode

Defines how the 4 side parts of the 9 slices will scale

max_corner_scale: f32

Defines the maximum scale of the 4 corner slices (default to 1.0)

Implementations

impl TextureSlicer

pub fn compute_slices( &self, rect: Rect, render_size: Option<Vec2> ) -> Vec<TextureSlice>

Slices the given rect into at least 9 sections. If the center and/or side parts are set to tile, a bigger number of sections will be computed.

Arguments

• rect - The section of the texture to slice in 9 parts
• render_size - The optional draw size of the texture. If not set the rect size will be used.

Trait Implementations

impl Clone for TextureSlicer

fn clone(&self) -> TextureSlicer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TextureSlicer

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

Formats the value using the given formatter.

impl Default for TextureSlicer

fn default() -> TextureSlicer

Returns the “default value” for a type.

impl FromReflect for TextureSlicer

where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath, SliceScaleMode: FromReflect + TypePath, f32: FromReflect + TypePath,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<TextureSlicer>

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 TextureSlicer

where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath, SliceScaleMode: FromReflect + TypePath, f32: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl Reflect for TextureSlicer

where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath, SliceScaleMode: FromReflect + TypePath, f32: FromReflect + TypePath,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn into_any(self: Box<TextureSlicer>) -> 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<TextureSlicer>) -> 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 apply(&mut self, value: &(dyn Reflect + 'static))

Applies 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<TextureSlicer>) -> 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 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 TextureSlicer

where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath, SliceScaleMode: FromReflect + TypePath, f32: FromReflect + TypePath,

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 TextureSlicer

where TextureSlicer: 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 TextureSlicer

where TextureSlicer: Any + Send + Sync, BorderRect: FromReflect + TypePath, SliceScaleMode: FromReflect + TypePath, f32: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.