Bevy ECS Tilemap

https://docs.rs/bevy_ecs_tilemap/latest/
Admin
Bevy ECS Tilemap is an ECS-driven tilemap rendering library designed for fast, highly customizable...
Tokens:232,530
Snippets:1,579
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Usage of Selection Helpers

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/selection.rs.html

Illustrates how to use selection helper functions. This example is a placeholder and does not contain actual executable code.

```rust
1
```

--------------------------------

### MaterialTilemapPlugin Setup

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/material.rs.html

A plugin for integrating custom material types into the Bevy ECS Tilemap rendering system. It initializes the asset type and adds the necessary extraction logic.

```rust
pub struct MaterialTilemapPlugin<M: MaterialTilemap>(PhantomData<M>);

impl<M: MaterialTilemap> Default for MaterialTilemapPlugin<M> {
    fn default() -> Self {
        Self(Default::default())
    }
}

impl<M: MaterialTilemap> Plugin for MaterialTilemapPlugin<M>
where
    M::Data: PartialEq + Eq + Hash + Clone,
{
    fn build(&self, app: &mut App) {
        app.init_asset::<M>()
            .add_plugins(ExtractComponentPlugin::<MaterialTilemapHandle<M>>::extract_visible());
    }
}
```

--------------------------------

### Bevy ECS Tilemap Plugin Setup

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/lib.rs.html

This code demonstrates how to set up the TilemapPlugin in a Bevy application. It includes registering various tilemap-related components and configuring system sets. This is essential for enabling tilemap functionality.

```rust
#![allow(dead_code)]

//! Bevy ECS Tilemap plugin is a ECS driven tilemap rendering library. It's designed to be fast and highly customizable. Each tile is considered a unique entity and all tiles are stored in the game world.
//!
//!
//! ## Features
//! - A tile per entity.
//! - Fast rendering using a chunked approach.
//! - Layers and sparse tile maps.
//! - GPU powered animations.
//! - Isometric and Hexagonal tile maps.
//! - Initial support for Tiled file exports.
//! - Support for isometric and hexagon rendering.
//! - Built in animation support  – see [`animation` example](https://github.com/StarArawn/bevy_ecs_tilemap/blob/main/examples/animation.rs).
//! - Texture array support.
//! - Can `Anchor` tilemap like a sprite.
1
use bevy::{
    ecs::schedule::IntoScheduleConfigs,
    prelude::{
        Bundle, Changed, Component, Deref, First, GlobalTransform, InheritedVisibility, Plugin,
        Query, Reflect, ReflectComponent, SystemSet, Transform, ViewVisibility, Visibility,
    },
    render::sync_world::SyncToRenderWorld,
    time::TimeSystems,
};

#[cfg(feature = "render")]
use render::material::MaterialTilemapHandle;

use anchor::TilemapAnchor;
use map::{
    TilemapGridSize, TilemapSize, TilemapSpacing, TilemapTexture, TilemapTextureSize,
    TilemapTileSize, TilemapType,
};
use prelude::{TilemapId, TilemapRenderSettings};
#[cfg(feature = "render")]
use render::material::{MaterialTilemap, StandardTilemapMaterial};
use tiles::{
    AnimatedTile, TileColor, TileFlip, TilePos, TilePosOld, TileStorage, TileTextureIndex,
    TileVisible,
};

#[cfg(all(not(feature = "atlas"), feature = "render"))]
use bevy::render::{ExtractSchedule, RenderApp};

pub mod anchor;
/// A module that allows pre-loading of atlases into array textures.
#[cfg(all(not(feature = "atlas"), feature = "render"))]
mod array_texture_preload;
/// A module which provides helper functions.
pub mod helpers;
/// A module which contains tilemap components.
pub mod map;
#[cfg(feature = "render")]
pub(crate) mod render;
/// A module which contains tile components.
pub mod tiles;

/// A bevy tilemap plugin. This must be included in order for everything to be rendered.
/// But is not necessary if you are running without a renderer.
pub struct TilemapPlugin;

impl Plugin for TilemapPlugin {
    fn build(&self, app: &mut bevy::prelude::App) {
        #[cfg(feature = "render")]
        app.add_plugins(render::TilemapRenderingPlugin);

        app.add_systems(First, update_changed_tile_positions.in_set(TilemapFirstSet));

        #[cfg(all(not(feature = "atlas"), feature = "render"))]
        {
            app.insert_resource(array_texture_preload::ArrayTextureLoader::default());
            let render_app = app.sub_app_mut(RenderApp);
            render_app.add_systems(ExtractSchedule, array_texture_preload::extract);
        }

        app.register_type::<FrustumCulling>()
            .register_type::<TilemapId>()
            .register_type::<TilemapSize>()
            .register_type::<TilemapTexture>()
            .register_type::<TilemapTileSize>()
            .register_type::<TilemapGridSize>()
            .register_type::<TilemapSpacing>()
            .register_type::<TilemapTextureSize>()
            .register_type::<TilemapType>()
            .register_type::<TilemapAnchor>()
            .register_type::<TilePos>()
            .register_type::<TileTextureIndex>()
            .register_type::<TileColor>()
            .register_type::<TileVisible>()
            .register_type::<TileFlip>()
            .register_type::<TileStorage>()
            .register_type::<TilePosOld>()
            .register_type::<AnimatedTile>()
            .configure_sets(First, TilemapFirstSet.after(TimeSystems));
    }
}

#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
pub struct TilemapFirstSet;

#[derive(Component, Reflect, Debug, Clone, Copy, Deref)]
#[reflect(Component)]
pub struct FrustumCulling(pub bool);

impl Default for FrustumCulling {
    /// By default, `FrustumCulling` is `true`.
    fn default() -> Self {
        FrustumCulling(true)
    }
}

#[cfg(feature = "render")]
pub type TilemapBundle = MaterialTilemapBundle<StandardTilemapMaterial>;

#[cfg(feature = "render")]
/// The default tilemap bundle. All of the components within are required.
#[derive(Bundle, Debug, Default, Clone)]
pub struct MaterialTilemapBundle<M: MaterialTilemap> {
    pub grid_size: TilemapGridSize,
    pub map_type: TilemapType,
    pub size: TilemapSize,
    pub spacing: TilemapSpacing,
    pub storage: TileStorage,
}

```

