From e803d0bf4c7ccc997c1e011b6dd5837ad2d1b653 Mon Sep 17 00:00:00 2001
From: Arc-blroth <45273859+Arc-blroth@users.noreply.github.com>
Date: Thu, 18 Aug 2022 12:25:09 -0700
Subject: [PATCH 1/4] update bevy -> 0.8 and benimator -> 4.0.0-rc.1

---
 Cargo.toml                    |   4 +--
 assets/sprites/hello.aseprite | Bin 2039 -> 2069 bytes
 examples/animated/main.rs     |  50 ++++++++++++++++++++++++++--------
 src/benimator.rs              |   6 ++--
 src/loader.rs                 |   4 +--
 5 files changed, 45 insertions(+), 19 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 82062eb..31dd7c2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,11 +7,11 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.7"
+bevy = "0.8"
 asefile = "0.3.5"
 anyhow = "1.0"
 bevy_ecs_tilemap = { version = "0.6.0", optional = true }
-benimator = { version = "3.5.0", optional = true}
+benimator = { version = "4.0.0-rc.1", optional = true}
 
 [profile.dev.package."*"]
 opt-level = 2
diff --git a/assets/sprites/hello.aseprite b/assets/sprites/hello.aseprite
index c9c7f3e9aecfbcc8ebd7fbcbcb0d66abf2eb5195..2901ec5c398a61c75966b7c879782e1d264948ac 100644
GIT binary patch
delta 68
zcmey)KUIK9lw%@O9pllBjr`1du?!3h5(>;f5(b!H3<%B5;98biR9TXdnU}7(c>!}c
F3jm0j3$OqH

delta 38
ocmbO#@SUIOJNrbYI>zN28~K?9>=_ssBovr{Bm`{U#~jWA0KwG=0RR91

diff --git a/examples/animated/main.rs b/examples/animated/main.rs
index 14a828d..d5eb796 100644
--- a/examples/animated/main.rs
+++ b/examples/animated/main.rs
@@ -1,24 +1,31 @@
 use std::path::Path;
 
-use bevy::{input::system::exit_on_esc_system, prelude::*, sprite::SpriteSheetBundle};
+use bevy::{prelude::*, reflect::TypeUuid, sprite::SpriteSheetBundle};
 use bevy_ase::{
     self,
     asset::{Animation, AseAsset},
     loader::{self, Loader},
 };
 
+#[derive(TypeUuid, Deref)]
+#[uuid = "33fd3d9b-dd1e-4d38-9b82-30751b29c72c"]
+pub struct SpriteSheetAnimation(benimator::Animation);
+
+#[derive(Default, Component, Deref, DerefMut)]
+pub struct SpriteSheetAnimationState(benimator::State);
+
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_plugin(loader::AseLoaderDefaultPlugin)
-        .add_plugin(benimator::AnimationPlugin::default())
-        .add_system(exit_on_esc_system.system())
+        .add_asset::<SpriteSheetAnimation>()
         .add_state(AppState::Loading)
-        .add_system_set(SystemSet::on_enter(AppState::Loading).with_system(load_sprites.system()))
+        .add_system_set(SystemSet::on_enter(AppState::Loading).with_system(load_sprites))
         .add_system_set(
-            SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites.system()),
+            SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites),
         )
-        .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_sprites.system()))
+        .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_sprites))
+        .add_system_set(SystemSet::on_update(AppState::Game).with_system(animate))
         .run()
 }
 
