New backend foundation

Cargo.toml

@@ -17,7 +17,9 @@ description = "A simple portable multimedia layer to create apps or games easily
 members = [
     "crates/notan_core",
     "crates/notan_macro2",
-    "xtask"
+    "crates/notan_app2",
+    "crates/notan_gfx",
+    "xtask",
 ]
 
 [workspace.package]
@@ -31,15 +33,17 @@ edition = "2021"
 [workspace.dependencies]
 notan_core = { path = "crates/notan_core" }
 notan_macro2 = { path = "crates/notan_macro2" }
+notan_math = { path = "crates/notan_math" }
+notan_app2 = { path = "crates/notan_app2" }
+notan_gfx = { path = "crates/notan_gfx" }
+notan_draw = { path = "crates/notan_draw" }
 #notan_input = { path = "crates/notan_input" }
 #notan_app = { path = "crates/notan_app" }
 #notan_macro = { path = "crates/notan_macro" }
-#notan_math = { path = "crates/notan_math" }
 #notan_graphics = { path = "crates/notan_graphics" }
 #notan_utils = { path = "crates/notan_utils" }
 #notan_log = { path = "crates/notan_log" }
 #notan_glyph = { path = "crates/notan_glyph" }
-#notan_draw = { path = "crates/notan_draw" }
 #notan_backend = { path = "crates/notan_backend" }
 #notan_egui = { path = "crates/notan_egui" }
 #notan_text = { path = "crates/notan_text" }
@@ -58,28 +62,32 @@ bytemuck = "1.14.0"
 anymap = "0.12.1"
 arrayvec = "0.7.4"
 raw-window-handle = "0.6.0"
+bitflags = "2.4.2"
 serde = { version = "1.0", features = ["serde_derive"] }
-image = { version = "0.24.7", default-features = false, features = ["jpeg", "png", "ico"] }
+image = { version = "0.24.8", default-features = false, features = ["jpeg", "png", "ico"] }
 
 # wasm deps
-wasm-bindgen = "0.2.89"
-wasm-bindgen-futures = "0.4.39"
-futures-util = "0.3.29"
-web-sys = "0.3.66"
-js-sys = "0.3.65"
+wasm-bindgen = "0.2.90"
+wasm-bindgen-futures = "0.4.40"
+futures-util = "0.3.30"
+web-sys = "0.3.67"
+js-sys = "0.3.67"
+cfg_aliases = "0.2.0"
 
 [dependencies]
 notan_core.workspace = true
 notan_macro2.workspace = true
+notan_app2.workspace = true
+notan_math.workspace = true
+notan_gfx = { workspace = true, optional = true }
+notan_draw = { workspace = true, optional = true }
 #notan_input.workspace = true
 #notan_app.workspace = true
 #notan_macro.workspace = true
-#notan_math.workspace = true
 #notan_graphics.workspace = true
 #notan_utils.workspace = true
 #notan_log = { workspace = true, optional = true }
 #notan_glyph = { workspace = true, optional = true }
-#notan_draw = { workspace = true, optional = true }
 #notan_backend = { workspace = true, optional = true }
 #notan_egui = { workspace = true, optional = true }
 #notan_text = { workspace = true, optional = true }
@@ -88,6 +96,20 @@ notan_macro2.workspace = true
 #notan_random = { workspace = true, optional = true }
 
 [features]
+default = ["limited_core_events", "winit", "gfx", "wgpu"]
+# uses winit as backend
+winit = ["notan_app2/winit"]
+# enabled gfx module
+gfx = ["notan_gfx"]
+# uses wgpu as renderer
+wgpu = ["notan_gfx?/wgpu"]
+# allow to serialize and deserialize internal types with serde
+serde = ["notan_core/serde", "notan_app2/serde"]
+# use arrayvec instead of vec when possible
+limited_core_events = ["notan_core/limited_events"]
+#enabled draw2d features
+draw2d = ["notan_draw", "gfx"]
+
 #default = ["backend", "log", "draw", "random", "glsl-to-spirv"]
 #backend = ["notan_backend"]
 #log = ["notan_log"]
