feat(core): load template zips from bytes and add GIF dither flag

Session-Id: 79d370e4-6659-40e5-94e4-321776e55484

Author: taskylizard

crates/maple-render-core/README.md

@@ -41,3 +41,33 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 ```
+
+## Load templates from bytes (embedded at build time)
+
+You can bundle your template ZIP into your binary and load it without touching the filesystem at runtime.
+
+`build.rs`:
+
+```rust
+use std::{env, fs, path::PathBuf};
+
+fn main() {
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    fs::copy("templates/toaster.zip", out_dir.join("template.zip")).unwrap();
+    println!("cargo:rerun-if-changed=templates/toaster.zip");
+}
+```
+
+`src/main.rs`:
+
+```rust
+use maple_render_core::Repository;
+
+const TEMPLATE_ZIP: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/template.zip"));
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let repo = Repository::load_from_bytes(TEMPLATE_ZIP.to_vec())?;
+    // ...
+    Ok(())
+}
+```

crates/maple-render-core/src/gif_anim.rs

@@ -21,6 +21,7 @@ pub struct GifAnim {
     first_frame: i32,
     blocks: Vec<GifBlock>,
     palette: Option<Palette>,
+    dither: bool,
 }
 
 struct GifBlock {
@@ -40,9 +41,14 @@ impl GifAnim {
             first_frame: -1,
             blocks: Vec::new(),
             palette: None,
+            dither: false,
         }
     }
 
+    pub fn set_dither(&mut self, dither: bool) {
+        self.dither = dither;
+    }
+
     pub fn set_palette(&mut self, index: i32) {
         self.palette_frames = vec![index];
     }
@@ -73,19 +79,20 @@ impl GifAnim {
         let mut pal_index: i32 = -1;
 
         for (i, &idx) in self.palette_frames.iter().enumerate() {
-            // Get the rendered image first
-            let img = {
-                let render = self.renders.get_render(idx)?;
-                render.get().clone()
-            };
-            self.renders.remove_mapping(idx);
-
             if pals == 1 {
-                pal_image = Some(img);
+                let render = self.renders.get_render(idx)?;
+                pal_image = Some(render.get().clone());
                 pal_index = idx;
-            } else {
+                self.renders.remove_mapping(idx);
+                continue;
+            }
+
+            {
+                let render = self.renders.get_render(idx)?;
+                let img = render.get();
                 let w = img.width() as usize;
                 let h = img.height() as usize;
+
                 if pal_image.is_none() {
                     pal_image = Some(img.clone());
                 } else {
@@ -98,6 +105,8 @@ impl GifAnim {
                     }
                 }
             }
+
+            self.renders.remove_mapping(idx);
         }
 
         let pal_image = pal_image.ok_or(Error::MissingData("No palette image".to_string()))?;
@@ -107,8 +116,7 @@ impl GifAnim {
         let mut quantizer = Quantizer::new(&pal_image);
         self.palette = Some(quantizer.palette().clone());
 
-        let mut prev_indices = quantizer.quantize(&pal_image, true);
-        let _pre_prev_indices = prev_indices.clone();
+        let mut prev_indices = quantizer.quantize(&pal_image, self.dither);
 
         let frames = self.renders.length() as i32;
 
@@ -122,12 +130,12 @@ impl GifAnim {
             step_pending = step_pending.saturating_add(step);
 
             let curr_indices = if i != pal_index {
-                let img = {
+                let quantized = {
                     let render = self.renders.get_render(i)?;
-                    render.get().clone()
+                    quantizer.quantize(render.get(), self.dither)
                 };
                 self.renders.remove_mapping(i);
-                quantizer.quantize(&img, true)
+                quantized
             } else {
                 prev_indices.clone()
             };

crates/maple-render-core/src/repository.rs

@@ -1,14 +1,11 @@
 use std::{
     collections::HashMap,
-    io::{Read, Seek},
+    io::{Cursor, Read, Seek},
 };
 
 #[cfg(not(target_arch = "wasm32"))]
 use std::{fs::File, io::BufReader, path::Path};
 
-#[cfg(target_arch = "wasm32")]
-use std::io::Cursor;
-
 use image::RgbaImage;
 use zip::ZipArchive;
 
@@ -18,17 +15,11 @@ use crate::{
     template::Template,
 };
 
-#[cfg(not(target_arch = "wasm32"))]
-pub struct Repository {
-    zip: ZipArchive<BufReader<File>>,
-    pub template: Template,
-    mappings: HashMap<i32, Mapping>,
-    peak_cache_count: usize,
-}
+trait ReadSeek: Read + Seek {}
+impl<T: Read + Seek> ReadSeek for T {}
 
-#[cfg(target_arch = "wasm32")]
 pub struct Repository {
-    zip: ZipArchive<Cursor<Vec<u8>>>,
+    zip: ZipArchive<Box<dyn ReadSeek>>,
     pub template: Template,
     mappings: HashMap<i32, Mapping>,
     peak_cache_count: usize,
@@ -44,18 +35,16 @@ impl Repository {
         }
 
         let file = File::open(path)?;
-        let reader = BufReader::new(file);
-        let mut zip = ZipArchive::new(reader)?;
-
-        let template_json = Self::load_text_from_zip(&mut zip, "template.json")?;
-        let template: Template = serde_json::from_str(&template_json)?;
-
-        Ok(Repository { zip, template, mappings: HashMap::new(), peak_cache_count: 0 })
+        let reader: Box<dyn ReadSeek> = Box::new(BufReader::new(file));
+        Self::load_from_reader(reader)
     }
 
-    #[cfg(target_arch = "wasm32")]
     pub fn load_from_bytes(bytes: Vec<u8>) -> Result<Self> {
-        let reader = Cursor::new(bytes);
+        let reader: Box<dyn ReadSeek> = Box::new(Cursor::new(bytes));
+        Self::load_from_reader(reader)
+    }
+
+    fn load_from_reader(reader: Box<dyn ReadSeek>) -> Result<Self> {
         let mut zip = ZipArchive::new(reader)?;
 
         let template_json = Self::load_text_from_zip(&mut zip, "template.json")?;

src/main.rs

@@ -117,6 +117,10 @@ struct Cli {
     /// Background color for text inputs as hex (default: "FFFFFF" white)
     #[arg(long)]
     text_bg: Option<String>,
+
+    /// Enable Floyd-Steinberg dithering during GIF quantization (slower, can improve gradients)
+    #[arg(long)]
+    dither: bool,
 }
 
 #[derive(Deserialize)]
@@ -265,6 +269,7 @@ fn main() -> Result<()> {
         let repo_ref = Repository::load(zip_path)?;
         anim.set_palette_frames(repo_ref.get_palette());
         anim.set_timing(repo_ref.get_period(), repo_ref.get_hold());
+        anim.set_dither(cli.dither);
 
         if let Some(start) = cli.start {
             anim.set_first_frame(start);