Merge pull request #33 from ettoreleandrotognoli/issue-27

avoid to despawn already removed entities

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy-parallax"
-version = "0.6.0"
+version = "0.6.1"
 authors = ["Carlo Supina <cdsupina@gmail.com>"]
 edition = "2021"
 description = "A Bevy plugin for creating a parallax effect."

examples/reload.rs

@@ -0,0 +1,124 @@
+use bevy::prelude::*;
+use bevy_parallax::{
+    CreateParallaxEvent, LayerData, LayerSpeed, ParallaxCameraComponent, ParallaxMoveEvent,
+    ParallaxPlugin, ParallaxSystems,
+};
+
+fn main() {
+    // Define window
+    let primary_window = Window {
+        title: "Cyberpunk".to_string(),
+        resolution: (1280.0, 720.0).into(),
+        resizable: false,
+        ..Default::default()
+    };
+
+    App::new()
+        .add_plugins(
+            DefaultPlugins
+                .set(WindowPlugin {
+                    primary_window: Some(primary_window),
+                    ..default()
+                })
+                // Use nearest filtering so our pixel art renders clear
+                .set(ImagePlugin::default_nearest()),
+        )
+        .add_plugins(ParallaxPlugin)
+        .add_systems(Startup, initialize_camera_system)
+        .add_systems(Update, move_camera_system.before(ParallaxSystems))
+        .add_systems(Update, (reload_system, despawn_all))
+        .run();
+}
+
+pub fn new_create_parallax_event(camera: Entity) -> CreateParallaxEvent {
+    CreateParallaxEvent {
+        layers_data: vec![
+            LayerData {
+                speed: LayerSpeed::Horizontal(0.9),
+                path: "cyberpunk_back.png".to_string(),
+                tile_size: Vec2::new(96.0, 160.0),
+                cols: 1,
+                rows: 1,
+                scale: 4.5,
+                z: 0.0,
+                ..Default::default()
+            },
+            LayerData {
+                speed: LayerSpeed::Horizontal(0.6),
+                path: "cyberpunk_middle.png".to_string(),
+                tile_size: Vec2::new(144.0, 160.0),
+                cols: 1,
+                rows: 1,
+                scale: 4.5,
+                z: 1.0,
+                ..Default::default()
+            },
+            LayerData {
+                speed: LayerSpeed::Horizontal(0.1),
+                path: "cyberpunk_front.png".to_string(),
+                tile_size: Vec2::new(272.0, 160.0),
+                cols: 1,
+                rows: 1,
+                scale: 4.5,
+                z: 2.0,
+                ..Default::default()
+            },
+        ],
+        camera: camera,
+    }
+}
+
+// Put a ParallaxCameraComponent on the camera used for parallax
+pub fn initialize_camera_system(
+    mut commands: Commands,
+    mut create_parallax: EventWriter<CreateParallaxEvent>,
+) {
+    let camera = commands
+        .spawn(Camera2dBundle::default())
+        .insert(ParallaxCameraComponent::default())
+        .id();
+    create_parallax.send(new_create_parallax_event(camera));
+}
+
+pub fn reload_system(
+    keyboard_input: Res<Input<KeyCode>>,
+    camera_query: Query<Entity, With<Camera>>,
+    mut create_parallax: EventWriter<CreateParallaxEvent>,
+) {
+    let camera = camera_query.get_single().unwrap();
+    if keyboard_input.just_released(KeyCode::R) {
+        create_parallax.send(new_create_parallax_event(camera))
+    }
+}
+
+pub fn despawn_all(
+    mut commands: Commands,
+    keyboard_input: Res<Input<KeyCode>>,
+    all_query: Query<Entity, (Without<Camera>, Without<Window>)>,
+) {
+    if keyboard_input.just_released(KeyCode::Q) {
+        for entity in all_query.iter() {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+// Send a ParallaxMoveEvent with the desired camera movement speed
+pub fn move_camera_system(
+    keyboard_input: Res<Input<KeyCode>>,
+    mut move_event_writer: EventWriter<ParallaxMoveEvent>,
+    camera_query: Query<Entity, With<Camera>>,
+) {
+    let camera = camera_query.get_single().unwrap();
+    if keyboard_input.pressed(KeyCode::D) || keyboard_input.pressed(KeyCode::Right) {
+        move_event_writer.send(ParallaxMoveEvent {
+            camera_move_speed: Vec2::new(3.0, 0.0),
+            camera: camera,
+        });
+    } else if keyboard_input.pressed(KeyCode::A) || keyboard_input.pressed(KeyCode::Left) {
+        move_event_writer.send(ParallaxMoveEvent {
+            camera_move_speed: Vec2::new(-3.0, 0.0),
+            camera: camera,
+        });
+    }
+}

src/lib.rs

@@ -1,4 +1,4 @@
-use bevy::{prelude::*, render::view::RenderLayers, window::PrimaryWindow};
+use bevy::{prelude::*, window::PrimaryWindow};
 
 pub mod layer;
 pub mod parallax;
@@ -32,31 +32,31 @@ fn create_parallax_system(
     asset_server: Res<AssetServer>,
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     window_query: Query<&Window, With<PrimaryWindow>>,
-    mut parallax_query: Query<(&mut ParallaxCameraComponent, &Camera)>,
+    parallax_query: Query<(Entity, &ParallaxCameraComponent, &Camera)>,
+    layers_query: Query<(Entity, &LayerComponent)>,
     mut create_parallax_events: EventReader<CreateParallaxEvent>,
 ) {
     let primary_window = window_query.get_single().unwrap();
     let mut window_size = Vec2::new(primary_window.width(), primary_window.height());
     for event in create_parallax_events.iter() {
-        if let Ok((mut parallax, camera)) = parallax_query.get_mut(event.camera) {
-            for entity in parallax.entities.iter() {
-                commands.entity(*entity).despawn_recursive();
+        if let Ok((parallax_entity, parallax, camera)) = parallax_query.get(event.camera) {
+            for (entity, layer) in layers_query.iter() {
+                // If it is not my layer don't despawn
+                if layer.camera != parallax_entity {
+                    continue;
+                }
+                commands.entity(entity).despawn_recursive();
             }
             if let Some(viewport) = &camera.viewport {
                 window_size = viewport.physical_size.as_vec2();
             }
-            parallax.entities = event.create_layers(
+            event.create_layers(
                 &mut commands,
                 window_size,
                 &asset_server,
                 &mut texture_atlases,
                 parallax.render_layer,
             );
-            for entity in parallax.entities.iter() {
-                commands
-                    .entity(*entity)
-                    .insert(RenderLayers::from_layers(&[parallax.render_layer]));
-            }
         }
     }
 }

src/parallax.rs

@@ -17,8 +17,7 @@ impl CreateParallaxEvent {
         asset_server: &AssetServer,
         texture_atlases: &mut Assets<TextureAtlas>,
         render_layer: u8,
-    ) -> Vec<Entity> {
-        let mut entities = vec![];
+    )  {
         // Spawn new layers using layer_data
         for (i, layer) in self.layers_data.iter().enumerate() {
             // Setup texture
@@ -122,21 +121,19 @@ impl CreateParallaxEvent {
                 });
 
             // Add layer component to entity
-            entity_commands.insert(layer::LayerComponent {
-                speed: match layer.speed {
-                    layer::LayerSpeed::Horizontal(vx) => Vec2::new(vx, 0.0),
-                    layer::LayerSpeed::Vertical(vy) => Vec2::new(0.0, vy),
-                    layer::LayerSpeed::Bidirectional(vx, vy) => Vec2::new(vx, vy),
-                },
-                repeat: layer.repeat.clone(),
-                texture_count,
-                camera: self.camera,
-            });
-
-            // Push parallax layer entity to layer_entities
-            entities.push(entity_commands.id());
-        }
-        entities
+            entity_commands
+                .insert(layer::LayerComponent {
+                    speed: match layer.speed {
+                        layer::LayerSpeed::Horizontal(vx) => Vec2::new(vx, 0.0),
+                        layer::LayerSpeed::Vertical(vy) => Vec2::new(0.0, vy),
+                        layer::LayerSpeed::Bidirectional(vx, vy) => Vec2::new(vx, vy),
+                    },
+                    repeat: layer.repeat.clone(),
+                    texture_count,
+                    camera: self.camera,
+                })
+                .insert(RenderLayers::from_layers(&[render_layer]));
+        };
     }
 }
 
@@ -175,7 +172,6 @@ impl ParallaxMoveEvent {
 #[derive(Component)]
 pub struct ParallaxCameraComponent {
     pub render_layer: u8,
-    pub entities: Vec<Entity>,
 }
 
 impl ParallaxCameraComponent {
@@ -191,7 +187,6 @@ impl Default for ParallaxCameraComponent {
     fn default() -> Self {
         Self {
             render_layer: 0,
-            entities: vec![],
         }
     }
 }