@@ -115,5 +137,4 @@ lto = true
 
 [dev-dependencies]
 egui_demo_lib = "0.27.2"
-bytemuck = "1.14.0"
-
+bytemuck.workspace = true

crates/notan_app2/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "notan_app2"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+readme = "README.md"
+description = "Default backend for Notan's app"
+
+[dependencies]
+notan_core.workspace = true
+
+log.workspace = true
+hashbrown.workspace = true
+raw-window-handle.workspace = true
+serde = { workspace = true, optional = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+winit = { version = "0.29.10", optional = true }
+
+[build-dependencies]
+cfg_aliases.workspace = true

crates/notan_app2/build.rs

@@ -0,0 +1,9 @@
+use cfg_aliases::cfg_aliases;
+
+fn main() {
+    cfg_aliases! {
+        is_web: { target_arch = "wasm32" },
+        is_winit: { all(not(is_web), feature = "winit") },
+        is_empty: { all(not(is_web), not(is_winit)) }
+    }
+}

crates/notan_app2/src/app.rs

@@ -0,0 +1,86 @@
+use crate::{AppConfig, Manager, Window};
+use hashbrown::hash_map::{Values, ValuesMut};
+use notan_core::window::{NotanApp, WindowConfig, WindowId};
+use notan_core::Plugin;
+
+pub struct App {
+    pub manager: Manager,
+    main_window: Option<WindowId>,
+    window_ids: Vec<WindowId>,
+}
+
+impl App {
+    pub fn new() -> Result<Self, String> {
+        Ok(Self {
+            manager: Manager::new()?,
+            main_window: None,
+            window_ids: vec![],
+        })
+    }
+
+    pub fn config() -> AppConfig {
+        AppConfig::default()
+    }
+
+    pub fn create_window(&mut self, attrs: WindowConfig) -> Result<WindowId, String> {
+        let id = self.manager.create(attrs)?;
+        self.window_ids.push(id);
+
+        // set this as main windows if there is no one
+        if self.main_window.is_none() {
+            self.main_window = Some(id);
+        }
+
+        Ok(id)
+    }
+
+    pub fn window_by_id(&mut self, id: WindowId) -> Option<&mut Window> {
+        self.manager.window(id)
+    }
+
+    pub fn window(&mut self) -> Option<&mut Window> {
+        self.main_window.and_then(|id| self.window_by_id(id))
+    }
+
+    pub fn set_main_window(&mut self, win_id: WindowId) {
+        self.main_window = Some(win_id);
+    }
+
+    pub fn window_ids(&self) -> &[WindowId] {
+        &self.window_ids
+    }
+
+    pub fn windows(&self) -> Values<'_, WindowId, Window> {
+        self.manager.windows.values()
+    }
+
+    pub fn windows_mut(&mut self) -> ValuesMut<'_, WindowId, Window> {
+        self.manager.windows.values_mut()
+    }
+
+    pub fn close(&mut self, id: WindowId) {
+        let closed = self.manager.close(id);
+        if closed {
+            // remove from the window_id list
+            let pos = self
+                .window_ids
+                .iter()
+                .position(|stored_id| *stored_id == id);
+
+            if let Some(pos) = pos {
+                self.window_ids.remove(pos);
+            }
+
+            // set main window as none if this was the main window
+            if self.main_window == Some(id) {
+                self.main_window = None;
+            }
+        }
+    }
+
+    pub fn exit(&mut self) {
+        self.manager.exit();
+    }
+}
+
+impl Plugin for App {}

crates/notan_app2/src/config.rs

