Add in_world_tile_size field to determine how large each tile is rendered in-world

examples/accessing_tiles.rs

@@ -90,6 +90,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
             map_type,
             texture: TilemapTexture::Single(texture_handle),
             tile_size,
+            in_world_tile_size: tile_size.into(),
             transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
             ..Default::default()
         },

examples/animation.rs

@@ -58,6 +58,7 @@ fn create_background(mut commands: Commands, asset_server: Res<AssetServer>) {
         grid_size,
         map_type,
         tile_size,
+        in_world_tile_size: tile_size.into(),
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         transform: get_tilemap_center_transform(&size, &grid_size, &map_type, 0.0),
@@ -115,6 +116,7 @@ fn create_animated_flowers(mut commands: Commands, asset_server: Res<AssetServer
         grid_size,
         map_type,
         tile_size,
+        in_world_tile_size: tile_size.into(),
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 1.0),

examples/basic.rs

@@ -56,6 +56,7 @@ fn startup(
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()
     });

examples/bench.rs

@@ -25,6 +25,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
     let tile_size = TilemapTileSize { x: 16.0, y: 16.0 };
     let grid_size = tile_size.into();
+
     let map_type = TilemapType::default();
 
     commands.entity(tilemap_entity).insert(TilemapBundle {
@@ -34,6 +35,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         render_settings: TilemapRenderSettings {
             render_chunk_size: UVec2::new(256, 256),

examples/chunking.rs

@@ -44,6 +44,7 @@ fn spawn_chunk(commands: &mut Commands, asset_server: &AssetServer, chunk_pos: I
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size: TILE_SIZE,
+        in_world_tile_size: TILE_SIZE.into(),
         transform,
         render_settings: TilemapRenderSettings {
             render_chunk_size: RENDER_CHUNK_SIZE,

examples/colors.rs

@@ -84,6 +84,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type: TilemapType::Square,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/custom_tile_scaling.rs

@@ -0,0 +1,68 @@
+use bevy::{
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    prelude::*,
+};
+use bevy_ecs_tilemap::prelude::*;
+
+mod helpers;
+
+fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn(Camera2dBundle::default());
+
+    let texture_handle: Handle<Image> = asset_server.load("tiles.png");
+
+    let map_size = TilemapSize { x: 32, y: 32 };
+    let mut tile_storage = TileStorage::empty(map_size);
+    let tilemap_entity = commands.spawn_empty().id();
+
+    fill_tilemap(
+        TileTextureIndex(0),
+        map_size,
+        TilemapId(tilemap_entity),
+        &mut commands,
+        &mut tile_storage,
+    );
+
+    // `tile_size` specifies how large in pixels each tile is in the source atlas texture
+    let tile_size = TilemapTileSize { x: 16.0, y: 16.0 };
+
+    // `in_world_tile_size` specifies how large to render each tile in the world
+    let in_world_tile_size = TilemapInWorldTileSize { x: 4.0, y: 4.0 };
+    // The `grid_size` is essentially how far about each tile is placed from eachother
+    let grid_size = TilemapGridSize { x: 4.0, y: 4.0 };
+
+    let map_type = TilemapType::default();
+
+    commands.entity(tilemap_entity).insert(TilemapBundle {
+        grid_size,
+        map_type,
+        size: map_size,
+        storage: tile_storage,
+        texture: TilemapTexture::Single(texture_handle),
+        tile_size,
+        in_world_tile_size,
+        transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
+        ..Default::default()
+    });
+}
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins
+                .set(WindowPlugin {
+                    primary_window: Option::Some(Window {
+                        title: String::from("Benchmark Example"),
+                        ..Default::default()
+                    }),
+                    ..default()
+                })
+                .set(ImagePlugin::default_nearest()),
+            LogDiagnosticsPlugin::default(),
+            FrameTimeDiagnosticsPlugin::default(),
+            TilemapPlugin,
+        ))
+        .add_systems(Startup, startup)
+        .add_systems(Update, helpers::camera::movement)
+        .run();
+}

examples/frustum_cull_test.rs

@@ -104,6 +104,7 @@ fn spawn_tilemap(mut commands: Commands, tile_handle_square: Res<TileHandleSquar
         storage: tile_storage,
         texture: TilemapTexture::Single(tile_handle_square.clone()),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type: TilemapType::Square,
         // The default behaviour is `FrustumCulling(true)`, but we supply this explicitly here
         // for the purposes of the example.

examples/game_of_life.rs

@@ -42,6 +42,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
             storage: tile_storage,
             texture: TilemapTexture::Single(texture_handle),
             tile_size,
+            in_world_tile_size: tile_size.into(),
             transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
             ..Default::default()
         },

examples/helpers/tiled.rs

@@ -376,6 +376,7 @@ pub fn process_loaded_maps(
                             storage: tile_storage,
                             texture: tilemap_texture.clone(),
                             tile_size,
+                            in_world_tile_size: tile_size.into(),
                             spacing: tile_spacing,
                             transform: get_tilemap_center_transform(
                                 &map_size,

examples/hex_neighbors.rs

@@ -77,6 +77,7 @@ fn spawn_tilemap(mut commands: Commands, tile_handle_hex_row: Res<TileHandleHexR
         storage: tile_storage,
         texture: TilemapTexture::Single(tile_handle_hex_row.clone()),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/hexagon_column.rs

@@ -80,6 +80,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/hexagon_generation.rs

@@ -82,6 +82,7 @@ fn spawn_tilemap(mut commands: Commands, tile_handle_hex_row: Res<TileHandleHexR
         storage: tile_storage,
         texture: TilemapTexture::Single(tile_handle_hex_row.clone()),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/hexagon_row.rs

@@ -79,6 +79,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/iso_diamond.rs

@@ -80,6 +80,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/iso_staggered.rs

@@ -82,6 +82,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/layers.rs

@@ -32,6 +32,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle.clone()),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()
     });
@@ -55,6 +56,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size: TilemapTileSize { x: 16.0, y: 16.0 },
+        in_world_tile_size: TilemapInWorldTileSize { x: 16.0, y: 16.0 },
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 1.0)
             * Transform::from_xyz(32.0, 32.0, 0.0),
         ..Default::default()

examples/mouse_to_tile.rs

@@ -101,6 +101,7 @@ fn spawn_tilemap(mut commands: Commands, tile_handle_square: Res<TileHandleSquar
         storage: tile_storage,
         texture: TilemapTexture::Single(tile_handle_square.clone()),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         map_type,
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()

examples/move_tile.rs

@@ -37,6 +37,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()
     });

