0.14 refactoring

Cargo.toml

@@ -16,6 +16,7 @@ bevy = { version = "0.14", default-features = false, features = [
   "bevy_sprite",
 ] }
 bevy_editor_pls = { version = "0.9.0", optional = true }
+bevy_render_layers_manager = "0.1.0"
 fast_poisson = { version = "1.0.0", features = [
   "single_precision",
 ], optional = true }

examples/multiple.rs

@@ -1,61 +1,56 @@
 mod shared;
 
-use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_scroller::{Scroller, ScrollerBundle, ScrollerSize, SingleSpriteGenerator};
+use bevy::prelude::*;
+use bevy_scroller::{
+  Direction, FillMode, Scroller, ScrollerBundle, ScrollerGenerators, ScrollerSpawner,
+  SingleSpriteGenerator,
+};
 use shared::get_app;
-use std::f32::consts::PI;
 
 fn main() {
   get_app("multiple".into()).add_systems(Startup, start).run();
 }
 
-pub fn start(mut commands: Commands, windows: Query<&Window, With<PrimaryWindow>>) {
-  let window = windows.get_single().expect("no primary window");
+pub fn start(
+  mut commands: Commands,
+  spawners: Res<ScrollerGenerators>,
+  asset_server: Res<AssetServer>,
+) {
   let sprite_size = Vec2::new(128., 128.);
 
   commands.spawn(Camera2dBundle::default());
 
-  commands.spawn((
-    ScrollerSize {
-      size: Vec2::new(window.width(), sprite_size.y),
-    },
-    ScrollerBundle {
-      scroller: Scroller {
-        speed: 5.,
-        ..default()
-      },
+  commands
+    .spawn(ScrollerBundle {
+      scroller: Scroller::new(5.),
+      size: Vec2::new(1000., sprite_size.y).into(),
       generator: SingleSpriteGenerator {
-        path: "gems/1.png".into(),
+        texture: asset_server.load("bevy_logo.png"),
         size: sprite_size,
       },
-      spatial: SpatialBundle::from_transform(Transform::from_translation(Vec3::new(
-        0.,
-        (sprite_size.y - window.height()) / 2.,
-        0.,
-      ))),
-      ..default()
-    },
-  ));
+      spawner: ScrollerSpawner(*spawners.get::<SingleSpriteGenerator>().unwrap()),
+      direction: Direction::default(),
+      fill_mode: FillMode::default(),
+      spatial: SpatialBundle::from_transform(Transform::from_translation(Vec3::new(0., 200., 0.))),
+    })
+    .with_children(|parent| {
+      parent.spawn(());
+    });
 
-  commands.spawn((
-    ScrollerSize {
-      size: Vec2::new(window.width(), sprite_size.y),
-    },
-    ScrollerBundle {
-      scroller: Scroller {
-        speed: 5.,
-        ..default()
-      },
+  commands
+    .spawn(ScrollerBundle {
+      scroller: Scroller::new(5.),
+      size: Vec2::new(1000., sprite_size.y).into(),
       generator: SingleSpriteGenerator {
-        path: "gems/2.png".into(),
+        texture: asset_server.load("gems/2.png"),
         size: sprite_size,
       },
-      spatial: SpatialBundle::from_transform(Transform {
-        translation: Vec3::new(0., (window.height() - sprite_size.y) / 2., 0.),
-        rotation: Quat::from_rotation_z(PI),
-        ..default()
-      }),
-      ..default()
-    },
-  ));
+      spawner: ScrollerSpawner(*spawners.get::<SingleSpriteGenerator>().unwrap()),
+      direction: Direction::default(),
+      fill_mode: FillMode::default(),
+      spatial: SpatialBundle::from_transform(Transform::from_translation(Vec3::new(0., -200., 0.))),
+    })
+    .with_children(|parent| {
+      parent.spawn(());
+    });
 }

examples/sequence.rs

@@ -72,7 +72,10 @@ pub fn run(
         speed: 5.,
         ..default()
       },
-      generator: SequenceSpriteGenerator { items },
+      generator: SequenceSpriteGenerator {
+				items
+			}
+			spawner: ,
       ..default()
     },
   ));

