Struct CustomTileCollider

pub struct CustomTileCollider {
    pub vertices: Vec<Vector2<f32>>,
    pub triangles: Vec<TriangleDefinition>,
}

Triangle data for a tile collider arranged in rectangle from (0,0) to (1,1). Custom tile colliders can be converted to and from strings, where the strings contain 2D vertex positions and triangle index triples. A group of two numbers is taken to be a 2D vertex position while a group of three numbers is taken to be an index triple, and the numbers are therefore parsed as ints. For example, “0,0 1,1 1,0 0,1,2” would be a valid string for a custom tile collider. The commas (,) are used to connect two numbers as being part of the same group. Any other characters are ignored, so this would also be accepted: “(0,0) (1,1) (1,0) [0,1,2]”.

Fields

vertices: Vec<Vector2<f32>>

The vertices of the triangles, with the boundaries of the tile being between (0,0) and (1,1).

triangles: Vec<TriangleDefinition>

The indices of the vertices of each triangle

Implementations

impl CustomTileCollider

pub const VERTICES: &'static str = "vertices"

pub const TRIANGLES: &'static str = "triangles"

impl CustomTileCollider

pub fn build_collider_shape( &self, transform: &Matrix4<f32>, position: Vector3<f32>, vertices: &mut Vec<Point2<f32>>, triangles: &mut Vec<[u32; 3]>, )

Construct triangles to represent this collider by appending to the given vectors, starting from the given lower-left corner of the tile and finally applying the given transformation matrix. The transformation and position are in 3D, but the resulting 2D vertices ignore the z-coordinate.

Trait Implementations

impl Clone for CustomTileCollider

fn clone(&self) -> CustomTileCollider

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CustomTileCollider

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

Formats the value using the given formatter.

impl Default for CustomTileCollider

fn default() -> CustomTileCollider

Returns the “default value” for a type.

impl Display for CustomTileCollider

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

Formats the value using the given formatter.

impl FromStr for CustomTileCollider

type Err = CustomTileColliderStrError

The associated error which can be returned from parsing.

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

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

impl OrthoTransform for CustomTileCollider

fn x_flipped(self) -> Self

Flip the object parallel to the x axis, so x becomes -x.

fn rotated(self, amount: i8) -> Self

Rotate the object counter-clockwise by the given amount.

fn y_flipped(self) -> Self

Flip the object parallel to the y axis, so y becomes -y.

fn transformed(self, amount: OrthoTransformation) -> Self

Transform the object by the given amount.

impl PartialEq for CustomTileCollider

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

where Self: 'static, Vec<Vector2<f32>>: Reflect, Vec<TriangleDefinition>: 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<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 ResourceData for CustomTileCollider

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 CustomTileCollider

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for CustomTileCollider

where Vec<Vector2<f32>>: Visit, Vec<TriangleDefinition>: Visit,

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 StructuralPartialEq for CustomTileCollider