Support Bevy v0.12.0

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "bevy_ecs_tilemap"
 description = "A tilemap rendering plugin for bevy which is more ECS friendly by having an entity per tile."
-version = "0.11.1"
+version = "0.12.0"
 authors = ["John Mitchell"]
 homepage = "https://github.com/StarArawn/bevy_ecs_tilemap"
 repository = "https://github.com/StarArawn/bevy_ecs_tilemap"
@@ -16,25 +16,26 @@ atlas = []
 render = []
 
 [dependencies]
-bevy = { version = "0.11", default-features = false, features = [
+bevy = { version = "0.12", default-features = false, features = [
     "bevy_core_pipeline",
     "bevy_render",
     "bevy_asset",
     "bevy_sprite",
+    "multi-threaded"
 ] }
 log = "0.4"
 regex = "1.5.4"
 
 [dev-dependencies]
-anyhow = { version = "1.0" }
 ldtk_rust = { version = "0.6" }
 rand = "0.8"
 env_logger = "0.10"
 serde_json = { version = "1.0" }
 tiled = { version = "0.11.0", default-features = false }
+thiserror = { version = "1.0" }
 
 [dev-dependencies.bevy]
-version = "0.11"
+version = "0.12"
 default-features = false
 features = [
     "bevy_core_pipeline",
@@ -45,12 +46,13 @@ features = [
     "bevy_winit",
     "bevy_text",
     "bevy_sprite",
-    "filesystem_watcher",
-    "webgl2"
+    "file_watcher",
+    "webgl2",
+    "multi-threaded"
 ]
 
 [target.'cfg(unix)'.dev-dependencies.bevy]
-version = "0.11"
+version = "0.12"
 default-features = false
 features = [
     "bevy_core_pipeline",
@@ -62,6 +64,7 @@ features = [
     "x11",
     "bevy_text",
     "bevy_sprite",
+    "multi-threaded"
 ]
 
 

README.md

@@ -92,6 +92,7 @@ cargo run --target wasm32-unknown-unknown --example animation --release --featur
 |bevy|bevy_ecs_tilemap|
 |---|---|
 |`main`|`bevy-track`|
+|0.12|0.12|
 |0.11|0.11.*|
 |0.10|0.10|
 |0.9|0.9|

examples/3d_iso.rs

@@ -1,6 +1,4 @@
-use bevy::utils::Duration;
-
-use bevy::{asset::ChangeWatcher, prelude::*};
+use bevy::prelude::*;
 use bevy_ecs_tilemap::prelude::*;
 
 mod helpers;
@@ -35,7 +33,7 @@ fn main() {
                 })
                 .set(ImagePlugin::default_nearest())
                 .set(AssetPlugin {
-                    watch_for_changes: ChangeWatcher::with_delay(Duration::from_millis(200)),
+                    mode: AssetMode::Unprocessed,
                     ..default()
                 }),
         )

examples/custom_shader.rs

@@ -6,7 +6,7 @@ use bevy::{
 use bevy_ecs_tilemap::prelude::*;
 mod helpers;
 
-#[derive(AsBindGroup, TypeUuid, TypePath, Debug, Clone, Default)]
+#[derive(AsBindGroup, TypeUuid, TypePath, Debug, Clone, Default, Asset)]
 #[uuid = "31575692-a956-4762-98e2-5d457f552d0a"]
 pub struct MyMaterial {
     #[uniform(0)]

examples/helpers/ldtk.rs

@@ -4,12 +4,17 @@ use bevy_ecs_tilemap::{
     tiles::{TileBundle, TilePos, TileStorage, TileTextureIndex},
     TilemapBundle,
 };
-use std::collections::HashMap;
+use std::{collections::HashMap, io::ErrorKind};
+use thiserror::Error;
 
-use bevy::reflect::{TypePath, TypeUuid};
 use bevy::{
-    asset::{AssetLoader, AssetPath, BoxedFuture, LoadContext, LoadedAsset},
+    asset::{io::Reader, AsyncReadExt},
+    reflect::{TypePath, TypeUuid},
+};
+use bevy::{
+    asset::{AssetLoader, AssetPath, LoadContext},
     prelude::*,
+    utils::BoxedFuture,
 };
 use bevy_ecs_tilemap::map::TilemapType;
 
@@ -18,13 +23,13 @@ pub struct LdtkPlugin;
 
 impl Plugin for LdtkPlugin {
     fn build(&self, app: &mut App) {
-        app.add_asset::<LdtkMap>()
-            .add_asset_loader(LdtkLoader)
+        app.init_asset::<LdtkMap>()
+            .register_asset_loader(LdtkLoader)
             .add_systems(Update, process_loaded_tile_maps);
     }
 }
 
-#[derive(TypeUuid, TypePath)]
+#[derive(TypeUuid, TypePath, Asset)]
 #[uuid = "abf9eaf2-f21c-4b46-89b0-8aa5c42199af"]
 pub struct LdtkMap {
     pub project: ldtk_rust::Project,
@@ -46,14 +51,34 @@ pub struct LdtkMapBundle {
 
 pub struct LdtkLoader;
 
+#[derive(Debug, Error)]
+pub enum LdtkAssetLoaderError {
+    /// An [IO](std::io) Error
+    #[error("Could load LDTk file: {0}")]
+    Io(#[from] std::io::Error),
+}
+
 impl AssetLoader for LdtkLoader {
+    type Asset = LdtkMap;
+    type Settings = ();
+    type Error = LdtkAssetLoaderError;
+
     fn load<'a>(
         &'a self,
-        bytes: &'a [u8],
+        reader: &'a mut Reader,
+        _settings: &'a Self::Settings,
         load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
+    ) -> BoxedFuture<'a, Result<LdtkMap, LdtkAssetLoaderError>> {
         Box::pin(async move {
-            let project: ldtk_rust::Project = serde_json::from_slice(bytes)?;
+            let mut bytes = Vec::new();
+            reader.read_to_end(&mut bytes).await?;
+
+            let project: ldtk_rust::Project = serde_json::from_slice(&bytes).map_err(|e| {
+                std::io::Error::new(
+                    ErrorKind::Other,
+                    format!("Could not read contents of Ldtk map: {e}"),
+                )
+            })?;
             let dependencies: Vec<(i64, AssetPath)> = project
                 .defs
                 .tilesets
@@ -68,17 +93,14 @@ impl AssetLoader for LdtkLoader {
                 })
                 .collect();
 
-            let loaded_asset = LoadedAsset::new(LdtkMap {
+            let ldtk_map = LdtkMap {
                 project,
                 tilesets: dependencies
                     .iter()
-                    .map(|dep| (dep.0, load_context.get_handle(dep.1.clone())))
+                    .map(|dep| (dep.0, load_context.load(dep.1.clone())))
                     .collect(),
-            });
-            load_context.set_default_asset(
-                loaded_asset.with_dependencies(dependencies.iter().map(|x| x.1.clone()).collect()),
-            );
-            Ok(())
+            };
+            Ok(ldtk_map)
         })
     }
 
@@ -95,35 +117,36 @@ pub fn process_loaded_tile_maps(
     mut query: Query<(Entity, &Handle<LdtkMap>, &LdtkMapConfig)>,
     new_maps: Query<&Handle<LdtkMap>, Added<Handle<LdtkMap>>>,
 ) {
-    let mut changed_maps = Vec::<Handle<LdtkMap>>::default();
-    for event in map_events.iter() {
+    let mut changed_maps = Vec::<AssetId<LdtkMap>>::default();
+    for event in map_events.read() {
         match event {
-            AssetEvent::Created { handle } => {
+            AssetEvent::Added { id } => {
                 log::info!("Map added!");
-                changed_maps.push(handle.clone());
+                changed_maps.push(*id);
             }
-            AssetEvent::Modified { handle } => {
+            AssetEvent::Modified { id } => {
                 log::info!("Map changed!");
-                changed_maps.push(handle.clone());
+                changed_maps.push(*id);
             }
-            AssetEvent::Removed { handle } => {
+            AssetEvent::Removed { id } => {
                 log::info!("Map removed!");
                 // if mesh was modified and removed in the same update, ignore the modification
                 // events are ordered so future modification events are ok
-                changed_maps.retain(|changed_handle| changed_handle == handle);
+                changed_maps.retain(|changed_handle| changed_handle == id);
             }
+            _ => continue,
         }
     }
 
     // If we have new map entities, add them to the changed_maps list
     for new_map_handle in new_maps.iter() {
-        changed_maps.push(new_map_handle.clone());
+        changed_maps.push(new_map_handle.id());
     }
 
     for changed_map in changed_maps.iter() {
         for (entity, map_handle, map_config) in query.iter_mut() {
             // only deal with currently changed map
-            if map_handle != changed_map {
+            if map_handle.id() != *changed_map {
                 continue;
             }
             if let Some(ldtk_map) = maps.get(map_handle) {