Struct TileMapBrush 

pub struct TileMapBrush {
    pub tile_set: Option<TileSetResource>,
    pub pages: TileGridMap<TileMapBrushPage>,
    pub change_count: ChangeFlag,
}

Tile map brush is a set of tiles arranged in arbitrary shape, that can be used to draw on a tile map.

Fields

tile_set: Option<TileSetResource>

The tile set used by this brush. This must match the tile set of any tile map that this brush is used to edit.

pages: TileGridMap<TileMapBrushPage>

The set of pages contained in the brush Each page is associated with 2D coordinates within a palette of brush pages. This allows pages to be selected much like tiles are selected, and it allows users to customize the organization of pages.

change_count: ChangeFlag

A count of changes since last save. New changes add +1. Reverting to previous states add -1. Reverting to a state before the last save can result in negative values. Saving is unnecessary whenever this value is 0.

Implementations

impl TileMapBrush

pub const TILE_SET: &'static str = "tile_set"

impl TileMapBrush

pub fn has_tile_at(&self, page: Vector2<i32>, tile: Vector2<i32>) -> bool

True if there is a tile at the given position.

pub fn has_page_at(&self, page: Vector2<i32>) -> bool

True if there is a page at the given position.

pub fn tile_redirect( &self, handle: TileDefinitionHandle, ) -> Option<TileDefinitionHandle>

The handle stored at the given position.

pub fn pages_bounds(&self) -> OptionTileRect

Returns bounding rectangle of pages in grid coordinates.

pub fn page_icon(&self, page: Vector2<i32>) -> Option<TileDefinitionHandle>

The handle of the tile that represents the page at the given position.

pub fn tiles_bounds( &self, stage: TilePaletteStage, page: Vector2<i32>, ) -> OptionTileRect

The bounds of the tiles on the given page.

pub fn find_tile_at_position( &self, stage: TilePaletteStage, page: Vector2<i32>, position: Vector2<i32>, ) -> Option<TileDefinitionHandle>

The handle of the tile at the given position, either the icon of a page or the tile stored at that position in the brush.

pub fn get_tiles<I: Iterator<Item = Vector2<i32>>>( &self, stage: TilePaletteStage, page: Vector2<i32>, iter: I, tiles: &mut Tiles, )

The tile definition handles of the tiles at the given positions on the given page.

pub fn is_missing_tile_set(&self) -> bool

Return true if this brush has no tile set.

pub fn palette_render_loop<F>( &self, stage: TilePaletteStage, page: Vector2<i32>, func: F, )

where F: FnMut(Vector2<i32>, TileRenderData),

Loops through the tiles of the given page and finds the render data for each tile in the tile set, then passes it to the given function.

pub fn get_tile_render_data( &self, position: ResourceTilePosition, ) -> Option<TileRenderData>

Return the TileRenderData needed to render the tile at the given position on the given page. If there is no tile at that position or the tile set is missing or not loaded, then None is returned. If there is a tile and a tile set, but the handle of the tile does not exist in the tile set, then the rendering data for an error tile is returned using TileRenderData::missing_tile().

pub fn redirect_handle( &self, position: ResourceTilePosition, ) -> Option<TileDefinitionHandle>

The tiles of a brush are references to tiles in the tile set. This method converts positions within the brush into the handle that points to the corresponding tile definition within the tile set. If this brush does not contain a reference at the given position, then None is returned.

pub fn get_tile_bounds( &self, position: ResourceTilePosition, ) -> Option<TileMaterialBounds>

The TileMaterialBounds taken from the tile set for the tile in the brush at the given position.

pub async fn from_file( path: &Path, resource_manager: ResourceManager, io: &dyn ResourceIo, ) -> Result<Self, TileMapBrushResourceError>

Load a tile map brush resource from the specific file path.

Trait Implementations

impl Clone for TileMapBrush

fn clone(&self) -> TileMapBrush

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TileMapBrush

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

Formats the value using the given formatter.

impl Default for TileMapBrush

fn default() -> TileMapBrush

Returns the “default value” for a type.

impl Reflect for TileMapBrush

where Self: 'static, Option<TileSetResource>: 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 TileMapBrush

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 TileMapBrush

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for TileMapBrush

where Option<TileSetResource>: Visit, TileGridMap<TileMapBrushPage>: 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.