examples/random_map.rs

@@ -44,6 +44,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()
     });

examples/remove_tiles.rs

@@ -39,6 +39,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
             storage: tile_storage,
             texture: TilemapTexture::Single(texture_handle),
             tile_size,
+            in_world_tile_size: tile_size.into(),
             transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
             ..Default::default()
         },

examples/spacing.rs

@@ -32,6 +32,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle.clone()),
         tile_size,
+        in_world_tile_size: tile_size.into(),
         spacing: TilemapSpacing { x: 8.0, y: 8.0 },
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
         ..Default::default()
@@ -56,6 +57,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size: TilemapTileSize { x: 16.0, y: 16.0 },
+        in_world_tile_size: TilemapInWorldTileSize { x: 16.0, y: 16.0 },
         transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 1.0)
             * Transform::from_xyz(32.0, 32.0, 0.0),
         ..Default::default()

examples/texture_container.rs

@@ -80,6 +80,7 @@ mod no_atlas {
             grid_size,
             map_type,
             tile_size,
+            in_world_tile_size: tile_size.into(),
             size: map_size,
             storage: tile_storage,
             texture: texture_vec,

examples/texture_vec.rs

@@ -74,6 +74,7 @@ mod no_atlas {
             grid_size,
             map_type,
             tile_size,
+            in_world_tile_size: tile_size.into(),
             size: map_size,
             storage: tile_storage,
             texture: texture_vec,

examples/visibility.rs

@@ -39,6 +39,7 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
             storage: tile_storage,
             texture: TilemapTexture::Single(texture_handle),
             tile_size,
+            in_world_tile_size: tile_size.into(),
             transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
             ..Default::default()
         },

src/helpers/transform.rs

@@ -1,5 +1,6 @@
+use crate::prelude::TilemapInWorldTileSize;
 use crate::tiles::TilePos;
-use crate::{TilemapGridSize, TilemapTileSize, TilemapType};
+use crate::{TilemapGridSize,  TilemapType};
 use bevy::math::{UVec2, Vec2, Vec3};
 use bevy::render::primitives::Aabb;
 
@@ -29,11 +30,11 @@ pub fn chunk_index_to_world_space(
 pub fn chunk_aabb(
     chunk_size: UVec2,
     grid_size: &TilemapGridSize,
-    tile_size: &TilemapTileSize,
+    in_world_tile_size: &TilemapInWorldTileSize,
     map_type: &TilemapType,
 ) -> Aabb {
     // The AABB minimum and maximum have to be modified by -border and +border respectively.
-    let border = Vec2::from(grid_size).max(tile_size.into());
+    let border = Vec2::from(grid_size).max(in_world_tile_size.into());
 
     // For most map types, it would be sufficient to calculate c0 and c3. However, for some map
     // types (right now, isometric diamond), this would not work, and for robustness (especially

src/lib.rs

@@ -30,7 +30,7 @@ use map::{
     TilemapGridSize, TilemapSize, TilemapSpacing, TilemapTexture, TilemapTextureSize,
     TilemapTileSize, TilemapType,
 };
-use prelude::{TilemapId, TilemapRenderSettings};
+use prelude::{TilemapId, TilemapInWorldTileSize, TilemapRenderSettings};
 #[cfg(feature = "render")]
 use render::material::{MaterialTilemap, StandardTilemapMaterial};
 use tiles::{
@@ -120,6 +120,7 @@ pub struct MaterialTilemapBundle<M: MaterialTilemap> {
     pub storage: TileStorage,
     pub texture: TilemapTexture,
     pub tile_size: TilemapTileSize,
+    pub in_world_tile_size: TilemapInWorldTileSize,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
     pub render_settings: TilemapRenderSettings,
@@ -145,6 +146,7 @@ pub struct StandardTilemapBundle {
     pub storage: TileStorage,
     pub texture: TilemapTexture,
     pub tile_size: TilemapTileSize,
+    pub in_world_tile_size: TilemapInWorldTileSize,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
     pub render_settings: TilemapRenderSettings,