--------------------------------

### Register Required Components for TilemapGridSize

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/map/struct.TilemapGridSize.html

Registers any components required by TilemapGridSize during Bevy's ECS setup.

```rust
fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )
```

--------------------------------

### Initialize Tilemap Material Rendering

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/material.rs.html

Adds necessary render commands and initializes resources for custom tilemap materials within the render app. This setup ensures that the tilemap rendering pipeline can process and draw custom materials.

```rust
fn finish(&self, app: &mut App) {
        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
            render_app
                .add_render_command::<Transparent2d, DrawTilemapMaterial<M>>()
                .init_resource::<MaterialTilemapPipeline<M>>()
                .init_resource::<ExtractedMaterialsTilemap<M>>()
                .init_resource::<RenderMaterialsTilemap<M>>()
                .init_resource::<SpecializedRenderPipelines<MaterialTilemapPipeline<M>>>()
                .add_systems(ExtractSchedule, extract_materials_tilemap::<M>)
                .add_systems(
                    Render,
                    prepare_materials_tilemap::<M>.in_set(RenderSystems::PrepareAssets),
                )
                .add_systems(
                    Render,
                    (
                        // Ensure `queue_material_tilemap_meshes` runs after `prepare::prepare` because `prepare` calls `commands.spawn` with `ChunkId`
                        // and that data is then consumed by `queue_material_tilemap_mesh`. This is important because `prepare` is part of the `PrepareAssets`
                        // set. Bevy is loose on its expectation of when systems in the `PrepareAssets` set execute (for performance) and only needs them
                        // to run before the `Prepare` set (which is after Queue). This invites the possibility of an intermittent incorrect ordering dependent
                        // on the scheduler.
                        queue_material_tilemap_meshes::<M>
                            .in_set(RenderSystems::Queue)
                            .after(prepare::prepare),
                        bind_material_tilemap_meshes::<M>.in_set(RenderSystems::PrepareBindGroups),
                    ),
                );
        }
    }
```

--------------------------------

### Plugin Implementation for MaterialTilemapPlugin

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/prelude/struct.MaterialTilemapPlugin.html

Implements the Plugin trait for MaterialTilemapPlugin, enabling its integration into a Bevy application. This includes methods for configuring the app, finishing setup, checking readiness, and cleanup.

```rust
fn build(&self, app: &mut App)
```

```rust
fn finish(&self, app: &mut App)
```

```rust
fn ready(&self, _app: &App) -> bool
```

```rust
fn cleanup(&self, _app: &mut App)
```

```rust
fn name(&self) -> &str
```

```rust
fn is_unique(&self) -> bool
```

--------------------------------

### Get Diamond Neighboring Tile Position

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/square_grid/diamond.rs.html

Gets the `TilePos` of a neighbor in a specified direction within the map bounds, assuming an isometric diamond coordinate system. Returns `None` if the neighbor is out of bounds.

```rust
/// Get the neighbor lying in the specified direction from this position, if it  fits on the map
/// and assuming that this is a map using the isometric diamond coordinate system.
#[inline]
pub fn diamond_offset(
    &self,
    direction: &SquareDirection,
    map_size: &TilemapSize,
) -> Option<TilePos> {
    DiamondPos::from(self)
        .offset(direction)
        .as_tile_pos(map_size)
}
```

--------------------------------

### offset_compass

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Get the tile offset from `self` in the given [`HexColDirection`].

```APIDOC
## offset_compass

### Description
Get the tile offset from `self` in the given [`HexColDirection`].

### Signature
`pub fn offset_compass(&self, direction: HexRowDirection) -> Self`

### Parameters
- `direction`: The `HexRowDirection` to offset the tile by.

### Returns
A new tile position offset by the specified direction.
```

--------------------------------

### Settings Implementation

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/square_grid/neighbors/struct.Neighbors.html

This section outlines the implementation of 'Settings' for types that are 'static + Send + Sync'.

```APIDOC
### impl<T> Settings for T

#### where T: 'static + Send + Sync

This implementation block provides settings-related functionality for types that meet the specified trait bounds.
```

--------------------------------

### offset

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Get the tile offset from `self` in the given [`HexDirection`].

```APIDOC
## offset

### Description
Get the tile offset from `self` in the given [`HexDirection`].

### Signature
`pub fn offset(&self, direction: HexDirection) -> Self`

### Parameters
- `direction`: The `HexDirection` to offset the tile by.

### Returns
A new tile position offset by the specified direction.
```

--------------------------------

### Get All Image Handles

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/map.rs.html