examples/shared/mod.rs

@@ -1,5 +1,6 @@
 use bevy::{prelude::*, window::WindowResized};
-use bevy_scroller::{ScrollerPlugin, ScrollerSize};
+use bevy_render_layers_manager::RenderLayersManagerPlugin;
+use bevy_scroller::{ScrollerPlugin, Size};
 use iyes_perf_ui::prelude::*;
 
 pub fn get_app(title: String) -> App {
@@ -21,8 +22,8 @@ pub fn get_app(title: String) -> App {
     .add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
     .add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin)
     .add_plugins(PerfUiPlugin)
-    .add_systems(Startup, default_start)
-    .add_systems(Update, on_resize);
+    .add_systems(Startup, default_start);
+  // .add_systems(Update, on_resize);
   #[cfg(feature = "dev")]
   {
     use bevy_editor_pls::EditorPlugin;
@@ -33,17 +34,15 @@ pub fn get_app(title: String) -> App {
 
 fn default_start(mut commands: Commands) {
   commands.spawn(PerfUiCompleteBundle::default());
+  // commands.spawn(PerfUiDefaultEntries::default());
 }
 
-fn on_resize(
-  mut resize_reader: EventReader<WindowResized>,
-  mut scroller_size: Query<&mut ScrollerSize>,
-) {
+fn on_resize(mut resize_reader: EventReader<WindowResized>, mut scroller_size: Query<&mut Size>) {
   for e in resize_reader.read() {
     debug!("window resized: {:.1} x {:.1}", e.width, e.height);
     for mut ss in scroller_size.iter_mut() {
-      ss.size.x = e.width;
-      ss.size.y = e.height;
+      // ss.size.x = e.width;
+      // ss.size.y = e.height;
     }
   }
 }

examples/single.rs

@@ -1,33 +1,36 @@
 mod shared;
 
-use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_scroller::{Scroller, ScrollerBundle, ScrollerSize, SingleSpriteGenerator};
+use bevy::prelude::*;
+use bevy_scroller::{
+  Direction, FillMode, Scroller, ScrollerBundle, ScrollerGenerators, ScrollerSpawner,
+  SingleSpriteGenerator,
+};
 use shared::*;
 
 fn main() {
   get_app("single".into()).add_systems(Startup, start).run();
 }
 
-pub fn start(mut commands: Commands, windows: Query<&Window, With<PrimaryWindow>>) {
-  let primary_window = windows.get_single().expect("no primary window");
+pub fn start(
+  mut commands: Commands,
+  spawners: Res<ScrollerGenerators>,
+  asset_server: Res<AssetServer>,
+) {
   let sprite_size = Vec2::new(300., 300.);
-
   commands.spawn(Camera2dBundle::default());
-
-  commands.spawn((
-    ScrollerSize {
-      size: Vec2::new(primary_window.width(), sprite_size.y),
-    },
-    ScrollerBundle {
-      scroller: Scroller {
-        speed: 5.,
-        ..default()
-      },
+  commands
+    .spawn(ScrollerBundle {
+      scroller: Scroller::new(5.),
+      size: Vec2::new(1000., 300.).into(),
       generator: SingleSpriteGenerator {
-        path: "bevy_logo.png".into(),
+        texture: asset_server.load("bevy_logo.png"),
         size: sprite_size,
       },
-      ..default()
-    },
-  ));
+      direction: Direction::default(),
+      fill_mode: FillMode::default(),
+      spatial: SpatialBundle::default(),
+    })
+    .with_children(|parent| {
+      parent.spawn(());
+    });
 }

examples/sprite_sheet.rs

@@ -2,7 +2,7 @@ mod shared;
 use std::collections::VecDeque;
 
 use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_scroller::{Scroller, ScrollerBundle, ScrollerSize, SequenceSpriteSheetGenerator};
+use bevy_scroller::{Direction, Scroller, ScrollerBundle, SequenceSpriteSheetGenerator, Size};
 use shared::get_app;
 fn main() {
   get_app("sprite sheet".into())
@@ -30,10 +30,10 @@ fn startup(
   let sprite_size = Vec2::new(64., 64.);
 
   commands.spawn((
-    ScrollerSize {
-      size: Vec2::new(primary_window.width(), sprite_size.y * 2.),
-    },
+    Size(Vec2::new(primary_window.width(), sprite_size.y * 2.)),
     ScrollerBundle {
+      size: Default::default(),
+
       scroller: Scroller {
         speed: 1.,
         ..default()

src/generators/generator.rs

@@ -1,43 +1,66 @@
-use std::fmt::Debug;
+use std::{any::TypeId, fmt::Debug};
 
-use bevy::prelude::*;
+use bevy::{ecs::world, prelude::*};
 
-use crate::Scroller;
+use crate::{Scroller, ScrollerGenerators, ScrollerItem, Size};
 
 pub trait GeneratedItem: Debug {
   fn size(&self) -> Vec2;
 }
-pub trait ScrollerGenerator: Default {
-  type I: GeneratedItem + Debug;
-  fn gen_item(&mut self) -> Self::I;
+pub trait ScrollerGenerator {
+  type Item: GeneratedItem + Debug;
+  fn gen_item(&mut self) -> Self::Item;
 }
 
-pub type SpawnerInput<T> = Vec<(Entity, Scroller, Box<<T as ScrollerGenerator>::I>)>;
+pub type SpawnerInput<I> = (Entity, Vec<I>);
 
-const GENERATIONS_LIMIT: u32 = 300;
+pub fn spawner() -> Box<Vec<impl Bundle>> {
+  Box::new(vec![{}])
+}
 
-pub fn pre_generator<T>(mut q_scroller: Query<(Entity, &Scroller, &mut T)>) -> SpawnerInput<T>
+pub fn gen<G: 'static>(world: &mut World) {
+  if let Some(generator) = world
+    .get_resource_ref::<ScrollerGenerators>()
+    .unwrap()
+    .generators
+    .get(&TypeId::of::<G>())
+  {
+    let spid = world.register_system(spawner);
+    let asd = world.run_system(spid).unwrap();
+    world.spawn_batch(asd.into_iter());
+  }
+}
+pub fn generator<G>(
+  In(entity): In<Entity>,
+  mut query: Query<(&mut G, &Scroller, &Size)>,
+  q_item: Query<(&Transform, &ScrollerItem)>,
+  generators: Res<ScrollerGenerators>,
+) -> Box<Vec<impl Bundle>>
 where
-  T: ScrollerGenerator + Component + Clone,
+  G: ScrollerGenerator + Component + Clone,
 {
-  q_scroller
-    .iter_mut()
-    .flat_map(|(entity, scroller, mut generator)| {
-      let mut length = scroller.get_free_space();
-      let mut generations = 0;
-      let mut to_generate = vec![];
-      while length > 0. && generations <= GENERATIONS_LIMIT {
-        let item = generator.gen_item();
-        trace!("generated item is: {:?}", item);
-        length -= item.size().x;
-        generations += 1;
-        to_generate.push((entity, scroller.clone(), Box::new(item)));
+  let items = if let Ok((mut generator, scroller, size)) = query.get_mut(entity) {
+    let edge = match scroller.last_item {
+      Some(last_item) => {
+        let (position, item) = q_item.get(last_item).unwrap();
+        position.translation.x + item.size.x / 2.
       }
-      if generations > GENERATIONS_LIMIT {
-        panic!("Reached item generation limit");
+      None => 0.,
+    };
+    let mut free_space = size.x - edge;
+    // let mut width = scroller.items_width;
+    let mut items = vec![];
+    if let Some(generator) = generators.generators.get(&TypeId::of::<G>()) {
+      while free_space > 0. {
+        world.run_system_once(generator).unwrap();
+        // width += item.size().x;
+        free_space -= item.size().x;
+        items.push(item);
       }
-
-      to_generate
-    })
-    .collect()
+    }
+    items
+  } else {
+    vec![]
+  };
+  (entity, items)
 }