[render] add transform, assets, window and render

.cargo/config.toml

@@ -0,0 +1,9 @@
+
+[target.'cfg(any(target_arch = "x86", target_arch = "x86_64"))']
+rustflags = ["-C", "target-feature=+avx"]
+
+[target.wasm32-unknown-unknown]
+rustflags = ["--cfg=web_sys_unstable_apis"]
+
+[alias]
+run-wasm = "run --release --package run-wasm --"

.github/workflows/rust.yml

@@ -38,7 +38,7 @@ jobs:
         cargo build --workspace --all-targets
     - name: Run tests
       run: |
-        cargo test --workspace --all-targets
+        cargo test --workspace --all-targets --exclude benches
 
   check:
     name: Rustfmt & Clippy

Cargo.toml

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
   "crates/*",
   "crates/*/macros",
+  "run-wasm",
   "benches"
 ]
 default-members = [
@@ -18,14 +19,42 @@ edition = "2024"
 rust-version = "1.86"
 
 [workspace.dependencies]
+glam = "0.30"
+serde = "1.0"
+raw-window-handle = "0.6"
 slotmap = "1.0"
+thiserror = "2.0"
+tracing = "0.1"
+bitflags = "2.9"
 fnv = "1.0"
+radsort = "0.1"
+bytemuck = "1.22"
+blink-alloc = "0.3"
+dynsequence = { version = "0.1.0-alpha.4" }
+blocking = "1.6"
 threadpool = "1.8"
 backtrace = "0.3"
+gametime = "0.5"
 atomic_refcell = "0.1"
+palette = { version = "0.7", default-features = false }
+image = { version = "0.25", default-features = false }
+encase = { version = "0.11", features = ["glam"], default-features = false }
+encase_derive_impl = { version = "0.11" }
 crossbeam-utils = "0.8"
+crossbeam-queue = "0.3"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-wasm = "0.2"
+tracing-log = "0.2"
+console_error_panic_hook = "0.1"
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+js-sys = "0.3"
+web-sys = "0.3"
+ndk = "0.9"
+ndk-glue = "0.7"
 darling = "0.20"
 proc-macro2 = "1.0"
 syn = "2.0"
 quote = "1.0"
 proc-macro-crate = "3.3"
+

crates/assets-loader/CHANGELOG.md

@@ -0,0 +1,6 @@
+# `pulz-assets-loader` Changelog
+All notable changes to this crate will be documented in this file.
+
+## Unreleased (DATE)
+
+ * Initial version

crates/assets-loader/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "pulz-assets-loader"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+readme = "README.md"
+
+[dependencies]
+pulz-ecs = { path = "../ecs" }
+pulz-assets = { path = "../assets" }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+blocking  = { workspace = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = { workspace = true }
+wasm-bindgen-futures = { workspace = true }
+js-sys = { workspace = true }
+web-sys = { workspace = true, features = [ 'Request', 'Response', "Window", ]}
+
+[target.'cfg(target_os = "android")'.dependencies]
+ndk = { workspace = true }

crates/assets-loader/README.md

@@ -0,0 +1,34 @@
+# `pulz-assets-loader` 
+
+<img align="right" src="https://raw.githubusercontent.com/HellButcher/pulz/master/docs/logo-full.png"/>
+
+[![Crates.io](https://img.shields.io/crates/v/pulz-assets-loader.svg?label=pulz-assets-loader)](https://crates.io/crates/pulz-assets-loader)
+[![docs.rs](https://docs.rs/pulz-assets-loader/badge.svg)](https://docs.rs/pulz-assets-loader/)
+[![license: MIT/Apache-2.0](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](#license)
+[![Rust CI](https://github.com/HellButcher/pulz/actions/workflows/rust.yml/badge.svg)](https://github.com/HellButcher/pulz/actions/workflows/rust.yml)
+
+<!-- TODO: Short Introduction -->
+**TODO**
+
+## Example
+
+<!-- TODO: basic Usage Example -->
+**TODO**
+
+## License
+
+[license]: #license
+
+This project is licensed under either of
+
+* MIT license ([LICENSE-MIT] or <http://opensource.org/licenses/MIT>)
+* Apache License, Version 2.0, ([LICENSE-APACHE] or <http://www.apache.org/licenses/LICENSE-2.0>)
+
+at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
+
+[LICENSE-MIT]: ../../LICENSE-MIT
+[LICENSE-APACHE]: ../../LICENSE-APACHE

crates/assets-loader/src/lib.rs

@@ -0,0 +1,165 @@
+#![warn(
+    // missing_docs,
+    // rustdoc::missing_doc_code_examples,
+    future_incompatible,
+    rust_2018_idioms,
+    unused,
+    trivial_casts,
+    trivial_numeric_casts,
+    unused_lifetimes,
+    unused_qualifications,
+    unused_crate_dependencies,
+    clippy::cargo,
+    clippy::multiple_crate_versions,
+    clippy::empty_line_after_outer_attr,
+    clippy::fallible_impl_from,
+    clippy::redundant_pub_crate,
+    clippy::use_self,
+    clippy::suspicious_operation_groupings,
+    clippy::useless_let_if_seq,
+    // clippy::missing_errors_doc,
+    // clippy::missing_panics_doc,
+    clippy::wildcard_imports
+)]
+#![doc(html_logo_url = "https://raw.githubusercontent.com/HellButcher/pulz/master/docs/logo.png")]
+#![doc(html_no_source)]
+#![doc = include_str!("../README.md")]
+
+use std::{future::Future, io::Cursor};
+
+use path::{AssetPath, AssetPathBuf};
+use platform::AssetOpen;
+
+pub mod path;
+pub mod platform;
+
+pub trait LoadAsset<A> {
+    type Future: Future<Output = Result<A, Self::Error>>;
+    type Error: From<std::io::Error>;
+    fn load(&self, load: Load<'_>) -> Self::Future;
+}
+
+impl<A, E, F, T> LoadAsset<A> for T
+where
+    T: Fn(Load<'_>) -> F,
+    F: Future<Output = Result<A, E>>,
+    E: From<std::io::Error>,
+{
+    type Future = F;
+    type Error = E;
+    fn load(&self, load: Load<'_>) -> Self::Future {
+        self(load)
+    }
+}
+
+pub struct Load<'a> {
+    buffer: Cursor<Vec<u8>>,
+    path: AssetPathBuf,
+    server: &'a AssetServer,
+}
+
+impl Load<'_> {
+    #[inline]
+    pub fn path(&self) -> &AssetPath {
+        &self.path
+    }
+
+    #[inline]
+    pub fn into_vec(self) -> Vec<u8> {
+        self.buffer.into_inner()
+    }
+
+    #[inline]
+    pub fn cursor_mut(&mut self) -> &'_ mut Cursor<impl AsRef<[u8]>> {
+        &mut self.buffer
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &'_ [u8] {
+        self.buffer.get_ref()
+    }
+
+    #[inline]
+    pub async fn load(&self, path: impl AsRef<AssetPath>) -> std::io::Result<Load<'_>> {
+        self._load(path.as_ref()).await
+    }
+    async fn _load(&self, path: &AssetPath) -> std::io::Result<Load<'_>> {
+        let full_path = if self.path.is_directory() {
+            self.path.join(path)
+        } else if let Some(parent) = self.path.parent() {
+            parent.join(path)
+        } else {
+            let mut p = AssetPathBuf::from("/");
+            p.push(path);
+            p
+        };
+        self.server._load(full_path).await
+    }
+}
+
+impl AsRef<[u8]> for Load<'_> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
+pub struct AssetServer {
+    io: Box<dyn AssetOpen>,
+}
+
+impl Default for AssetServer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AssetServer {
+    #[cfg(not(target_os = "android"))]
+    pub fn new() -> Self {
+        #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
+        let io = platform::fs::FileSystemAssetLoaderIo::new();
+
+        #[cfg(target_arch = "wasm32")]
+        let io = platform::wasm::WasmFetchAssetLoaderIo::new();
+
+        Self::with(io)
+    }
+
+    #[cfg(target_os = "android")]
+    pub fn with_asset_manager(manager: ::ndk::asset::AssetManager) -> Self {
+        let io = platform::android::AndroidAssetLoaderIo::with_asset_manager(manager);
+        Self::with(io)
+    }
+
+    #[inline]
+    pub fn with(io: impl AssetOpen + 'static) -> Self {
+        Self { io: Box::new(io) }
+    }
+}
+
+impl AssetServer {
+    pub async fn load_with<A, L: LoadAsset<A>>(
+        &self,
+        path: impl AsRef<AssetPath>,
+        loader: L,
+    ) -> Result<A, L::Error> {
+        let load = self.load(path).await?;
+        loader.load(load).await
+    }
+
+    pub async fn load(&self, path: impl AsRef<AssetPath>) -> std::io::Result<Load<'_>> {
+        let mut abs_base = AssetPathBuf::from("/");
+        abs_base.push(path);
+        self._load(abs_base).await
+    }
+
+    async fn _load(&self, path: AssetPathBuf) -> std::io::Result<Load<'_>> {
+        let buffer = self.io.load(&path).await?;
+        Ok(Load {
+            buffer: Cursor::new(buffer),
+            path,
+            server: self,
+        })
+    }
+}