Collects all image handles from different TilemapTexture variants.

```rust
pub fn image_handles(&self) -> Vec<&Handle<Image>> {
    match &self {
        TilemapTexture::Single(handle) => vec![handle],
        #[cfg(not(feature = "atlas"))]
        TilemapTexture::Vector(handles) => handles.iter().collect(),
        #[cfg(not(feature = "atlas"))]
        TilemapTexture::TextureContainer(handle) => vec![handle],
    }
}
```

--------------------------------

### Configure Bevy Render App for Tilemaps

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/mod.rs.html

Sets up the render app by initializing resources, adding systems for asset preparation, rendering, and cleanup. This configuration is conditional on the 'atlas' feature.

```rust
let render_app = match app.get_sub_app_mut(RenderApp) {
            Some(render_app) => render_app,
            None => return,
        };

        render_app.init_resource::<TilemapPipeline>();

        #[cfg(not(feature = "atlas"))]
        render_app
            .init_resource::<TextureArrayCache>()
            .add_systems(
                Render,
                prepare_textures.in_set(RenderSystems::PrepareAssets),
            )
            .add_systems(Render, texture_array_cache::remove_modified_textures);
```

```rust
render_app
            .insert_resource(DefaultSampler(sampler))
            .insert_resource(RenderChunk2dStorage::default())
            .add_systems(
                ExtractSchedule,
                (extract::extract, extract_resource::<ModifiedImageIds>),
            )
            .add_systems(
                Render,
                (prepare::prepare_removal, prepare::prepare)
                    .chain()
                    .in_set(RenderSystems::PrepareAssets),
            )
            .add_systems(
                Render,
                queue::queue_transform_bind_group.in_set(RenderSystems::PrepareBindGroups),
            )
            .add_systems(Render, remove_changed.in_set(RenderSystems::Cleanup))
            .init_resource::<ImageBindGroups>()
            .init_resource::<SpecializedRenderPipelines<TilemapPipeline>>()
            .init_resource::<MeshUniformResource>()
            .init_resource::<TilemapUniformResource>()
            .init_resource::<ModifiedImageIds>();

        render_app.add_render_command::<Transparent2d, DrawTilemap>();
```

--------------------------------

### GetPath Trait

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/anchor/enum.TilemapAnchor.html

Provides methods for getting references to nested values using a path.

```APIDOC
## GetPath Trait

### Description
Provides methods for getting references to nested values using a path.

### Methods
#### `reflect_path<'p>(&self, path: impl ReflectPath<'p>) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>`
Returns a reference to the value specified by `path`.

#### `reflect_path_mut<'p>(&mut self, path: impl ReflectPath<'p>) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>`
Returns a mutable reference to the value specified by `path`.

#### `path<'p, T>(&self, path: impl ReflectPath<'p>) -> Result<&T, ReflectPathError<'p>>`
where T: Reflect
Returns a statically typed reference to the value specified by `path`.

#### `path_mut<'p, T>(&mut self, path: impl ReflectPath<'p>) -> Result<&mut T, ReflectPathError<'p>>`
where T: Reflect
Returns a statically typed mutable reference to the value specified by `path`.
```

--------------------------------

### Prepare Textures for GPU Rendering

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/texture_array_cache.rs.html

Iterates through textures queued for preparation, creates GPU textures, samplers, and views, and adds them to the cache. Includes a workaround for default handles and a fix for WGPU's texture type inference.

```rust
pub fn prepare(
        &mut self,
        render_device: &RenderDevice,
        render_images: &Res<RenderAssets<GpuImage>>,
    ) {
        let prepare_queue = self.prepare_queue.drain().collect::<Vec<_>>();
        for texture in prepare_queue.iter() {
            // Fixes issue where default handle causes a crash. There should be a better
            // way of fixing this.
            if let TilemapTexture::Single(t) = texture
                && bevy::prelude::Handle::default() == t.clone()
            {
                return;
            }

            match texture {
                TilemapTexture::Single(_) | TilemapTexture::Vector(_) => {
                    let (count, tile_size, _, _, filter, format) = 
                        self.meta_data.get(texture).unwrap();

                    // Fixes issue where wgpu's gles texture type inference fails.
                    let count = if *count == 1 || count % 6 == 0 {
                        count + 1
                    } else {
                        *count
                    };

                    let gpu_texture = render_device.create_texture(&TextureDescriptor {
                        label: Some("texture_array"),
                        size: Extent3d {
                            width: tile_size.x as u32,
                            height: tile_size.y as u32,
                            depth_or_array_layers: count,
                        },
                        mip_level_count: 1,
                        sample_count: 1,
                        dimension: TextureDimension::D2,
                        format: *format,
                        usage: TextureUsages::COPY_DST | TextureUsages::TEXTURE_BINDING,
                        view_formats: &[],
                    });

                    let sampler = render_device.create_sampler(&SamplerDescriptor {
                        label: Some("texture_array_sampler"),
                        address_mode_u: AddressMode::ClampToEdge,
                        address_mode_v: AddressMode::ClampToEdge,
                        address_mode_w: AddressMode::ClampToEdge,
                        mag_filter: *filter,
                        min_filter: *filter,
                        mipmap_filter: *filter,
                        lod_min_clamp: 0.0,
                        lod_max_clamp: f32::MAX,
                        compare: None,
                        anisotropy_clamp: 1,
                        border_color: None,
                    });

                    let texture_view = gpu_texture.create_view(&TextureViewDescriptor {
                        label: Some("texture_array_view"),
                        format: None,
                        dimension: Some(TextureViewDimension::D2Array),
                        aspect: TextureAspect::All,
                        base_mip_level: 0,
                        mip_level_count: None,
                        base_array_layer: 0,
                        array_layer_count: Some(count),
                        usage: Some(gpu_texture.usage()),
                    });

                    let mip_level_count = gpu_texture.mip_level_count();

                    let gpu_image = GpuImage {
                        texture_format: *format,
                        texture: gpu_texture,
                        sampler,
                        texture_view,
                        size: Extent3d {
                            width: tile_size.x as u32,
                            height: tile_size.y as u32,
                            depth_or_array_layers: 1,
                        },
                        mip_level_count,
                        texture_view_format: Some(*format),
                        had_data: false,
                    };

                    self.textures.insert(texture.clone(), gpu_image);
                    self.queue_queue.insert(texture.clone());
                }
            }
        }
    }