@@ -0,0 +1,64 @@
+use crate::{runner, App};
+use notan_core::events;
+use notan_core::window::{NotanWindow, WindowAction, WindowConfig, WindowEvent};
+use notan_core::{AppBuilder, AppState, BuildConfig};
+
+pub struct AppConfig {
+    main_window: Option<WindowConfig>,
+    auto_redraw: bool,
+}
+
+impl Default for AppConfig {
+    fn default() -> Self {
+        Self {
+            main_window: Some(Default::default()),
+            auto_redraw: true,
+        }
+    }
+}
+
+impl AppConfig {
+    pub fn with_windowless(mut self) -> Self {
+        self.main_window = None;
+        self
+    }
+
+    pub fn with_window(mut self, attrs: WindowConfig) -> Self {
+        self.main_window = Some(attrs);
+        self
+    }
+}
+
+impl<S: AppState> BuildConfig<S> for AppConfig {
+    fn apply(&mut self, builder: AppBuilder<S>) -> Result<AppBuilder<S>, String> {
+        let mut app = App::new()?;
+
+        // Initialize main windows if is not windowless mode
+        if let Some(attrs) = self.main_window.take() {
+            let id = app.create_window(attrs)?;
+            log::info!("Window '{:?}' created.", id);
+        }
+
+        // Call request_draw on each frame
+        let builder = if self.auto_redraw {
+            builder.on(|_: &events::UpdateEvent, app: &mut App| {
+                app.windows_mut().for_each(|win| win.request_redraw())
+            })
+        } else {
+            builder
+        };
+
+        // Read windows event to set main window and close app when all windows are closed
+        let builder = builder.on(|evt: &WindowEvent, app: &mut App| match evt.action {
+            WindowAction::Close => {
+                if app.window_ids().is_empty() {
+                    app.exit();
+                }
+            }
+            _ => {}
+        });
+
+        // let's add the windows plugin
+        Ok(builder.add_plugin(app).with_runner(runner))
+    }
+}

crates/notan_app2/src/empty/manager.rs

@@ -0,0 +1,44 @@
+use super::window::Window;
+use hashbrown::HashMap;
+use notan_core::window::{CursorIcon, NotanApp, WindowConfig, WindowId};
+
+#[derive(Default)]
+pub struct Manager {
+    pub(crate) windows: HashMap<WindowId, Window>,
+    pub(crate) request_exit: bool,
+}
+
+impl NotanApp<Window> for Manager {
+    fn new() -> Result<Self, String> {
+        Ok(Default::default())
+    }
+
+    fn create(&mut self, attrs: WindowConfig) -> Result<WindowId, String> {
+        let count = self.windows.len();
+        let id: WindowId = (count as u64).into();
+        let win = Window {
+            id,
+            size: attrs.size.unwrap_or((800, 600)),
+            position: attrs.position.unwrap_or((0, 0)),
+            title: attrs.title.clone(),
+            cursor: CursorIcon::Default,
+            resizable: attrs.resizable,
+            min_size: None,
+            max_size: None,
+        };
+        self.windows.insert(id, win);
+        Ok(id)
+    }
+
+    fn window(&mut self, id: WindowId) -> Option<&mut Window> {
+        self.windows.get_mut(&id)
+    }
+
+    fn close(&mut self, id: WindowId) -> bool {
+        self.windows.remove(&id).is_some()
+    }
+
+    fn exit(&mut self) {
+        self.request_exit = true;
+    }
+}

crates/notan_app2/src/empty/mod.rs

@@ -0,0 +1,9 @@
+#![cfg(is_empty)]
+
+mod manager;
+mod runner;
+mod window;
+
+pub use manager::*;
+pub use runner::*;
+pub use window::*;

crates/notan_app2/src/empty/runner.rs

@@ -0,0 +1,27 @@
+use crate::app::App;
+use notan_core::{AppState, System};
+
+pub fn runner<S: AppState>(mut app: System<S>) -> Result<(), String> {
+    app.init();
+
+    loop {
+        app.frame_start();
+        app.update();
+
+        let request_exit = app
+            .get_mut_plugin::<App>()
+            .ok_or_else(|| "Cannot find Platform plugin.")?
+            .manager
+            .request_exit;
+
+        app.frame_end();
+
+        if request_exit {
+            break;
+        }
+    }
+
+    app.close();
+
+    Ok(())
+}