Struct tego::Map

pub struct Map {
    pub version: Version,
    pub editor_version: Option<Version>,
    pub orientation: Orientation,
    pub renderorder: Renderorder,
    pub size: ivec2,
    pub tile_size: ivec2,
    pub tilesets: Vec<TileSet>,
    pub layers: Vec<Layer>,
}

The Map struct is the top level container for all relevant data inside of a Tiled map. A Map consists of TileSets and Layers. Stacking the layers in iteration order creates the final map image. Each layer contains indices (GIDs) referencing a specific tile in a tile sets.

Fields

version: Version

editor_version: Option<Version>

orientation: Orientation

renderorder: Renderorder

size: ivec2

tile_size: ivec2

tilesets: Vec<TileSet>

layers: Vec<Layer>

The Layers that make up this map. The final map image is rendered by stacking the layers in iteration order.

Implementations

impl Map

pub fn from_file(path: &Path) -> Result<Self>

pub fn from_file_with_loader(
    path: &Path,
    image_loader: &mut dyn ImageLoader
) -> Result<Self>

pub fn from_xml_str(
    tmx: &str,
    image_loader: &mut dyn ImageLoader
) -> Result<Self>

Parse a map from xml data

pub fn tile_image(&self, id: GID) -> Option<(&dyn Any, Rect)>

Fetch the image that belongs to a given GID. Returns the image and the pixel coordinates where the tile image is inside of that image.

pub fn iter_layers(&self) -> impl Iterator<Item = (&Layer, usize)>

Iterate over all the layers in this map recursively. All layers are visited in depth-first pre-order manner. The iterator yields the group layers, as well as all of their sub-layers.

In addition to the layer, a number of “pops” is also returned with each item. This is the number of group layers that was left with this iteration step. Some attributes of group layers affect all containing layers. If those attributes are accumulated in a stack, then the number of pops is the number of elemets to remove from the top of the stack.

Example

Rendering layers under consideration of the group opacity:

let opacities = vec![1.];
for (layer, pops) in map.iter_layers() {
    opacities.truncate(opacities.len() - pops);
    match layer {
        Layer::Group(group) => { opacities.push(opacities.last().unwrap() * group.opacity) },
        Layer::Tile(tile) => { render_layer(tile, opacities.last()) }
    }
}