```

--------------------------------

### Get Image Handle for Atlas Feature

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/map.rs.html

Retrieves the image handle when the 'atlas' feature is enabled.

```rust
pub fn image_handle(&self) -> &Handle<Image> {
    match &self {
        TilemapTexture::Single(handle) => handle,
    }
}
```

--------------------------------

### RenderChunk2d::new

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/chunk.rs.html

Constructor for creating a new `RenderChunk2d` instance.

```APIDOC
## RenderChunk2d::new

### Description
Creates a new `RenderChunk2d` with the specified properties, calculating necessary transforms and bounding boxes.

### Method
`new(
    id: u64,
    tilemap_id: u64,
    index: &UVec3,
    size_in_tiles: UVec2,
    map_type: TilemapType,
    tile_size: TilemapTileSize,
    spacing: Vec2,
    grid_size: TilemapGridSize,
    texture: TilemapTexture,
    texture_size: Vec2,
    map_size: TilemapSize,
    global_transform: GlobalTransform,
    visible: bool,
    frustum_culling: bool,
    render_size: RenderChunkSize,
    y_sort: bool,
) -> Self`

### Parameters
- **id** (*u64*): Unique identifier for the chunk.
- **tilemap_id** (*u64*): Identifier of the tilemap this chunk belongs to.
- **index** (*&UVec3*): The chunk's index in chunk coordinates.
- **size_in_tiles** (*UVec2*): The dimensions of the chunk in tiles.
- **map_type** (*TilemapType*): The type of the tilemap (e.g., orthogonal, isometric).
- **tile_size** (*TilemapTileSize*): The size of individual tiles.
- **spacing** (*Vec2*): The spacing between tiles.
- **grid_size** (*TilemapGridSize*): The grid size of the tilemap.
- **texture** (*TilemapTexture*): The texture asset used for the tiles.
- **texture_size** (*Vec2*): The dimensions of the texture.
- **map_size** (*TilemapSize*): The overall size of the tilemap.
- **global_transform** (*GlobalTransform*): The global transformation of the tilemap.
- **visible** (*bool*): Whether the chunk is initially visible.
- **frustum_culling** (*bool*): Whether frustum culling is enabled for this chunk.
- **render_size** (*RenderChunkSize*): The rendering size configuration for the chunk.
- **y_sort** (*bool*): Whether y-sorting is enabled for the chunk.

### Returns
- `Self`: A new `RenderChunk2d` instance.
```

--------------------------------

### IntoScheduleConfigs

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/struct.TilemapFirstSet.html

Provides methods for configuring system schedules, including setting dependencies and run conditions.

```APIDOC
## fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>

Convert into a `ScheduleConfigs`.

## fn in_set(self, set: impl SystemSet) -> ScheduleConfigs<T>

Add these systems to the provided `set`.

## fn before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>

Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

## fn after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>

Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

## fn before_ignore_deferred<M>( self, set: impl IntoSystemSet<M>, ) -> ScheduleConfigs<T>

Run before all systems in `set`.

## fn after_ignore_deferred<M>( self, set: impl IntoSystemSet<M>, ) -> ScheduleConfigs<T>

Run after all systems in `set`.

## fn distributive_run_if<M>( self, condition: impl SystemCondition<M> + Clone, ) -> ScheduleConfigs<T>

Add a run condition to each contained system.

## fn run_if<M>(self, condition: impl SystemCondition<M>) -> ScheduleConfigs<T>

Run the systems only if the `SystemCondition` is `true`.

## fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.

## fn ambiguous_with_all(self) -> ScheduleConfigs<T>

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

## fn chain(self) -> ScheduleConfigs<T>

Treat this collection as a sequence of systems.

## fn chain_ignore_deferred(self) -> ScheduleConfigs<T>

Treat this collection as a sequence of systems.
```

--------------------------------

### Get Offset in HexDirection

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Calculates the offset tile position in a given `HexDirection` from the current tile.

```rust
/// Get the tile offset from `self` in the given [`HexDirection`].
#[inline]
pub fn offset(&self, direction: HexDirection) -> Self {
    Self::from(AxialPos::from(*self).offset(direction))
}
```

--------------------------------

### TilePos Reflection Methods

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.TilePos.html

Provides access to methods for runtime reflection on TilePos instances. These include getting type information, applying reflected values, checking reflection kind, and obtaining immutable or mutable reflection references.

```APIDOC
## TilePos Reflection Methods

