Split SliceOperation to a new module

TODO.md

@@ -42,5 +42,5 @@
 - [x] Add documentation to slicer
 - [x] Make the slice preview layer slider full height
 - [ ] Combine slice result and slice preview windows and add a close button
-- [ ] Split slice operation to a new module
+- [x] Split slice operation to a new module
 - [ ] Re-enable multi-sampling

mslicer/src/app.rs

@@ -3,20 +3,18 @@ use std::{sync::Arc, thread, time::Instant};
 use clone_macro::clone;
 use egui::{CentralPanel, Frame, Sense};
 use egui_wgpu::Callback;
-use image::{imageops::FilterType, RgbaImage};
+use image::imageops::FilterType;
 use nalgebra::{Vector2, Vector3};
-use parking_lot::{lock_api::MutexGuard, Condvar, MappedMutexGuard, Mutex, RawMutex, RwLock};
-use slicer::{
-    slicer::{Progress as SliceProgress, Slicer},
-    Pos,
-};
+use parking_lot::RwLock;
+use slicer::{slicer::Slicer, Pos};
 use tracing::info;
 
 use crate::{
     render::{
         camera::Camera, pipelines::model::RenderStyle, rendered_mesh::RenderedMesh,
         workspace::WorkspaceRenderCallback,
     },
+    slice_operation::{SliceOperation, SliceResult},
     windows::{self, Windows},
 };
 use common::config::{ExposureConfig, SliceConfig};
@@ -40,62 +38,6 @@ pub struct FpsTracker {
     last_frame_time: f32,
 }
 
-pub struct SliceResult {
-    pub goo: GooFile,
-
-    pub slice_preview_layer: usize,
-    pub last_preview_layer: usize,
-    pub preview_offset: Vector2<f32>,
-    pub preview_scale: f32,
-}
-
-// todo: Arc<SliceOperationInner>?
-#[derive(Clone)]
-pub struct SliceOperation {
-    pub progress: SliceProgress,
-    pub result: Arc<Mutex<Option<SliceResult>>>,
-
-    pub preview_image: Arc<Mutex<Option<RgbaImage>>>,
-    preview_condvar: Arc<Condvar>,
-}
-
-impl SliceOperation {
-    pub fn new(progress: SliceProgress) -> Self {
-        Self {
-            progress,
-            result: Arc::new(Mutex::new(None)),
-            preview_image: Arc::new(Mutex::new(None)),
-            preview_condvar: Arc::new(Condvar::new()),
-        }
-    }
-
-    pub fn needs_preview_image(&self) -> bool {
-        self.preview_image.lock().is_none()
-    }
-
-    pub fn add_preview_image(&self, image: RgbaImage) {
-        self.preview_image.lock().replace(image);
-        self.preview_condvar.notify_all();
-    }
-
-    pub fn preview_image(&self) -> MappedMutexGuard<'_, RgbaImage> {
-        let mut preview_image = self.preview_image.lock();
-        while preview_image.is_none() {
-            self.preview_condvar.wait(&mut preview_image);
-        }
-
-        MutexGuard::map(preview_image, |image| image.as_mut().unwrap())
-    }
-
-    pub fn add_result(&self, result: SliceResult) {
-        self.result.lock().replace(result);
-    }
-
-    pub fn result(&self) -> MutexGuard<RawMutex, Option<SliceResult>> {
-        self.result.lock()
-    }
-}
-
 impl App {
     pub fn slice(&mut self) {
         info!("Starting slicing operation");

mslicer/src/main.rs

@@ -13,6 +13,7 @@ const TEXTURE_FORMAT: TextureFormat = TextureFormat::Bgra8Unorm;
 mod app;
 mod components;
 mod render;
+mod slice_operation;
 mod windows;
 use app::App;
 

mslicer/src/render/workspace.rs

@@ -2,12 +2,11 @@ use std::sync::Arc;
 
 use egui::PaintCallbackInfo;
 use egui_wgpu::{CallbackResources, CallbackTrait, ScreenDescriptor};
-use image::RgbaImage;
 use nalgebra::{Matrix4, Vector3};
-use parking_lot::{Mutex, RwLock};
+use parking_lot::RwLock;
 use wgpu::{CommandBuffer, CommandEncoder, Device, Queue, RenderPass};
 
-use crate::app::SliceOperation;
+use crate::slice_operation::SliceOperation;
 
 use super::{
     camera::Camera,

mslicer/src/slice_operation.rs

@@ -0,0 +1,62 @@
+use std::sync::Arc;
+
+use goo_format::File as GooFile;
+use image::RgbaImage;
+use nalgebra::Vector2;
+use parking_lot::{Condvar, MappedMutexGuard, Mutex, MutexGuard};
+use slicer::slicer::Progress as SliceProgress;
+
+#[derive(Clone)]
+pub struct SliceOperation {
+    pub progress: SliceProgress,
+    pub result: Arc<Mutex<Option<SliceResult>>>,
+
+    pub preview_image: Arc<Mutex<Option<RgbaImage>>>,
+    preview_condvar: Arc<Condvar>,
+}
+
+pub struct SliceResult {
+    pub goo: GooFile,
+
+    pub slice_preview_layer: usize,
+    pub last_preview_layer: usize,
+    pub preview_offset: Vector2<f32>,
+    pub preview_scale: f32,
+}
+
+impl SliceOperation {
+    pub fn new(progress: SliceProgress) -> Self {
+        Self {
+            progress,
+            result: Arc::new(Mutex::new(None)),
+            preview_image: Arc::new(Mutex::new(None)),
+            preview_condvar: Arc::new(Condvar::new()),
+        }
+    }
+
+    pub fn needs_preview_image(&self) -> bool {
+        self.preview_image.lock().is_none()
+    }
+
+    pub fn add_preview_image(&self, image: RgbaImage) {
+        self.preview_image.lock().replace(image);
+        self.preview_condvar.notify_all();
+    }
+
+    pub fn preview_image(&self) -> MappedMutexGuard<'_, RgbaImage> {
+        let mut preview_image = self.preview_image.lock();
+        while preview_image.is_none() {
+            self.preview_condvar.wait(&mut preview_image);
+        }
+
+        MutexGuard::map(preview_image, |image| image.as_mut().unwrap())
+    }
+
+    pub fn add_result(&self, result: SliceResult) {
+        self.result.lock().replace(result);
+    }
+
+    pub fn result(&self) -> MutexGuard<Option<SliceResult>> {
+        self.result.lock()
+    }
+}