Make more progress on editor revival

Author: SpaceManiac

Cargo.lock

@@ -17,8 +17,7 @@ lodepng = "3.10.7"
 ndarray = "0.15.6"
 divrem = "1.0.0"
 sdl3 = "0.14.42"
-serde = "1.0.213"
-serde_derive = "1.0.213"
+serde = { version = "1.0.213", features = ["derive"] }
 toml = "0.5.11"
 petgraph = { version = "0.6.0", default-features = false }
 weak-table = "0.3.2"

crates/spaceman-dmm/Cargo.toml

@@ -4,8 +4,8 @@ extern crate git2;
 use std::env;
 use std::fs::File;
 use std::io::Write;
-use std::process::Command;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 
 fn main() {
     // build info
@@ -21,7 +21,7 @@ fn main() {
     if cfg!(windows) {
         let out_dir = env::var("OUT_DIR").ok().expect("can't find out_dir");
 
-        if cfg!(target_env="msvc") {
+        if cfg!(target_env = "msvc") {
             if let Err(e) = Command::new("windres")
                 .args(&["res/editor.rc", "-o"])
                 .arg(&format!("{}/editor_rc.lib", out_dir))

crates/spaceman-dmm/build.rs

@@ -1,5 +1,7 @@
-use std::{io, env, fs};
 use std::path::{Path, PathBuf};
+use std::{env, fs, io};
+
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Default)]
 pub struct Config {
@@ -20,7 +22,7 @@ impl Config {
     pub fn make_recent(&mut self, recent: &Path) {
         if let Some(first) = self.recent.first() {
             if first == recent {
-                return;  // no work to do
+                return; // no work to do
             }
         }
 
@@ -54,21 +56,22 @@ fn load(path: &Path) -> io::Result<Config> {
         Err(e) => {
             println!("Config read error:\n{}", e);
             Ok(Config::default())
-        }
+        },
     }
 }
 
 fn save(cfg: &Config, path: &Path) -> io::Result<()> {
-    use std::io::Write;
     use serde::Serialize;
+    use std::io::Write;
 
     let mut buffer = String::new();
     cfg.serialize(
         toml::ser::Serializer::new(&mut buffer)
             .pretty_string(true)
             .pretty_string_literal(false)
             .pretty_array(true),
-    ).unwrap();
+    )
+    .unwrap();
 
     if let Some(parent) = path.parent() {
         fs::create_dir_all(parent)?;

crates/spaceman-dmm/src/config.rs

@@ -1,18 +1,20 @@
 //! Editor-environment specific DMI (texture) handling.
 
+use std::collections::hash_map::HashMap;
 use std::io;
 use std::path::{Path, PathBuf};
-use std::collections::hash_map::HashMap;
 use std::sync::{Arc, RwLock};
 
-use lodepng::{self, RGBA, Decoder, ColorType};
+use lodepng::{self, ColorType, Decoder, RGBA};
+use sdl3::pixels::{PixelFormat, PixelFormatEnum};
+use sdl3::render::Texture;
+use sdl3::surface::Surface;
 
-use gfx::{self, Factory as FactoryTrait};
-use crate::{Factory, Texture};
+use crate::support::TextureCreator;
 
 type Rect = (u32, u32, u32, u32);
 
-pub use dm::dmi::*;
+pub use dreammaker::dmi::*;
 
 // ----------------------------------------------------------------------------
 // Icon file and metadata handling
@@ -23,8 +25,8 @@ pub struct IconCache {
 }
 
 #[derive(Default)]
-pub struct TextureCache {
-    textures: Vec<Option<Texture>>,
+pub struct TextureCache<'r> {
+    textures: Vec<Option<Texture<'r>>>,
 }
 
 #[derive(Default)]
@@ -61,12 +63,12 @@ impl IconCache {
                     lock.icons.push(arc);
                     lock.paths.insert(relative_file_path.to_owned(), Some(i));
                     Some(i)
-                }
+                },
                 None => {
                     let mut lock = self.lock.write().expect("IconCache poisoned");
                     lock.paths.insert(relative_file_path.to_owned(), None);
                     None
-                }
+                },
             },
         }
     }
@@ -84,13 +86,17 @@ impl IconCache {
     }*/
 }
 