### Description
Methods for runtime reflection on TilePos instances.

### Methods
- `get_represented_type_info()`: Returns the `TypeInfo` of the type represented by this value.
- `try_apply(value: &dyn PartialReflect)`: Tries to apply a reflected value to this value.
- `reflect_kind()`: Returns a zero-sized enumeration of "kinds" of type.
- `reflect_ref()`: Returns an immutable enumeration of "kinds" of type.
- `reflect_mut()`: Returns a mutable enumeration of "kinds" of type.
- `reflect_owned()`: Returns an owned enumeration of "kinds" of type.
- `try_into_reflect(self: Box<Self>)`: Attempts to cast this type to a boxed, fully-reflected value.
- `try_as_reflect()`: Attempts to cast this type to a fully-reflected value.
- `try_as_reflect_mut()`: Attempts to cast this type to a mutable, fully-reflected value.
- `into_partial_reflect(self: Box<Self>)`: Casts this type to a boxed, reflected value.
- `as_partial_reflect()`: Casts this type to a reflected value.
- `as_partial_reflect_mut()`: Casts this type to a mutable, reflected value.
- `reflect_partial_eq(value: &dyn PartialReflect)`: Returns a "partial equality" comparison result.
- `reflect_clone()`: Attempts to clone `Self` using reflection.
- `apply(value: &(dyn PartialReflect + 'static))`: Applies a reflected value to this value.
- `to_dynamic()`: Converts this reflected value into its dynamic representation based on its kind.
- `reflect_clone_and_take<T>()`: Combines `reflect_clone` and `take` for types implementing `PartialReflect`.
- `reflect_hash()`: Returns a hash of the value (which includes the type).
- `debug(f: &mut Formatter<'_>)`: Debug formatter for the value.
- `is_dynamic()`: Indicates whether or not this type is a "dynamic" type.
```

--------------------------------

### Get ColOddPos Center in World

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Calculates the world space position of the center of a ColOddPos tile.

```rust
pub fn center_in_world(&self, grid_size: &TilemapGridSize) -> Vec2 {
        let axial_pos = AxialPos::from(*self);
        axial_pos.center_in_world_col(grid_size)
    }
```

--------------------------------

### ColEvenPos::new

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/hex_grid/offset/struct.ColEvenPos.html

Creates a new ColEvenPos with the given q and r coordinates.

```APIDOC
## ColEvenPos::new

### Description
Creates a new `ColEvenPos` with the given `q` and `r` coordinates.

### Signature
```rust
pub const fn new(q: i32, r: i32) -> Self
```
```

--------------------------------

### TilemapGridSize Equality and Ordering Methods

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/map/struct.TilemapGridSize.html

Details the methods for comparing TilemapGridSize instances for equality and ordering.

```APIDOC
## TilemapGridSize Equality and Ordering

### `impl PartialEq for TilemapGridSize`

#### `fn eq(&self, other: &TilemapGridSize) -> bool`
Tests for `self` and `other` values to be equal, and is used by `==`.

#### `fn ne(&self, other: &Rhs) -> bool`
Tests for `!=`.

### `impl PartialOrd for TilemapGridSize`

#### `fn partial_cmp(&self, other: &TilemapGridSize) -> Option<Ordering>`
This method returns an ordering between `self` and `other` values if one exists.

#### `fn lt(&self, other: &Rhs) -> bool`
Tests less than (for `self` and `other`) and is used by the `<` operator.

#### `fn le(&self, other: &Rhs) -> bool`
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

#### `fn gt(&self, other: &Rhs) -> bool`
Tests greater than (for `self` and `other`) and is used by the `>` operator.