@@ -47,11 +54,11 @@ pub fn check_loading_sprites(mut state: ResMut<State<AppState>>, ase_loader: Res
 pub fn spawn_sprites(
     mut commands: Commands,
     animations: Res<Assets<Animation>>,
-    mut sprite_sheet_animations: ResMut<Assets<benimator::SpriteSheetAnimation>>,
+    mut sprite_sheet_animations: ResMut<Assets<SpriteSheetAnimation>>,
 ) {
     commands.spawn_bundle({
-        let mut b = OrthographicCameraBundle::new_2d();
-        b.orthographic_projection.scale = 1.0 / 3.0; // scale to 3x
+        let mut b = Camera2dBundle::default();
+        b.projection.scale = 1.0 / 3.0; // scale to 3x
         b
     });
 
@@ -59,8 +66,8 @@ pub fn spawn_sprites(
     for (idx, (_id, anim)) in anims {
         let texture_atlas = anim.atlas();
         // The "benimator" feature provides a From implementation to convert animations.
-        let anim: benimator::SpriteSheetAnimation = anim.into();
-        let anim_handle = sprite_sheet_animations.add(anim);
+        let anim: benimator::Animation = anim.into();
+        let anim_handle = sprite_sheet_animations.add(SpriteSheetAnimation(anim));
         let x_position = idx as f32 * 50.0;
 
         commands
@@ -70,6 +77,25 @@ pub fn spawn_sprites(
                 ..Default::default()
             })
             .insert(anim_handle)
-            .insert(benimator::Play);
+            .insert(SpriteSheetAnimationState::default());
+    }
+}
+
+pub fn animate(
+    time: Res<Time>,
+    animations: Res<Assets<SpriteSheetAnimation>>,
+    mut query: Query<(
+        &mut SpriteSheetAnimationState,
+        &mut TextureAtlasSprite,
+        &Handle<SpriteSheetAnimation>,
+    )>,
+) {
+    for (mut state, mut texture, handle) in query.iter_mut() {
+        let animation = match animations.get(handle) {
+            Some(anim) => anim,
+            None => continue,
+        };
+        state.update(animation, time.delta());
+        texture.index = state.frame_index();
     }
 }
diff --git a/src/benimator.rs b/src/benimator.rs
index 294f430..29c742f 100644
--- a/src/benimator.rs
+++ b/src/benimator.rs
@@ -9,9 +9,9 @@ impl From<&Frame> for benimator::Frame {
         )
     }
 }
-impl From<&Animation> for benimator::SpriteSheetAnimation {
+impl From<&Animation> for benimator::Animation {
     fn from(a: &Animation) -> Self {
-        let frames = a.frames().iter().map(|f| f.into()).collect();
-        benimator::SpriteSheetAnimation::from_frames(frames)
+        let frames = a.frames().iter().map(|f| f.into());
+        benimator::Animation::from_frames(frames)
     }
 }
diff --git a/src/loader.rs b/src/loader.rs
index 03f8e40..961d038 100644
--- a/src/loader.rs
+++ b/src/loader.rs
@@ -212,7 +212,7 @@ impl Loader {
         let mut ase_files: Vec<(PathBuf, AsepriteFile)> = Vec::with_capacity(handles.len());
         for h in &handles {
             let ase_asset = aseprites
-                .get_mut(h.clone_weak())
+                .get_mut(&h)
                 .expect("Failed to get aseprite from handle");
 
             // We actually remove the AsepriteFile from the AsepriteAsset so
@@ -290,7 +290,6 @@ pub(crate) type AseAssetResources<'a> = (
 /// ```
 pub fn ase_importer(
     mut loader: ResMut<Loader>,
-    task_pool: ResMut<AsyncComputeTaskPool>,
     mut aseassets: ResMut<Assets<AseAsset>>,
     asset_server: Res<AssetServer>,
     resources: AseAssetResources,
@@ -300,6 +299,7 @@ pub fn ase_importer(
         debug!("Processing asefiles (batches: {})", pending);
     }
     if loader.all_todo_handles_ready(&asset_server) {
+        let task_pool = AsyncComputeTaskPool::get();
         loader.spawn_tasks(&task_pool, &mut aseassets);
     }
     loader.move_finished_into_resources(resources);

From 75efd292f2dba7931b534c8cef464d9058709768 Mon Sep 17 00:00:00 2001
From: Arc-blroth <45273859+Arc-blroth@users.noreply.github.com>
Date: Thu, 18 Aug 2022 16:33:40 -0700
Subject: [PATCH 2/4] [breaking] update bevy_ecs_tilemap -> 0.7.0

---
 Cargo.toml               |  4 +--
 examples/tilemap/main.rs | 60 ++++++++++++++++++++--------------------
 src/bevy_ecs_tilemap.rs  | 44 ++++++++++++-----------------
 3 files changed, 49 insertions(+), 59 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 31dd7c2..e1fc2e2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ase"
-version = "0.3.1"
+version = "0.4.0"
 authors = ["Bruce Reif", "alpine_alpaca <alpine.alpaca.games@gmail.com>", ]
 edition = "2021"
 
@@ -10,7 +10,7 @@ edition = "2021"
 bevy = "0.8"
 asefile = "0.3.5"
 anyhow = "1.0"
-bevy_ecs_tilemap = { version = "0.6.0", optional = true }
+bevy_ecs_tilemap = { version = "0.7.0", optional = true }
 benimator = { version = "4.0.0-rc.1", optional = true}
 
 [profile.dev.package."*"]
diff --git a/examples/tilemap/main.rs b/examples/tilemap/main.rs
index d62cbb6..a45bb3d 100644
--- a/examples/tilemap/main.rs
+++ b/examples/tilemap/main.rs
@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use bevy::{input::system::exit_on_esc_system, prelude::*};
+use bevy::prelude::*;
 use bevy_ase::{
     self,
     asset::{AseAsset, Tileset},
@@ -14,14 +14,13 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_plugin(TilemapPlugin)
         .add_plugin(loader::AseLoaderDefaultPlugin)
-        .add_system(exit_on_esc_system.system())
         .add_state(AppState::Loading)
-        .add_system_set(SystemSet::on_enter(AppState::Loading).with_system(load_sprites.system()))
+        .add_system_set(SystemSet::on_enter(AppState::Loading).with_system(load_sprites))
         .add_system_set(
-            SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites.system()),
+            SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites),
         )
-        .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_camera.system()))
-        .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_tiles.system()))
+        .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_camera))
+        .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_tiles))
         .run()
 }
 
