Add progress bars to import/export

Holyfucktheyaredumb

src/frame_export.rs

@@ -14,13 +14,14 @@ use crate::{SpriteType, Error};
 
 // Won't export layers with None prefix,
 // framedef_file is joined to path, as are the image names
-pub fn export_frames(
+pub fn export_frames<F: Fn(f32)>(
     file: &files::File,
     ty: SpriteType,
     path: &Path,
     framedef_file: &Path,
     layer_prefixes: &[Option<String>],
     single_image: bool,
+    report_progress: F,
 ) -> Result<(), Error> {
     if !path.is_dir() {
         return Err(format_err!("{} is not a directory", path.to_string_lossy()));
@@ -49,6 +50,9 @@ pub fn export_frames(
     let frame_width = (x_max.max(i32::from(values.width) / scale_div as i32) - x_base) as u32;
     let frame_height = (y_max.max(i32::from(values.height) / scale_div as i32) - y_base) as u32;
     let mut multi_frame_images = Vec::new();
+    let mut step = 1.0;
+    let layer_count = layer_prefixes.iter().filter(|x| x.is_some()).count();
+    let step_count = (layer_count * frames.len()) as f32;
     for (i, prefix) in enum_prefixes {
         let texture = file.texture(i)?;
         if single_image {
@@ -74,6 +78,8 @@ pub fn export_frames(
                     x_base,
                     y_base,
                 ).with_context(|_| format!("Writing frame {}", n))?;
+                report_progress(step / step_count);
+                step += 1.0;
             }
 
             let mut encoder = png::Encoder::new(out, image_width, image_height);
@@ -103,6 +109,8 @@ pub fn export_frames(
                     x_base,
                     y_base,
                 ).with_context(|_| format!("Writing frame {}", n))?;
+                report_progress(step / step_count);
+                step += 1.0;
             }
         }
     }
@@ -232,21 +240,25 @@ fn write_frame(
     Ok(())
 }
 
-pub fn export_grp(
+pub fn export_grp<F: Fn(f32)>(
     file: &files::File,
     path: &Path,
     prefix: &str,
     framedef_file: &Path,
     single_image: bool,
+    report_progress: F,
 ) -> Result<(), Error> {
     if !path.is_dir() {
         return Err(format_err!("{} is not a directory", path.to_string_lossy()));
     }
 
     let mut multi_frame_images = Vec::new();
 
+    let layer_count = file.layer_count();
+    let mut step = 1.0;
     if single_image {
-        let layer_count = file.layer_count();
+        // Adding 20% for PNG encoding
+        let step_count = layer_count as f32 * 1.25;
         assert!(layer_count > 0);
         let frame_width = (0..layer_count)
             .flat_map(|i| file.texture(i).ok())
@@ -290,6 +302,8 @@ pub fn export_grp(
             if texture.width != frame_width || texture.height != frame_height {
                 frame_size_overrides.insert(i as u32, (texture.width, texture.height));
             }
+            report_progress(step / step_count);
+            step += 1.0;
         }
 
         let mut encoder = png::Encoder::new(out, image_width, image_height);
@@ -307,6 +321,7 @@ pub fn export_grp(
             frame_size_overrides,
         });
     } else {
+        let step_count = layer_count as f32;
         for i in 0..file.layer_count() {
             let texture = file.texture(i)?;
 
@@ -329,6 +344,8 @@ pub fn export_grp(
                 frame_height: texture.height,
                 frame_size_overrides: HashMap::default(),
             });
+            report_progress(step / step_count);
+            step += 1.0;
         }
     }
 

src/frame_import.rs

@@ -13,14 +13,15 @@ use crate::files;
 use crate::frame_info::{FrameInfo};
 use crate::{SpriteType, Error};
 
-pub fn import_frames_grp(
+pub fn import_frames_grp<F: Fn(f32)>(
     files: &mut files::Files,
     frame_info: &FrameInfo,
     dir: &Path,
     frame_scale: f32,
     format: anim::TextureFormat,
     sprite: usize,
     scale: u8,
+    report_progress: F,
 ) -> Result<(), Error> {
     let mut frames = Vec::new();
     let mut reader = FrameReader::new(dir.into());
@@ -37,6 +38,7 @@ pub fn import_frames_grp(
             size: data.len() as u32,
             offset: !0,
         }, data));
+        report_progress((i + 1) as f32 / frame_info.frame_count as f32);
     }
     files.set_grp_changes(sprite, frames, scale);
     Ok(())
@@ -185,7 +187,7 @@ impl FrameReader {
     }
 }
 
-pub fn import_frames(
+pub fn import_frames<F: Fn(f32)>(
     files: &mut files::Files,
     frame_info: &FrameInfo,
     hd2_frame_info: Option<&FrameInfo>,
@@ -196,16 +198,20 @@ pub fn import_frames(
     formats: &[anim::TextureFormat],
     sprite: usize,
     ty: SpriteType,
+    report_progress: F,
 ) -> Result<(), Error> {
-    fn add_layers(
+    fn add_layers<F: Fn(f32)>(
         layout: &mut anim_encoder::Layout,
         frame_info: &FrameInfo,
         dir: &Path,
         first_layer: usize,
         frame_scale: f32,
         scale: u32,
+        report_progress: F,
     ) -> Result<(), Error> {
         let mut frame_reader = FrameReader::new(dir.into());
+        let mut step = 1.0;
+        let step_count = frame_info.layers.len() as f32 * frame_info.frame_count as f32;
         for &(i, _) in &frame_info.layers {
             let layer = first_layer + i as usize;
             for f in 0..frame_info.frame_count {
@@ -219,6 +225,8 @@ pub fn import_frames(
                 bounded.coords.width *= scale;
                 bounded.coords.height *= scale;
                 layout.add_frame(layer, f as usize, bounded.data, bounded.coords);
+                report_progress(step / step_count);
+                step += 1.0;
             }
         }
         Ok(())
@@ -231,9 +239,29 @@ pub fn import_frames(
 
     let layer_count = formats.len();
     let mut layout = anim_encoder::Layout::new();
-    add_layers(&mut layout, frame_info, dir, 0, frame_scale, 1)?;
+    let progress_mul = match hd2_frame_info.is_some() {
+        true => 0.5,
+        false => 1.0,
+    };
+    add_layers(
+        &mut layout,
+        frame_info,
+        dir,
+        0,
+        frame_scale,
+        1,
+        |step| report_progress(step * progress_mul),
+    )?;
     if let Some((hd2, dir)) = hd2_frame_info {
-        add_layers(&mut layout, hd2, dir, layer_count, hd2_frame_scale.unwrap_or(1.0), 2)?;
+        add_layers(
+            &mut layout,
+            hd2,
+            dir,
+            layer_count,
+            hd2_frame_scale.unwrap_or(1.0),
+            2,
+            |step| report_progress(0.5 + step * 0.5),
+        )?;
     }
     let layout_result = layout.layout();