#### `fn ge(&self, other: &Rhs) -> bool`
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.
```

--------------------------------

### Get Corner in World Space

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/square_grid/diamond/struct.DiamondPos.html

Retrieves the world space coordinates of a specific corner of a tile.

```rust
pub fn corner_in_world( &self, corner_direction: SquareDirection, grid_size: &TilemapGridSize, ) -> Vec2
```

--------------------------------

### TilemapRenderingPlugin Implementation

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/mod.rs.html

The main plugin for enabling tilemap rendering. It sets up necessary systems, observers, and plugins for handling tilemap rendering within the Bevy application.

```rust
impl Plugin for TilemapRenderingPlugin {
    fn build(&self, app: &mut App) {
        #[cfg(not(feature = "atlas"))]
        app.add_systems(Update, set_texture_to_copy_src);

        app.add_systems(First, clear_removed.in_set(TilemapFirstSet));

        app.add_observer(on_remove_tile);
        app.add_observer(on_remove_tilemap);

        app.add_plugins(ExtractComponentPlugin::<RemovedTileEntity>::default());
        app.add_plugins(ExtractComponentPlugin::<RemovedMapEntity>::default());

        app.add_plugins(MaterialTilemapPlugin::<StandardTilemapMaterial>::default());

        app.world_mut()
            .resource_mut::<Assets<StandardTilemapMaterial>>()
            .insert(

```

--------------------------------

### Get ColOddPos Corner in World

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Calculates the world space position of a specific corner of a ColOddPos tile.

```rust
pub fn corner_in_world(
        &self,
        corner_direction: HexColDirection,
        grid_size: &TilemapGridSize,
    ) -> Vec2 {
        let axial_pos = AxialPos::from(*self);
        axial_pos.corner_in_world_col(corner_direction, grid_size)
    }
```

--------------------------------

### SystemSet Implementation for TilemapFirstSet

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/struct.TilemapFirstSet.html

Demonstrates the implementation of the SystemSet trait for TilemapFirstSet, enabling its use in Bevy's scheduling system.

```APIDOC
## impl SystemSet for TilemapFirstSet

```rust
impl SystemSet for TilemapFirstSet
where
    Self: 'static + Send + Sync + Clone + Eq + Debug + Hash,
{
    fn dyn_clone(&self) -> Box<dyn SystemSet>;
    fn system_type(&self) -> Option<TypeId>;
    fn is_anonymous(&self) -> bool;
    fn intern(&self) -> Interned<dyn SystemSet>
    where
        Self: Sized;
}
```

This implementation allows `TilemapFirstSet` to be used as a system set within Bevy. It provides methods for cloning, identifying system types, checking for anonymity, and interning the set for efficient management.
```

--------------------------------

### DynamicBundle for Component

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.TilePos.html

Provides methods for managing components when inserting bundles, including getting and applying effects.

```APIDOC
### impl<C> DynamicBundle for C
where C: Component,
Source§
#### type Effect = ()
An operation on the entity that happens _after_ inserting this bundle.
Source§
#### unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect
Moves the components out of the bundle. Read more
Source§
#### unsafe fn apply_effect( _ptr: MovingPtr<'_, MaybeUninit<C>>, _entity: &mut EntityWorldMut<'_>, )
Applies the after-effects of spawning this bundle. Read more
Source§
```

--------------------------------

### TilemapTextureSize Type Registration

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/map/struct.TilemapTextureSize.html

Provides methods for getting the default TypeRegistration and registering type dependencies for TilemapTextureSize.

```APIDOC
## TilemapTextureSize

### Type Registration

#### fn get_type_registration() -> TypeRegistration

Returns the default `TypeRegistration` for this type.

#### fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.
```

--------------------------------

### Preparing Tilemap Materials for GPU

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/material.rs.html

This system prepares extracted Material2d assets for the GPU. It handles retries for assets that cannot be prepared immediately and logs errors for invalid sampler types or bind group creation issues.

```rust
fn prepare_materials_tilemap<M: MaterialTilemap>(
    mut prepare_next_frame: Local<PrepareNextFrameMaterials<M>>,
    mut extracted_assets: ResMut<ExtractedMaterialsTilemap<M>>,
    mut render_materials: ResMut<RenderMaterialsTilemap<M>>,
    render_device: Res<RenderDevice>,
    pipeline: Res<MaterialTilemapPipeline<M>>,
    mut param: StaticSystemParam<M::Param>,
    pipeline_cache: Res<PipelineCache>,
) {
    let queued_assets = std::mem::take(&mut prepare_next_frame.assets);
    for (handle, material) in queued_assets {
        match prepare_material_tilemap(
            &material,
            &render_device,
            &pipeline,
            &pipeline_cache,
            &mut param,
        ) {
            Ok(prepared_asset) => {
                render_materials.insert(handle, prepared_asset);
            }
            Err(AsBindGroupError::RetryNextUpdate) => {
                prepare_next_frame.assets.push((handle, material));
            }
            Err(AsBindGroupError::InvalidSamplerType(_, _, _)) => {
                error!("Encountered AsBindGroupError::InvalidSamplerType while preparing material");
            }
            Err(AsBindGroupError::CreateBindGroupDirectly) => {
                error!(
                    "Encountered AsBindGroupError::CreateBindGroupDirectly while preparing material"
                );
            }
        }
    }

    for removed in std::mem::take(&mut extracted_assets.removed) {
        render_materials.remove(&removed);
    }

    for (handle, material) in std::mem::take(&mut extracted_assets.extracted) {
        match prepare_material_tilemap(
            &material,
            &render_device,
            &pipeline,
            &pipeline_cache,
            &mut param,
        ) {
            Ok(prepared_asset) => {
                render_materials.insert(handle, prepared_asset);
            }
            Err(AsBindGroupError::RetryNextUpdate) => {
                prepare_next_frame.assets.push((handle, material));
            }
            Err(AsBindGroupError::InvalidSamplerType(_, _, _)) => {
                error!("Encountered AsBindGroupError::InvalidSamplerType while preparing material");
            }
            Err(AsBindGroupError::CreateBindGroupDirectly) => {
                error!(
                    "Encountered AsBindGroupError::CreateBindGroupDirectly while preparing material"
                );
            }
        }
    }
}
```

--------------------------------

### ColEvenPos center_in_world() Method

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/hex_grid/offset/struct.ColEvenPos.html

Calculates the center position of a hex tile in world space, given the grid size.

```rust
pub fn center_in_world(&self, grid_size: &TilemapGridSize) -> Vec2
```

--------------------------------

### Get ColOddPos Corner Offset in World

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Calculates the world space offset to a specific corner of a ColOddPos tile.

```rust
pub fn corner_offset_in_world(
        corner_direction: HexColDirection,
        grid_size: &TilemapGridSize,
    ) -> Vec2 {
        AxialPos::corner_offset_in_world_col(corner_direction, grid_size)
    }
```

--------------------------------

### GetField for Struct

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.TilePos.html

Provides methods to get references to struct fields by name, with optional downcasting to a specific type.

```APIDOC
### impl<S> GetField for S
where S: Struct,
Source§
#### fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,
Returns a reference to the value of the field named `name`, downcast to `T`.
Source§
#### fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,
Returns a mutable reference to the value of the field named `name`, downcast to `T`.
Source§
```

--------------------------------

### TilemapTileSize Reflection Implementations

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/map/struct.TilemapTileSize.html

Provides methods for constructing TilemapTileSize from reflected values and handling reflection-related operations.

```APIDOC
## impl FromReflect for TilemapTileSize

### fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>
Constructs a concrete instance of `Self` from a reflected value.

### fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>
Attempts to downcast the given value to `Self` using, constructing the value using `from_reflect` if that fails.
```

```APIDOC
## impl PartialReflect for TilemapTileSize

### fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
Returns the `TypeInfo` of the type _represented_ by this value.

### fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>
Tries to `apply` 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<Self>) -> ReflectOwned
Returns an owned enumeration of “kinds” of type.

### fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>
Attempts to cast this type to a boxed, fully-reflected value.

### fn try_as_reflect(&self) -> Option<&dyn Reflect>
Attempts to cast this type to a fully-reflected value.

### fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>
Attempts to cast this type to a mutable, fully-reflected value.

### fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>
Casts this type to a boxed, reflected value.

### fn as_partial_reflect(&self) -> &dyn PartialReflect
Casts this type to a reflected value.

### fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect
Casts this type to a mutable, reflected value.

### fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>
Returns a “partial equality” comparison result.

### fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>
Attempts to clone `Self` using reflection.

### fn apply(&mut self, value: &(dyn PartialReflect + 'static))
Applies a reflected value to this value.

### fn to_dynamic(&self) -> Box<dyn PartialReflect>
Converts this reflected value into its dynamic representation based on its kind.

### fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
where T: 'static, Self: Sized + TypePath,
For a type implementing `PartialReflect`, combines `reflect_clone` and `take` in a useful fashion, automatically constructing an appropriate `ReflectCloneError` if the downcast fails.

### 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 is_dynamic(&self) -> bool
Indicates whether or not this type is a _dynamic_ type.
```

--------------------------------

### Get Tile Entity by Position

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.TileStorage.html

Retrieves the entity associated with a specific tile position. Panics if the position is out of bounds.

```rust
pub fn get(&self, tile_pos: &TilePos) -> Option<Entity>
```

--------------------------------

### TryFrom and TryInto Implementations

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/hex_grid/neighbors/struct.HexNeighbors.html

Provides `TryFrom` and `TryInto` implementations for type conversions.

```APIDOC
### `impl<T, U> TryFrom<U> for T`

Allows attempting to convert a value of type `U` into type `T`.

#### Associated Types:
- `type Error = Infallible`: The type returned in the event of a conversion error.

#### Methods:
- `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.

### `impl<T, U> TryInto<U> for T`

Allows attempting to convert a value of type `T` into type `U`.

#### Associated Types:
- `type Error = <U as TryFrom<T>>::Error`: The type returned in the event of a conversion error.

#### Methods:
- `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

--------------------------------

### FractionalCubePos Constructor and Rounding Method

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/cube.rs.html

Provides a constant constructor `new` for FractionalCubePos and a `round` method to convert it to the nearest CubePos, useful for determining the hex tile a fractional position belongs to.

```rust
impl FractionalCubePos {
    pub const fn new(q: f32, r: f32, s: f32) -> Self {
        Self { q, r, s }
    }

    /// Returns `self` rounded to a [`CubePos`] that contains `self`. This is particularly useful
    /// for determining the hex tile that this fractional position is in.
    #[inline]
    pub fn round(&self) -> CubePos {
        let q_round = self.q.round();
        let r_round = self.r.round();
        let s_round = self.s.round();

        let q_diff = (q_round - self.q).abs();
        let r_diff = (r_round - self.r).abs();
        let s_diff = (s_round - self.s).abs();

        // TODO: This is not the most accurate way to round cube coordinates.
        // See https://www.redblobgames.com/grids/hexagons/#rounding-cube-coordinate
        // For now, we will just round each component and then correct the s component.
        // This is good enough for most cases.
        let mut q = q_round as i32;
        let mut r = r_round as i32;
        let mut s = s_round as i32;

        if q_diff + r_diff + s_diff > 1.0 {
            if q_diff > r_diff && q_diff > s_diff {
                q = -r - s;
            } else if r_diff > q_diff && r_diff > s_diff {
                r = -q - s;
            } else {
                s = -q - r;
            }
        }

        CubePos::new(q, r, s)
    }
}
```

--------------------------------

### TileColor Type Registration

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.TileColor.html

Provides the method to get the TypeRegistration for TileColor, essential for Bevy's reflection system.

```rust
fn get_type_registration() -> TypeRegistration

```

--------------------------------

### Get GPU Texture from Cache

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/texture_array_cache.rs.html

Retrieves a `GpuImage` from the texture cache using its `TilemapTexture` handle. Panics if the texture is not found.

```rust
pub fn get(&self, texture: &TilemapTexture) -> &GpuImage {
        self.textures.get(texture).unwrap()
    }
```

--------------------------------

### ColEvenPos new() Constructor

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/hex_grid/offset/struct.ColEvenPos.html

Creates a new ColEvenPos instance with the specified q and r coordinates.

```rust
pub const fn new(q: i32, r: i32) -> Self
```

--------------------------------

### Initialize Material Tilemap Pipeline

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/render/material.rs.html

Creates a new `MaterialTilemapPipeline` from the world, initializing the material layout descriptor using the `M::bind_group_layout_descriptor` function. This pipeline is essential for rendering custom tilemap materials.

```rust
impl<M: MaterialTilemap> FromWorld for MaterialTilemapPipeline<M> {
    fn from_world(world: &mut World) -> Self {
        let asset_server = world.resource::<AssetServer>();
        let render_device = world.resource::<RenderDevice>();
        let material_tilemap_layout = M::bind_group_layout_descriptor(render_device);

        MaterialTilemapPipeline {
            tilemap_pipeline: world.resource::<TilemapPipeline>().clone(),
            material_tilemap_layout,
            vertex_shader: match M::vertex_shader() {
                ShaderRef::Default => None,
                ShaderRef::Handle(handle) => Some(handle),

```

--------------------------------

### Get Offset in HexColDirection (Compass)

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Calculates the offset tile position in a given `HexRowDirection` (compass direction) from the current tile.

```rust
/// Get the tile offset from `self` in the given [`HexColDirection`].
#[inline]
pub fn offset_compass(&self, direction: HexRowDirection) -> Self {
    Self::from(AxialPos::from(*self).offset(direction.into()))
}
```

--------------------------------

### Bundle Trait Implementation for TileBundle

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.TileBundle.html

This implementation of the Bundle trait for TileBundle provides a way to get component IDs for the bundle.

```rust
fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>
```

--------------------------------

### TilemapTileSize Implementations

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/map.rs.html

Provides implementations for arithmetic operations and conversions for `TilemapTileSize`, allowing addition with itself or `Vec2`, and conversion to and from `TilemapGridSize` and `Vec2`.

```APIDOC
impl Add<TilemapTileSize> for TilemapTileSize
impl Add<Vec2> for TilemapTileSize
impl From<TilemapTileSize> for TilemapGridSize
impl From<TilemapTileSize> for Vec2
impl From<&TilemapTileSize> for Vec2
impl From<Vec2> for TilemapTileSize
```

--------------------------------

### Get Type Registration for TilemapSize

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/map/struct.TilemapSize.html

Provides the default TypeRegistration for TilemapSize, which is necessary for Bevy ECS to recognize and manage this type.

```rust
fn get_type_registration() -> TypeRegistration
```

--------------------------------

### Get Center in World Space

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/hex_grid/offset.rs.html

Calculates the world space position of the center of a hex tile. Requires tilemap grid size.

```rust
/// Returns the position of this tile's center, in world space.
#[inline]
pub fn center_in_world(&self, grid_size: &TilemapGridSize) -> Vec2 {
    let axial_pos = AxialPos::from(*self);
    axial_pos.center_in_world_col(grid_size)
}
```

--------------------------------

### TilemapTileSize New Constructor

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/map.rs.html

Creates a new TilemapTileSize with specified x and y dimensions.

```rust
pub const fn new(x: f32, y: f32) -> Self {
    Self { x, y }
}
```

--------------------------------

### Get Neighbor by SquareDirection

Source: https://docs.rs/bevy_ecs_tilemap/latest/src/bevy_ecs_tilemap/helpers/square_grid/neighbors.rs.html

Retrieves an immutable reference to an optional neighbor in a specific square direction. Returns `None` if the neighbor does not exist.

```rust
pub fn get(&self, direction: SquareDirection) -> Option<&T> {
    use SquareDirection::*;
    match direction {
        East => self.east.as_ref(),
        NorthEast => self.north_east.as_ref(),
        North => self.north.as_ref(),
        NorthWest => self.north_west.as_ref(),
        West => self.west.as_ref(),
        SouthWest => self.south_west.as_ref(),
        South => self.south.as_ref(),
        SouthEast => self.south_east.as_ref(),
    }
}
```

--------------------------------

### Safely Get Tile Entity by Position

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.TileStorage.html

Safely retrieves the entity for a tile position, returning None if the position is out of bounds or has no entity.

```rust
pub fn checked_get(&self, tile_pos: &TilePos) -> Option<Entity>
```

--------------------------------

### Get Neighboring Entities

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/square_grid/neighbors/struct.Neighbors.html

Retrieves the `Entity` for each neighboring tile position from the `TileStorage`. This is useful for interacting with entities associated with adjacent tiles.

```rust
pub fn entities(&self, tile_storage: &TileStorage) -> Neighbors<Entity>
```

--------------------------------

### Create a new FractionalCubePos

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/hex_grid/cube/struct.FractionalCubePos.html

Constructs a new FractionalCubePos with specified q, r, and s floating-point coordinates.

```rust
pub const fn new(q: f32, r: f32, s: f32) -> Self
```

--------------------------------

### Get Corner Offset in World Space

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/helpers/square_grid/diamond/struct.DiamondPos.html

Calculates the world space offset to a specific corner of a tile. Useful for precise positioning.

```rust
pub fn corner_offset_in_world( corner_direction: SquareDirection, grid_size: &TilemapGridSize, ) -> Vec2
```

--------------------------------

### AnimatedTile Struct Definition

Source: https://docs.rs/bevy_ecs_tilemap/latest/bevy_ecs_tilemap/tiles/struct.AnimatedTile.html

Defines the AnimatedTile component, which controls tile animation by specifying start and end frames and playback speed.

```rust
pub struct AnimatedTile {
    pub start: u32,
    pub end: u32,
    pub speed: f32,
}
```
Tokens:
Raw