Merge pull request #40 from yellowcake-org/feature/core-58-performance-improvements

0xceed · web-flow · commit 8a7ab2946eb4 · 2023-03-15T18:37:13.000+04:00
CORE-58: Performance improvements.
diff --git a/examples/mapview/main.rs b/examples/mapview/main.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::fs::File;
 use std::io::BufWriter;
 
@@ -9,9 +10,13 @@ use cli::export::elevation;
 use cli::export::filter::{Filter, Layers};
 use libycresources::common::types::geometry::Scaled;
 use libycresources::common::types::space;
-use libycresources::formats::map;
+use libycresources::formats::{map, pal};
+use libycresources::formats::map::blueprint::prototype::Instance;
+use libycresources::formats::map::tiles::Group;
 use provider::CommonProvider;
 
+use crate::cli::export::darkness::Darkness;
+
 mod print;
 mod render;
 mod provider;
@@ -69,17 +74,75 @@ fn main() {
             if export.darkness.as_ref().is_some() { println!("Darkness customization has been applied."); }
             if export.elevation.as_ref().is_some() { println!("Provided elevation will be rendered only."); }
 
-            for level in levels {
-                let level_readable = level + 1;
-                let elevation = space::Elevation { level: Scaled { value: level, scale: 0..MAX_ELEVATION + 1 } };
+            let default = match u8::try_from(map.darkness) {
+                Ok(value) => value,
+                Err(error) => {
+                    return eprintln!("Map darkness value is out of range. Error: {:?}", error);
+                }
+            };
+
+            let darkness = export.darkness.map_or(
+                default,
+                |d| {
+                    match d {
+                        Darkness::None => 1,
+                        Darkness::Night => 2,
+                        Darkness::Dusk => 3,
+                        Darkness::Day => 4,
+                    }
+                },
+            );
+
+            println!("Loading common palette...");
+
+            let file = match File::open(&options.resources.join("COLOR.PAL")) {
+                Err(error) => { return eprintln!("Failed to open main palette's file. Error: {:?}.", error); }
+                Ok(value) => value
+            };
+
+            let mut reader = std::io::BufReader::with_capacity(1 * 1024 * 1024, file);
+            let palette = match pal::parse::palette(&mut reader) {
+                Err(error) => { return eprintln!("Failed to parse main palette. Error: {:?}.", error); }
+                Ok(value) => value
+            };
+
+            println!("Success.");
+
+            let mut tiles = HashMap::new();
+            for group in &map.tiles { tiles.insert(&group.elevation, group); }
+
+            let mut protos: HashMap<&space::Elevation, Vec<&Instance>> = HashMap::new();
+            for proto in &map.prototypes {
+                if let Some(grid) = &proto.location.grid {
+                    if let Some(protos) = protos.get_mut(&grid.elevation) {
+                        protos.push(&proto);
+                    } else {
+                        let mut list = Vec::new();
+                        list.push(proto);
+
+                        protos.insert(&grid.elevation, list);
+                    }
+                }
+            }
+
+            let drawables: Vec<(space::Elevation, &&Group, Option<&Vec<&Instance>>)> = levels.map(
+                |l| space::Elevation { level: Scaled { value: l, scale: 0..MAX_ELEVATION + 1 } }
+            ).map(|e| {
+                let protos = protos.get(&e);
+                tiles.get(&e).map(|t| (e, t, protos))
+            }).flatten().collect();
+
+            for (elevation, tiles, protos) in drawables {
+                let level_readable = elevation.level.value + 1;
 
                 println!("Started rendering level {:?}...", level_readable);
                 let result = render::map(
-                    &map, &filter,
-                    export.darkness.as_ref(),
-                    &elevation,
+                    &tiles,
+                    protos,
+                    &filter,
+                    darkness,
                     &provider,
-                    &options.resources,
+                    &palette,
                 );
 
                 let image = match result {
diff --git a/examples/mapview/provider/suffix.rs b/examples/mapview/provider/suffix.rs
@@ -15,7 +15,7 @@ pub(crate) fn detect(weapon: &Option<weapon::Animation>, animation: &critter::An
             Some(weapon::Animation::BigGun) => 8,
             Some(weapon::Animation::Minigun) => 9,
             Some(weapon::Animation::RocketLauncher) => 10,
-        }) as char
+        }) as char;
     }
 
     fn a_char(a: &critter::Animation) -> char {
diff --git a/examples/mapview/render.rs b/examples/mapview/render.rs
@@ -1,13 +1,9 @@
-use std::fs::File;
-use std::path::PathBuf;
-
 use item::Instance;
-use libycresources::common::types::space::Elevation;
-use libycresources::formats::{map, pal};
-use libycresources::formats::map::blueprint;
+use libycresources::formats::map;
+use libycresources::formats::map::tiles::Group;
+use libycresources::formats::pal::Palette;
 use libycresources::formats::pro::meta::info::flags::Root::Flat;
 
-use crate::cli::export::darkness::Darkness;
 use crate::cli::export::filter::Layers;
 use crate::error::Error;
 use crate::traits::render::Provider;
@@ -21,37 +17,13 @@ mod sprite;
 mod grid;
 
 pub(crate) fn map<'a, P: Provider>(
-    map: &'a map::Map,
+    tiles: &'a Group,
+    protos: Option<&Vec<&map::blueprint::prototype::Instance>>,
     layers: &Layers,
-    darkness: Option<&Darkness>,
-    elevation: &Elevation,
+    darkness: u8,
     provider: &P,
-    resources: &PathBuf,
+    palette: &Palette,
 ) -> Result<Option<(Vec<(u8, u8, u8)>, (usize, usize))>, Error<'a>> {