-impl TextureCache {
-    pub fn retrieve(&mut self, factory: &mut Factory, icons: &IconCache, id: usize) -> &Texture {
-        use crate::Fulfill;
+impl<'r> TextureCache<'r> {
+    pub fn retrieve(
+        &mut self,
+        factory: &'r TextureCreator,
+        icons: &IconCache,
+        id: usize,
+    ) -> &Texture {
         if id >= self.textures.len() {
-            self.textures.resize(id + 1, None);
+            self.textures.resize_with(id + 1, Default::default);
         }
-        self.textures[id].fulfill(|| load_texture(factory, &icons.get_icon(id).bitmap))
+        self.textures[id].get_or_insert_with(|| load_texture(factory, &icons.get_icon(id).bitmap))
     }
 
     pub fn clear(&mut self) {
@@ -104,7 +110,7 @@ fn load(path: &Path) -> Option<IconFile> {
         Err(err) => {
             eprintln!("error loading icon: {}\n  {}", path.display(), err);
             None
-        }
+        },
     }
 }
 
@@ -130,21 +136,27 @@ impl IconFile {
     }
 
     pub fn uv_of(&self, icon_state: &str, dir: Dir) -> Option<[f32; 4]> {
-        self.rect_of(icon_state, dir).map(|(x1, y1, w, h)| [
-            x1 as f32 / self.width as f32,
-            y1 as f32 / self.height as f32,
-            (x1 + w) as f32 / self.width as f32,
-            (y1 + h) as f32 / self.height as f32,
-        ])
+        self.rect_of(icon_state, dir).map(|(x1, y1, w, h)| {
+            [
+                x1 as f32 / self.width as f32,
+                y1 as f32 / self.height as f32,
+                (x1 + w) as f32 / self.width as f32,
+                (y1 + h) as f32 / self.height as f32,
+            ]
+        })
     }
 
     #[inline]
     pub fn rect_of(&self, icon_state: &str, dir: Dir) -> Option<Rect> {
-        self.metadata.rect_of(self.width, icon_state, dir, 0)
+        self.metadata
+            .rect_of(self.width, &StateIndex::from(icon_state), dir, 0)
     }
 }
 
-pub fn texture_from_bytes(factory: &mut Factory, bytes: &[u8]) -> io::Result<Texture> {
+pub fn texture_from_bytes<'r>(
+    factory: &'r TextureCreator,
+    bytes: &[u8],
+) -> io::Result<Texture<'r>> {
     let mut decoder = Decoder::new();
     decoder.info_raw_mut().colortype = ColorType::RGBA;
     decoder.info_raw_mut().set_bitdepth(8);
@@ -157,22 +169,30 @@ pub fn texture_from_bytes(factory: &mut Factory, bytes: &[u8]) -> io::Result<Tex
     Ok(load_texture(factory, &bitmap))
 }
 
-pub fn load_texture(factory: &mut Factory, bitmap: &lodepng::Bitmap<RGBA>) -> Texture {
+pub fn load_texture<'r>(
+    factory: &'r TextureCreator,
+    bitmap: &lodepng::Bitmap<RGBA>,
+) -> Texture<'r> {
     let width = bitmap.width;
     let height = bitmap.height;
-    let mut new_buffer = Vec::with_capacity(4 * width * height);
-    for pixel in &bitmap.buffer {
-        new_buffer.push(pixel.r);
-        new_buffer.push(pixel.g);
-        new_buffer.push(pixel.b);
-        new_buffer.push(pixel.a);
-    }
 
-    let kind = gfx::texture::Kind::D2(width as u16, height as u16, gfx::texture::AaMode::Single);
-    let (_, view) = factory.create_texture_immutable_u8::<crate::ColorFormat>(
-        kind,
-        gfx::texture::Mipmap::Provided,
-        &[&new_buffer[..]]
-    ).expect("create_texture_immutable_u8");
-    view
+    let mut surface = Surface::new(
+        width as u32,
+        height as u32,
+        PixelFormat::from(PixelFormatEnum::RGBA8888),
+    )
+    .expect("Surface::new");
+    surface.with_lock_mut(|dest| {
+        let mut dest = dest.iter_mut();
+        for pixel in &bitmap.buffer {
+            *dest.next().unwrap() = pixel.r;
+            *dest.next().unwrap() = pixel.g;
+            *dest.next().unwrap() = pixel.b;
+            *dest.next().unwrap() = pixel.a;
+        }
+    });
+
+    factory
+        .create_texture_from_surface(surface)
+        .expect("create_texture_from_surface")
 }