feat: atlas texture array (#121)

    added Context::set_default_atlas_size
    added AtlasFrame to distinguish between image frames in the atlas and texture addressing
    added Atlas::add_images and Atlas::resize, removed ...
    added UiImage to renderling-ui to hold frames and textures
    added Ui::set_background_color and Ui::with_background_color
    published loading-bytes

Author: schell

Cargo.lock

@@ -1,5 +1,27 @@
 # devlog
 
+## Mon June 3, 2024
+
+### NLNet progress
+
+[My first PR to add atomics to naga's SPIR-V frontend](https://github.com/gfx-rs/wgpu/pull/5702) was 
+merged last week! I'm super stoked because I was worried it might be a bit beyond my pay grade, but 
+I figured it out with the help of @jimblandy.
+
+### Atlas improvements
+
+Finally, the atlas in renderling is a true texture array, greatly increasing `renderling`'s texture
+capacity.
+
+By default the atlas holds an array of 2048x2048x8 textures, but it's configurable so if you need 
+more you can bump up the default size in `Context`, before you create the stage.
+
+### renderling-ui
+
+I've rebuilt and released a good portion of [`renderling-ui`](https://crates.io/renderling-ui). 
+Partially because @jimsynz wanted to use `renderling` as a [`scenic`](hexdocs.pm/scenic/) driver,
+and partially because I still want to be able to write game and tools UI with `renderling`.
+
 ## Sat May 25, 2024
 
 ### SPIR-V atomics update

DEVLOG.md

@@ -64,6 +64,7 @@ Renderling takes a [forward+](https://takahiroharada.files.wordpress.com/2015/04
 
 By default it uses a single uber-shader for rendering.
 
+- [x] texture atlas
 - [ ] frustum culling
 - [ ] occlusion culling
 - [ ] light tiling
@@ -95,8 +96,15 @@ By default it uses a single uber-shader for rendering.
     - [x] textures, images, samplers
     - animation
       - [x] interpolation
-      - [x] morph targets
-      - [x] skinning
+      - [x] skinning (still working on one [issue](https://github.com/schell/renderling/issues/120))
+      - [ ] morph targets (requires rebuild)
+- 2d 
+  - [x] text
+  - [x] stroked and filled paths
+    - [x] cubic beziers
+    - [x] quadratic beziers
+    - [x] arbitrary polygons
+    - [x] fill w/ image
 
 ## Definition
 **renderling** noun
@@ -188,7 +196,7 @@ Some of these solutions were then spun off into their own projects.
 - [`crabslab`](https://github.com/schell/crabslab)
   A slab allocator for working across CPU/GPU boundaries.
 - [`loading-bytes`](crates/loading-bytes)
-  A cross-platform (including the web) way of loading files to bytes.
+  A cross-platform (including the web) and comedically tiny way of loading files to bytes.
 - [`moongraph`](https://github.com/schell/moongraph)
   A DAG and resource graph runner.
 - Contributions to [`naga`](https://github.com/gfx-rs/wgpu/issues/4489)

README.md

@@ -164,7 +164,7 @@ impl App {
         self.theta = std::f32::consts::FRAC_PI_4;
         self.left_mb_down = false;
         self.last_cursor_position = None;
-        self.stage.set_images(std::iter::empty()).unwrap();
+        self.stage.clear_images().unwrap();
         self.document = None;
         log::debug!("ticking stage to reclaim buffers");
         self.stage.tick();

crates/example/src/lib.rs

@@ -1,7 +1,13 @@
 [package]
 name = "loading-bytes"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
+description = "Load bytes from paths on native and WASM"
+repository = "https://github.com/schell/renderling"
+license = "MIT OR Apache-2.0"
+keywords = ["image", "font", "binary", "loading", "bytes"]
+categories = ["webassembly", "filesystem", "asynchronous"]
+readme = "README.md"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

crates/loading-bytes/Cargo.toml

@@ -0,0 +1,35 @@
+# loading-bytes
+
+Sometimes loading things really bites. 
+
+Let's say you just want to compile your program on native and web, but you've 
+done a bit of loading in your call tree... 
+
+You know what I'm talking about, I mean reading from the filesystem. Easy stuff - right? 
+
+## WRONG!
+
+Well, not really - it's still pretty easy - but it's a hassle, hoff!
+
+## NOT ANYMORE.
+
+That's right folks! Step right up and use this here little library to load things from 
+the filesystem on native and through a web request on WASM! 
+
+What you get back totally bytes!
+
+## BUT WAIT, THERE'S MORE!
+
+Act now and I'll throw in some "nice" enumerated error handling.
+
+OK. You got me. That's free!
+
+In fact, the whole thing is free! Take it or leave it, folks, the choice is yours.
+
+...
+
+`loading-bytes` - from the same company that brought you `streaming-nibbles`🐟... 
+
+...Just kidding! 
+
+Happy hacking :) ☕☕☕

crates/loading-bytes/README.md

@@ -1,71 +1,74 @@
 //! Abstraction over loading bytes on WASM or other.
 use snafu::prelude::*;
 
+/// Enumeration of all errors this library may result in.
 #[derive(Debug, Snafu)]
 pub enum LoadingBytesError {
-    #[snafu(display("loading by WASM error: {msg:#?}"))]
+    #[snafu(display("loading '{path}' by WASM error: {msg:#?}"))]
     Wasm {
         path: String,
         msg: wasm_bindgen::JsValue,
     },
-    #[snafu(display("loading '{path}' from '{}' by filesystem error: {source}", cwd.display()))]
+    #[snafu(display("loading '{path}' by filesystem from CWD '{}' error: {source}", cwd.display()))]
     Fs {
         path: String,
         cwd: std::path::PathBuf,
         source: std::io::Error,
     },
 }
 
-/// Load the file at the given url and return it as a vector of bytes, if
-// possible.
-#[cfg(target_arch = "wasm32")]
+/// Load the file at the given url fragment or path and return it as a vector of bytes, if
+/// possible.
 pub async fn load(path: &str) -> Result<Vec<u8>, LoadingBytesError> {
-    use wasm_bindgen::JsCast;
+    #[cfg(target_arch = "wasm32")]
+    {
+        use wasm_bindgen::JsCast;
 
-    let path = path.to_string();
-    let mut opts = web_sys::RequestInit::new();
-    opts.method("GET");
-    let request = web_sys::Request::new_with_str_and_init(&path, &opts).map_err(|msg| {
-        LoadingBytesError::Wasm {
-            path: path.clone(),
-            msg,
-        }
-    })?;
-    let window = web_sys::window().unwrap();
-    let resp_value = wasm_bindgen_futures::JsFuture::from(window.fetch_with_request(&request))
-        .await
-        .map_err(|msg| LoadingBytesError::Wasm {
-            path: path.clone(),
-            msg,
+        let path = path.to_string();
+        let mut opts = web_sys::RequestInit::new();
+        opts.method("GET");
+        let request = web_sys::Request::new_with_str_and_init(&path, &opts).map_err(|msg| {
+            LoadingBytesError::Wasm {
+                path: path.clone(),
+                msg,
+            }
         })?;
-    let resp: web_sys::Response = resp_value
-        .dyn_into()
-        .map_err(|msg| LoadingBytesError::Wasm {
+        let window = web_sys::window().unwrap();
+        let resp_value = wasm_bindgen_futures::JsFuture::from(window.fetch_with_request(&request))
+            .await
+            .map_err(|msg| LoadingBytesError::Wasm {
+                path: path.clone(),
+                msg,
+            })?;
+        let resp: web_sys::Response =
+            resp_value
+                .dyn_into()
+                .map_err(|msg| LoadingBytesError::Wasm {
+                    path: path.clone(),
+                    msg,
+                })?;
+        let array_promise = resp.array_buffer().map_err(|msg| LoadingBytesError::Wasm {
             path: path.clone(),
             msg,
         })?;
-    let array_promise = resp.array_buffer().map_err(|msg| LoadingBytesError::Wasm {
-        path: path.clone(),
-        msg,
-    })?;
-    let buffer = wasm_bindgen_futures::JsFuture::from(array_promise)
-        .await
-        .map_err(|msg| LoadingBytesError::Wasm {
-            path: path.clone(),
-            msg,
+        let buffer = wasm_bindgen_futures::JsFuture::from(array_promise)
+            .await
+            .map_err(|msg| LoadingBytesError::Wasm {
+                path: path.clone(),
+                msg,
+            })?;
+        assert!(buffer.is_instance_of::<js_sys::ArrayBuffer>());
+        let array: js_sys::Uint8Array = js_sys::Uint8Array::new(&buffer);
+        let mut bytes: Vec<u8> = vec![0; array.length() as usize];
+        array.copy_to(&mut bytes);
+        Ok(bytes)
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let bytes: Vec<u8> = async_fs::read(path).await.with_context(|_| FsSnafu {
+            path: path.to_string(),
+            cwd: std::env::current_dir().unwrap(),
         })?;
-    assert!(buffer.is_instance_of::<js_sys::ArrayBuffer>());
-    let array: js_sys::Uint8Array = js_sys::Uint8Array::new(&buffer);
-    let mut bytes: Vec<u8> = vec![0; array.length() as usize];
-    array.copy_to(&mut bytes);
-    Ok(bytes)
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub async fn load(path: &str) -> Result<Vec<u8>, LoadingBytesError> {
-    let bytes: Vec<u8> = async_fs::read(path).await.with_context(|_| FsSnafu {
-        path: path.to_string(),
-        cwd: std::env::current_dir().unwrap(),
-    })?;
-    Ok(bytes)
+        Ok(bytes)
+    }
 }

crates/loading-bytes/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "renderling_ui"
-version = "0.3.1"
+version = "0.3.4"
 edition = "2021"
 description = "User-friendly real-time 2d rendering. 🍖"
 repository = "https://github.com/schell/renderling"
@@ -13,10 +13,10 @@ readme = "README.md"
 crabslab = {workspace = true}
 glyph_brush = "0.7.8"
 image = {workspace=true}
-loading-bytes = {version = "0.1.0", path = "../loading-bytes"}
+loading-bytes = {version = "0.1.1", path = "../loading-bytes"}
 log = {workspace=true}
 lyon = "1.0.1"
-renderling = {version = "0.4.6", path = "../renderling"}
+renderling = {version = "0.4.7", path = "../renderling"}
 rustc-hash = {workspace = true}
 snafu = {workspace = true}
 wgpu = {workspace = true}

crates/renderling-ui/Cargo.toml

@@ -31,7 +31,7 @@ use std::sync::{Arc, RwLock};
 use crabslab::Id;
 use glyph_brush::ab_glyph;
 use renderling::{
-    atlas::AtlasTexture,
+    atlas::{AtlasFrame, AtlasTexture, TextureModes},
     camera::Camera,
     math::{Quat, UVec2, Vec2, Vec3Swizzles, Vec4},
     slab::{Hybrid, UpdatesSlab},
@@ -130,14 +130,20 @@ impl UiTransform {
     }
 }
 
+#[derive(Clone)]
+struct UiImage {
+    frame: Hybrid<AtlasFrame>,
+    texture: Hybrid<AtlasTexture>,
+}
+
 /// A 2d user interface renderer.
 ///
 /// Clones of `Ui` all point to the same data.
 #[derive(Clone)]
 pub struct Ui {
     camera: Hybrid<Camera>,
     stage: Stage,
-    images: Arc<RwLock<Vec<Hybrid<AtlasTexture>>>>,
+    images: Arc<RwLock<Vec<UiImage>>>,
     fonts: Arc<RwLock<Vec<FontArc>>>,
     // We keep a list of transforms that we use to "manually" order renderlets.
     //
@@ -168,6 +174,16 @@ impl Ui {
         }
     }
 
+    pub fn set_background_color(&self, color: impl Into<Vec4>) -> &Self {
+        self.stage.set_background_color(color);
+        self
+    }
+
+    pub fn with_background_color(self, color: impl Into<Vec4>) -> Self {
+        self.set_background_color(color);
+        self
+    }
+
     pub fn set_antialiasing(&self, antialiasing_is_on: bool) -> &Self {
         let sample_count = if antialiasing_is_on { 4 } else { 1 };
         self.stage.set_msaa_sample_count(sample_count);
@@ -248,17 +264,26 @@ impl Ui {
             image::ImageFormat::from_path(path_s).context(ImageSnafu)?,
         )
         .context(ImageSnafu)?;
-        let mut texture = self.stage.add_image(img).context(StageSnafu)?;
-        texture.modes.s = renderling::atlas::TextureAddressMode::Repeat;
-        texture.modes.t = renderling::atlas::TextureAddressMode::Repeat;
-        let hybrid = self.stage.new_value(texture);
+        let frame = self
+            .stage
+            .add_images(Some(img))
+            .context(StageSnafu)?
+            .pop()
+            .unwrap();
+        let texture = self.stage.new_value(AtlasTexture {
+            frame_id: frame.id(),
+            modes: TextureModes {
+                s: renderling::atlas::TextureAddressMode::Repeat,
+                t: renderling::atlas::TextureAddressMode::Repeat,
+            },
+        });
         let mut guard = self.images.write().unwrap();
         let id = guard.len();
-        guard.push(hybrid);
+        guard.push(UiImage { frame, texture });
         Ok(ImageId(id))
     }
 
-    pub(crate) fn get_texture(&self, index: usize) -> Option<Hybrid<AtlasTexture>> {
+    pub(crate) fn get_image(&self, index: usize) -> Option<UiImage> {
         self.images.read().unwrap().get(index).cloned()
     }