Struct TileMapBrush 

pub struct TileMapBrush {
    pub tile_set: Option<TileSetResource>,
    pub pages: TileGridMap<TileMapBrushPage>,
    pub macros: BrushMacroInstanceList,
    pub change_flag: 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.

macros: BrushMacroInstanceList

Untyped data stored in this brush for use by some macro.

change_flag: ChangeFlag

A record of whether the brush has changed since last time it was saved.

Implementations

impl TileMapBrush

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

pub const MACROS: &'static str = "macros"

impl TileMapBrush

pub fn block_until_tile_set_is_loaded(&self) -> bool

Return true after blocking to wait for the brush’s tile set to load, if the tile set loads successfully, or if the tile set has no brush. Return false if any error occurs while trying to load the tile set.

pub fn tile_set(&self) -> Option<TileSetResource>

Return the tile set for this brush, blocking if the tile set is not yet loaded. None is returned if this brush has no tile set or the tile set fails to load.

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 stamp_element( &self, position: ResourceTilePosition, ) -> Option<StampElement>

The stamp element for the given position, if the tile in that cell is used to create a stamp. The StampElement::handle refers to the location of the tile within the tile set, while the StampElement::source refers to the location of the tile within the brush.

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 fn is_free_at(&self, position: ResourceTilePosition) -> bool

Returns true if the brush is unoccupied 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,

fn source_path() -> &'static str

fn try_clone_box(&self) -> Option<Box<dyn Reflect>>

fn type_name(&self) -> &'static str

fn derived_types() -> &'static [TypeId]

fn query_derived_types(&self) -> &'static [TypeId]

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_ref(&self, func: &mut dyn FnMut(&[FieldRef<'_, '_>]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [FieldMut<'_, '_>]))

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 set_field( &mut self, field_name: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, SetFieldError>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

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 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)>), )

fn as_handle( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHandle + 'static)>), )

fn as_handle_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHandle + '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.

fn try_clone_box(&self) -> Option<Box<dyn ResourceData>>

Tries to clone the resource data. This method can return None if the underlying type is non-cloneable.

impl TypeUuidProvider for TileMapBrush

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for TileMapBrush

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.