-    let default = u8::try_from(map.darkness)
-        .map_err(|_| Error::Corrupted("Map darkness value is out of range."))?;
-
-    let darkness = darkness.map_or(
-        default,
-        |d| {
-            match d {
-                Darkness::None => 1,
-                Darkness::Night => 2,
-                Darkness::Dusk => 3,
-                Darkness::Day => 4,
-            }
-        },
-    );
-
-    let tiles = map.tiles
-        .iter()
-        .find(|e| { &e.elevation == elevation });
-
-    let tiles = match tiles {
-        None => return Ok(None),
-        Some(value) => value
-    };
-
     let floors: Vec<Instance> = tiles::convert(&tiles.floor, provider)?;
     let ceilings: Vec<Instance> = tiles::convert(&tiles.ceiling, provider)?;
 
@@ -66,51 +38,41 @@ pub(crate) fn map<'a, P: Provider>(
     let mut pixels = vec![(u8::MIN, u8::MIN, u8::MIN); w * h];
     let mut image = (&mut pixels, (w, h));
 
-    let file = File::open(&resources.join("COLOR.PAL"))
-        .map_err(|io| Error::IO(io, "Failed to load main palette."))?;
-
-    let mut reader = std::io::BufReader::with_capacity(1 * 1024 * 1024, file);
-    let palette = pal::parse::palette(&mut reader)
-        .map_err(|i| Error::Internal(i, "Failed to parse main palette."))?;
-
     if layers.floor || layers.all() {
         println!("Rendering floor...");
-        tiles::imprint(&floors, false, &palette, darkness, &mut image)?;
+        tiles::imprint(&floors, false, palette, darkness, &mut image)?;
     }
 
     if layers.overlay || layers.all() {
         println!("Rendering hexagonal tiles' overlay...");
         hexes::overlay(&mut image)?;
     }
 
-    println!("Rendering prototypes...");
-    let flat: Vec<&blueprint::prototype::Instance> = map.prototypes.iter()
-        .filter(|p| p.patch.meta.flags.contains(&Flat)).collect();
-
-    let other: Vec<&blueprint::prototype::Instance> = map.prototypes.iter()
-        .filter(|p| !p.patch.meta.flags.contains(&Flat)).collect();
-
-    protos::imprint(
-        &flat,
-        provider,
-        &elevation,
-        &palette,
-        darkness,
-        &layers,
-        (tw, th),
-        &mut image,
-    )?;
-
-    protos::imprint(
-        &other,
-        provider,
-        &elevation,
-        &palette,
-        darkness,
-        &layers,
-        (tw, th),
-        &mut image,
-    )?;
+    if let Some(protos) = protos {
+        println!("Rendering prototypes...");
+        let (flat, normal) = protos.iter()
+            .partition(|p| p.patch.meta.flags.contains(&Flat));
+
+        protos::imprint(
+            &flat,
+            provider,
+            &palette,
+            darkness,
+            &layers,
+            (tw, th),
+            &mut image,
+        )?;
+
+        protos::imprint(
+            &normal,
+            provider,
+            &palette,
+            darkness,
+            &layers,
+            (tw, th),
+            &mut image,
+        )?;
+    }
 
     if layers.roof || layers.all() {
         println!("Rendering roofs...");
diff --git a/examples/mapview/render/protos.rs b/examples/mapview/render/protos.rs
@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-use libycresources::common::types::space::Elevation;
 use libycresources::formats::{pal, pro};
 use libycresources::formats::map::blueprint;
 use libycresources::formats::pro::Type::{Critter, Item, Misc, Scenery, Tile, Wall};
@@ -13,7 +12,6 @@ use crate::traits::render::Provider;
 pub(crate) fn imprint<'a, P: Provider>(
     protos: &Vec<&blueprint::prototype::Instance>,
     provider: &P,
-    elevation: &Elevation,
     palette: &pal::Palette,
     darkness: u8,
     layers: &Layers,
@@ -69,8 +67,6 @@ pub(crate) fn imprint<'a, P: Provider>(
                         &proto.location.grid,
                         &proto.location.screen.correction
                     ) {
-                        if &location.elevation != elevation { continue; }
-
                         let identifier = &proto.appearance.sprite;
                         let item = provider.provide(&identifier)?;
 

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ pub(crate) fn detect(weapon: &Option<weapon::Animation>, animation: &critter::An`
`15`	`15`	`Some(weapon::Animation::BigGun) => 8,`
`16`	`16`	`Some(weapon::Animation::Minigun) => 9,`
`17`	`17`	`Some(weapon::Animation::RocketLauncher) => 10,`
`18`		`- }) as char`
	`18`	`+ }) as char;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`fn a_char(a: &critter::Animation) -> char {`