@@ -48,23 +47,27 @@ pub fn check_loading_sprites(mut state: ResMut<State<AppState>>, aseloader: Res<
 
 fn spawn_camera(mut commands: Commands) {
     commands.spawn_bundle({
-        let mut b = OrthographicCameraBundle::new_2d();
-        b.orthographic_projection.scale = 1.0 / 3.0; // scale to 3x
+        let mut b = Camera2dBundle::default();
+        b.projection.scale = 1.0 / 3.0; // scale to 3x
         b
     });
 }
 
-fn set_tiles(layer_builder: &mut LayerBuilder<TileBundle>) {
+fn set_tiles(commands: &mut Commands, map_entity: Entity, tile_storage: &mut TileStorage) {
     for y in 0..3 {
         let y_offset = 7 - (y * 3);
         for x in 0..3 {
             let texture_index = y_offset + x;
-            let tile = Tile {
-                texture_index,
-                ..Tile::default()
-            };
-            let tile_pos = UVec2::new(x as u32, y as u32);
-            layer_builder.set_tile(tile_pos, tile.into()).unwrap();
+            let tile_pos = TilePos::new(x as u32, y as u32);
+            let tile = commands
+                .spawn_bundle(TileBundle {
+                    position: tile_pos,
+                    tilemap_id: TilemapId(map_entity),
+                    texture: TileTexture(texture_index),
+                    ..TileBundle::default()
+                })
+                .id();
+            tile_storage.set(&tile_pos, Some(tile));
         }
     }
 }
@@ -72,28 +75,25 @@ fn set_tiles(layer_builder: &mut LayerBuilder<TileBundle>) {
 fn spawn_tiles(
     mut commands: Commands,
     tilesets: Res<Assets<Tileset>>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-    mut map_query: MapQuery,
 ) {
     for (_, tileset) in tilesets.iter() {
         let texture_handle = tileset.texture.clone();
-        let material_handle = materials.add(ColorMaterial::texture(texture_handle));
-        // The layer_settings method of Tileset is implemented in the "bevy_ecs_tilemap" feature.
-        let settings = tileset.layer_settings(UVec2::new(3, 3), UVec2::new(3, 3));
 
-        let (mut layer_builder, layer_entity) =
-            LayerBuilder::<TileBundle>::new(&mut commands, settings, 0u16, 0u16);
-
-        set_tiles(&mut layer_builder);
+        let map_size = TilemapSize { x: 3, y: 3 };
+        let map_entity = commands.spawn().id();
+        let mut tile_storage = TileStorage::empty(map_size);
 
-        map_query.build_layer(&mut commands, layer_builder, material_handle);
+        set_tiles(&mut commands, map_entity, &mut tile_storage);
 
-        let map_entity = commands.spawn().id();
-        let mut map = Map::new(0u16, map_entity);
-        map.add_layer(&mut commands, 0u16, layer_entity);
         commands
             .entity(map_entity)
-            .insert(map)
-            .insert(GlobalTransform::default());
+            .insert_bundle(TilemapBundle {
+                grid_size: (&tileset.tile_size).into(),
+                size: map_size,
+                storage: tile_storage,
+                texture: TilemapTexture(texture_handle),
+                tile_size: (&tileset.tile_size).into(),
+                ..Default::default()
+            });
     }
 }
diff --git a/src/bevy_ecs_tilemap.rs b/src/bevy_ecs_tilemap.rs
index 440b048..c6976e1 100644
--- a/src/bevy_ecs_tilemap.rs
+++ b/src/bevy_ecs_tilemap.rs
@@ -1,5 +1,5 @@
-use crate::asset::{TileSize, Tileset};
-use bevy::math::{UVec2, Vec2};
+use crate::asset::TileSize;
+use bevy::math::Vec2;
 use bevy_ecs_tilemap::prelude::*;
 
 impl From<TileSize> for Vec2 {
@@ -8,30 +8,20 @@ impl From<TileSize> for Vec2 {
     }
 }
 
-impl Tileset {
-    /// Creates new [LayerSettings] using the [Tileset's](Tileset) own tile size and texture size.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #[cfg(feature = "bevy_ecs_tilemap")]
-    /// use bevy_ase::asset::Tileset;
-    /// use bevy_ecs_tilemap::LayerSettings;
-    /// use bevy::math::UVec2;
-    ///
-    /// // Create new layer settings from a tileset, with specified map size and chunk size.
-    /// fn my_layer_settings(tileset: &Tileset) -> LayerSettings {
-    ///     let map_size = UVec2::new(30, 30);
-    ///     let chunk_size = UVec2::new(15, 15);
-    ///     tileset.layer_settings(map_size, chunk_size)       
-    /// }
-    /// ```
-    pub fn layer_settings(&self, map_size: UVec2, chunk_size: UVec2) -> LayerSettings {
-        LayerSettings::new(
-            map_size,
-            chunk_size,
-            Vec2::new(self.tile_size.width as f32, self.tile_size.height as f32),
-            self.texture_size(),
-        )
+impl From<&TileSize> for TilemapTileSize {
+    fn from(tile_size: &TileSize) -> Self {
+        Self {
+            x: tile_size.width as f32,
+            y: tile_size.height as f32,
+        }
+    }
+}
+
+impl From<&TileSize> for TilemapGridSize {
+    fn from(tile_size: &TileSize) -> Self {
+        Self {
+            x: tile_size.width as f32,
+            y: tile_size.height as f32,
+        }
     }
 }

From 6b229657a048996ee978a6d242713b8cf9ec6c12 Mon Sep 17 00:00:00 2001
From: Arc-blroth <45273859+Arc-blroth@users.noreply.github.com>
Date: Thu, 18 Aug 2022 18:43:56 -0700
Subject: [PATCH 3/4] use nearest image sampling

---
 src/processing.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/processing.rs b/src/processing.rs
index 256b7ea..a52ad15 100644
--- a/src/processing.rs
+++ b/src/processing.rs
@@ -12,6 +12,7 @@ use asefile::AsepriteFile;
 use bevy::sprite::TextureAtlasBuilder;
 use bevy::{prelude::*, utils::HashMap};
 use std::path::{Path, PathBuf};
+use bevy::render::texture::ImageSampler;
 
 fn tilesets_from(ase: &AsepriteFile) -> TilesetResult<Vec<TilesetData<Image>>> {
     let f = |t| TilesetData::<Image>::from_ase_with_texture(ase, t);
@@ -150,6 +151,11 @@ fn move_sprites(
     let atlas = texture_atlas_builder
         .finish(images)
         .expect("Creating texture atlas failed");
+    // Since we likely are dealing with pixel art, default to nearest image sampling
+    images
+        .get_mut(&atlas.texture)
+        .expect("Texture atlas texture missing")
+        .sampler_descriptor = ImageSampler::nearest();
     let atlas_handle_id = handle_id::atlas(path);
     let atlas_handle = atlases.set(atlas_handle_id, atlas);
     file_assets.insert_atlas(atlas_handle.clone());

From e7bb3095efbf83fb64470a11729b81578b41e600 Mon Sep 17 00:00:00 2001
From: Arc-blroth <45273859+Arc-blroth@users.noreply.github.com>
Date: Thu, 18 Aug 2022 18:44:40 -0700
Subject: [PATCH 4/4] run cargo fmt

---
 examples/animated/main.rs |  4 +---
 examples/tilemap/main.rs  | 27 ++++++++++-----------------
 src/processing.rs         |  2 +-
 3 files changed, 12 insertions(+), 21 deletions(-)

diff --git a/examples/animated/main.rs b/examples/animated/main.rs
index d5eb796..d330e1d 100644
--- a/examples/animated/main.rs
+++ b/examples/animated/main.rs
@@ -21,9 +21,7 @@ fn main() {
         .add_asset::<SpriteSheetAnimation>()
         .add_state(AppState::Loading)
         .add_system_set(SystemSet::on_enter(AppState::Loading).with_system(load_sprites))
-        .add_system_set(
-            SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites),
-        )
+        .add_system_set(SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites))
         .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_sprites))
         .add_system_set(SystemSet::on_update(AppState::Game).with_system(animate))
         .run()
diff --git a/examples/tilemap/main.rs b/examples/tilemap/main.rs
index a45bb3d..e406a21 100644
--- a/examples/tilemap/main.rs
+++ b/examples/tilemap/main.rs
@@ -16,9 +16,7 @@ fn main() {
         .add_plugin(loader::AseLoaderDefaultPlugin)
         .add_state(AppState::Loading)
         .add_system_set(SystemSet::on_enter(AppState::Loading).with_system(load_sprites))
-        .add_system_set(
-            SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites),
-        )
+        .add_system_set(SystemSet::on_update(AppState::Loading).with_system(check_loading_sprites))
         .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_camera))
         .add_system_set(SystemSet::on_enter(AppState::Game).with_system(spawn_tiles))
         .run()
@@ -72,10 +70,7 @@ fn set_tiles(commands: &mut Commands, map_entity: Entity, tile_storage: &mut Til
     }
 }
 
-fn spawn_tiles(
-    mut commands: Commands,
-    tilesets: Res<Assets<Tileset>>,
-) {
+fn spawn_tiles(mut commands: Commands, tilesets: Res<Assets<Tileset>>) {
     for (_, tileset) in tilesets.iter() {
         let texture_handle = tileset.texture.clone();
 
@@ -85,15 +80,13 @@ fn spawn_tiles(
 
         set_tiles(&mut commands, map_entity, &mut tile_storage);
 
-        commands
-            .entity(map_entity)
-            .insert_bundle(TilemapBundle {
-                grid_size: (&tileset.tile_size).into(),
-                size: map_size,
-                storage: tile_storage,
-                texture: TilemapTexture(texture_handle),
-                tile_size: (&tileset.tile_size).into(),
-                ..Default::default()
-            });
+        commands.entity(map_entity).insert_bundle(TilemapBundle {
+            grid_size: (&tileset.tile_size).into(),
+            size: map_size,
+            storage: tile_storage,
+            texture: TilemapTexture(texture_handle),
+            tile_size: (&tileset.tile_size).into(),
+            ..Default::default()
+        });
     }
 }
diff --git a/src/processing.rs b/src/processing.rs
index a52ad15..32b0de6 100644
--- a/src/processing.rs
+++ b/src/processing.rs
@@ -9,10 +9,10 @@ use crate::{
     handle_id,
 };
 use asefile::AsepriteFile;
+use bevy::render::texture::ImageSampler;
 use bevy::sprite::TextureAtlasBuilder;
 use bevy::{prelude::*, utils::HashMap};
 use std::path::{Path, PathBuf};
-use bevy::render::texture::ImageSampler;
 
 fn tilesets_from(ase: &AsepriteFile) -> TilesetResult<Vec<TilesetData<Image>>> {
     let f = |t| TilesetData::<Image>::from_ase_with_texture(ase, t);