feat(render): ui working

5 files changed, 57 insertions, 65 deletions

diff --git a/stockton-render/src/draw/texture/load.rs b/stockton-render/src/draw/texture/load.rs
index eea820a..e278fa2 100644
--- a/stockton-render/src/draw/texture/load.rs
+++ b/stockton-render/src/draw/texture/load.rs
@@ -1,9 +1,8 @@
 use super::{
-    block::LoadedImage, block::TexturesBlock, loader::TextureLoader, repo::BLOCK_SIZE,
-    resolver::TextureResolver, staging_buffer::StagingBuffer, LoadableImage, PIXEL_SIZE,
+    block::LoadedImage, block::TexturesBlock, repo::BLOCK_SIZE, resolver::TextureResolver,
+    staging_buffer::StagingBuffer, LoadableImage, PIXEL_SIZE,
 };
 use crate::types::*;
-use stockton_levels::prelude::*;
 
 use anyhow::{Context, Result};
 use arrayvec::ArrayVec;
@@ -24,9 +23,6 @@ use thiserror::Error;
 pub enum TextureLoadError {
     #[error("No available resources")]
     NoResources,
-
-    #[error("Texture could not be resolved")]
-    ResolveFailed(usize),
 }
 
 pub const FORMAT: Format = Format::Rgba8Srgb;
@@ -43,6 +39,12 @@ pub const LAYERS: SubresourceLayers = SubresourceLayers {
     layers: 0..1,
 };
 
+pub struct TextureLoadConfig<R: TextureResolver> {
+    pub resolver: R,
+    pub filter: Filter,
+    pub wrap_mode: WrapMode,
+}
+
 pub struct QueuedLoad<B: Block<back::Backend>> {
     pub fence: FenceT,
     pub buf: CommandBufferT,
@@ -62,8 +64,6 @@ impl<B: Block<back::Backend>> QueuedLoad<B> {
     }
 }
 
-impl<'a, T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R, I> {}
-
 pub fn tex_size_info<T: LoadableImage>(img: &T, obcpa: hal::buffer::Offset) -> (usize, usize) {
     let initial_row_size = PIXEL_SIZE * img.width() as usize;
     let row_alignment_mask = obcpa as u32 - 1;
@@ -119,13 +119,14 @@ where
     Ok((block, image_ref))
 }
 
-pub unsafe fn load_image<I: LoadableImage>(
+pub unsafe fn load_image<I: LoadableImage, R: TextureResolver>(
     device: &mut DeviceT,
     staging_allocator: &mut DynamicAllocator,
     tex_allocator: &mut DynamicAllocator,
     staging_memory_type: MemoryTypeId,
     obcpa: u64,
     img_data: I,
+    config: &TextureLoadConfig<R>,
 ) -> Result<(StagingBuffer, LoadedImage<DynamicBlock>)> {
     // Calculate buffer size
     let (row_size, total_size) = tex_size_info(&img_data, obcpa);
@@ -172,7 +173,7 @@ pub unsafe fn load_image<I: LoadableImage>(
 
     // Create sampler
     let sampler = device
-        .create_sampler(&SamplerDesc::new(Filter::Nearest, WrapMode::Tile))
+        .create_sampler(&SamplerDesc::new(config.filter, config.wrap_mode))
         .context("Error creating sampler")?;
 
     Ok((
diff --git a/stockton-render/src/draw/texture/loader.rs b/stockton-render/src/draw/texture/loader.rs
index 3d7d32e..96b1646 100644
--- a/stockton-render/src/draw/texture/loader.rs
+++ b/stockton-render/src/draw/texture/loader.rs
@@ -2,10 +2,10 @@
 
 use super::{
     block::{LoadedImage, TexturesBlock},
-    load::{load_image, QueuedLoad, TextureLoadError, LAYERS, RESOURCES},
+    load::{load_image, QueuedLoad, TextureLoadConfig, TextureLoadError, LAYERS, RESOURCES},
     repo::BLOCK_SIZE,
     resolver::TextureResolver,
-    LoadableImage, PIXEL_SIZE,
+    PIXEL_SIZE,
 };
 use crate::{draw::utils::find_memory_type_id, error::LockPoisoned, types::*};
 
@@ -13,7 +13,6 @@ use std::{
     array::IntoIter,
     collections::VecDeque,
     iter::{empty, once},
-    marker::PhantomData,
     mem::{drop, ManuallyDrop},
     sync::{
         mpsc::{Receiver, Sender},
@@ -38,7 +37,6 @@ use image::{Rgba, RgbaImage};
 use log::*;
 use rendy_descriptor::{DescriptorRanges, DescriptorSetLayoutBinding, DescriptorType};
 use rendy_memory::DynamicConfig;
-use stockton_levels::prelude::HasTextures;
 use thiserror::Error;
 
 /// The number of command buffers to have in flight simultaneously.
@@ -49,7 +47,7 @@ pub type BlockRef = usize;
 
 /// Manages the loading/unloading of textures
 /// This is expected to load the textures, then send the loaded blocks back
-pub struct TextureLoader<T, R, I> {
+pub struct TextureLoader<R: TextureResolver> {
     /// Blocks for which commands have been queued and are done loading once the fence is triggered.
     commands_queued: ArrayVec<[QueuedLoad<DynamicBlock>; NUM_SIMULTANEOUS_CMDS]>,
 
@@ -82,11 +80,8 @@ pub struct TextureLoader<T, R, I> {
     /// From adapter, used for determining alignment
     optimal_buffer_copy_pitch_alignment: hal::buffer::Offset,
 
-    /// The textures lump to get info from
-    textures: Arc<RwLock<T>>,
-
-    /// The resolver which gets image data for a given texture.
-    resolver: R,
+    /// Configuration for how to find and load textures
+    config: TextureLoadConfig<R>,
 
     /// The channel requests come in.
     /// Requests should reference a texture **block**, for example textures 8..16 is block 1.
@@ -97,8 +92,6 @@ pub struct TextureLoader<T, R, I> {
 
     /// A filler image for descriptors that aren't needed but still need to be written to
     blank_image: ManuallyDrop<LoadedImage<DynamicBlock>>,
-
-    _li: PhantomData<I>,
 }
 
 #[derive(Error, Debug)]
@@ -107,7 +100,7 @@ pub enum TextureLoaderError {
     NoMemoryTypes,
 }
 
-impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R, I> {
+impl<R: TextureResolver> TextureLoader<R> {
     pub fn loop_until_exit(mut self) -> Result<TextureLoaderRemains> {
         debug!("TextureLoader starting main loop");
         let mut res = Ok(false);
@@ -196,8 +189,7 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
         ds_layout: Arc<RwLock<DescriptorSetLayoutT>>,
         request_channel: Receiver<LoaderRequest>,
         return_channel: Sender<TexturesBlock<DynamicBlock>>,
-        texs: Arc<RwLock<T>>,
-        resolver: R,
+        config: TextureLoadConfig<R>,
     ) -> Result<Self> {
         let mut device = device_lock
             .write()
@@ -310,6 +302,7 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
                 &mut tex_allocator,
                 staging_memory_type,
                 optimal_buffer_copy_pitch_alignment,
+                &config,
             )
         }
         .context("Error creating blank image")?;
@@ -333,10 +326,8 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
 
             request_channel,
             return_channel,
-            textures: texs,
-            resolver,
+            config,
             blank_image: ManuallyDrop::new(blank_image),
-            _li: PhantomData::default(),
         })
     }
 
@@ -347,12 +338,6 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
             .map_err(|_| LockPoisoned::Device)
             .context("Error getting device lock")?;
 
-        let textures = self
-            .textures
-            .read()
-            .map_err(|_| LockPoisoned::Map)
-            .context("Error getting map lock")?;
-
         // Get assets to use
         let (mut fence, mut buf) = self
             .buffers
@@ -407,9 +392,9 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
 
         // For each texture in block
         for tex_idx in (block_ref * BLOCK_SIZE)..(block_ref + 1) * BLOCK_SIZE {
-            // Get texture and Resolve image
-            let tex = textures.get_texture(tex_idx as u32);
-            if tex.is_none() {
+            // Resolve texture
+            let img_data = self.config.resolver.resolve(tex_idx as u32);
+            if img_data.is_none() {
                 // Write a blank descriptor
                 device.write_descriptor_set(DescriptorSetWrite {
                     set: descriptor_set.raw_mut(),
@@ -430,12 +415,8 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
                 continue;
             }
 
-            let tex = tex.unwrap();
+            let img_data = img_data.unwrap();
 
-            let img_data = self
-                .resolver
-                .resolve(tex)
-                .ok_or(TextureLoadError::ResolveFailed(tex_idx))?;
             let array_offset = tex_idx % BLOCK_SIZE;
 
             let (staging_buffer, img) = load_image(
@@ -445,6 +426,7 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
                 self.staging_memory_type,
                 self.optimal_buffer_copy_pitch_alignment,
                 img_data,
+                &self.config,
             )?;
 
             // Write to descriptor set
@@ -555,6 +537,7 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
         tex_allocator: &mut DynamicAllocator,
         staging_memory_type: MemoryTypeId,
         obcpa: u64,
+        config: &TextureLoadConfig<R>,
     ) -> Result<LoadedImage<DynamicBlock>> {
         let img_data = RgbaImage::from_pixel(1, 1, Rgba([0, 0, 0, 0]));
 
@@ -572,6 +555,7 @@ impl<T: HasTextures, R: TextureResolver<I>, I: LoadableImage> TextureLoader<T, R
             staging_memory_type,
             obcpa,
             img_data,
+            &config,
         )?;
 
         buf.begin_primary(CommandBufferFlags::ONE_TIME_SUBMIT);
diff --git a/stockton-render/src/draw/texture/mod.rs b/stockton-render/src/draw/texture/mod.rs
index 43c89d5..62b28c5 100644
--- a/stockton-render/src/draw/texture/mod.rs
+++ b/stockton-render/src/draw/texture/mod.rs
@@ -10,6 +10,7 @@ mod staging_buffer;
 
 pub use self::block::TexturesBlock;
 pub use self::image::LoadableImage;
+pub use self::load::TextureLoadConfig;
 pub use self::loader::BlockRef;
 pub use self::repo::TextureRepo;
 
diff --git a/stockton-render/src/draw/texture/repo.rs b/stockton-render/src/draw/texture/repo.rs
index 8191f7b..ef35610 100644
--- a/stockton-render/src/draw/texture/repo.rs
+++ b/stockton-render/src/draw/texture/repo.rs
@@ -1,10 +1,8 @@
-use stockton_levels::prelude::HasTextures;
-
 use super::{
     block::TexturesBlock,
+    load::TextureLoadConfig,
     loader::{BlockRef, LoaderRequest, TextureLoader, TextureLoaderRemains, NUM_SIMULTANEOUS_CMDS},
     resolver::TextureResolver,
-    LoadableImage,
 };
 use crate::error::LockPoisoned;
 use crate::types::*;
@@ -49,17 +47,12 @@ impl<'a> TextureRepo<'a> {
         family.queue_type().supports_transfer() && family.max_queues() >= NUM_SIMULTANEOUS_CMDS
     }
 
-    pub fn new<
-        T: 'static + HasTextures + Send + Sync,
-        R: 'static + TextureResolver<I> + Send + Sync,
-        I: 'static + LoadableImage + Send,
-    >(
+    pub fn new<R: 'static + TextureResolver + Send + Sync>(
         device_lock: Arc<RwLock<DeviceT>>,
         family: QueueFamilyId,
         queue: Arc<RwLock<QueueT>>,
         adapter: &Adapter,
-        texs_lock: Arc<RwLock<T>>,
-        resolver: R,
+        config: TextureLoadConfig<R>,
     ) -> Result<Self> {
         // Create Channels
         let (req_send, req_recv) = channel();
@@ -112,8 +105,7 @@ impl<'a> TextureRepo<'a> {
                 ds_lock.clone(),
                 req_recv,
                 resp_send,
-                texs_lock,
-                resolver,
+                config,
             )?;
 
             std::thread::spawn(move || loader.loop_until_exit())
diff --git a/stockton-render/src/draw/texture/resolver.rs b/stockton-render/src/draw/texture/resolver.rs
index 20efa00..1ecb7a0 100644
--- a/stockton-render/src/draw/texture/resolver.rs
+++ b/stockton-render/src/draw/texture/resolver.rs
@@ -1,33 +1,47 @@
 //! Resolves a texture in a BSP File to an image
 
 use crate::draw::texture::image::LoadableImage;
-use stockton_levels::traits::textures::Texture;
+use stockton_levels::prelude::HasTextures;
 
-use std::path::Path;
+use std::{
+    mem::drop,
+    path::Path,
+    sync::{Arc, RwLock},
+};
 
 use image::{io::Reader, RgbaImage};
 
 /// An object that can be used to resolve a texture from a BSP File
-pub trait TextureResolver<T: LoadableImage> {
+pub trait TextureResolver {
+    type Image: LoadableImage;
+
     /// Get the given texture, or None if it's corrupt/not there.
-    fn resolve(&mut self, texture: &Texture) -> Option<T>;
+    fn resolve(&mut self, texture_id: u32) -> Option<Self::Image>;
 }
 
-/// A basic filesystem resolver which expects no file extension and guesses the image format
-pub struct BasicFsResolver<'a> {
+/// A basic filesystem resolver which gets the texture name from any HasTextures Object.
+pub struct FsResolver<'a, T: HasTextures> {
     path: &'a Path,
+    map_lock: Arc<RwLock<T>>,
 }
 
-impl<'a> BasicFsResolver<'a> {
-    pub fn new(path: &'a Path) -> BasicFsResolver<'a> {
-        BasicFsResolver { path }
+impl<'a, T: HasTextures> FsResolver<'a, T> {
+    pub fn new(path: &'a Path, map_lock: Arc<RwLock<T>>) -> Self {
+        FsResolver { path, map_lock }
     }
 }
 
-impl<'a> TextureResolver<RgbaImage> for BasicFsResolver<'a> {
-    fn resolve(&mut self, tex: &Texture) -> Option<RgbaImage> {
+impl<'a, T: HasTextures> TextureResolver for FsResolver<'a, T> {
+    type Image = RgbaImage;
+
+    fn resolve(&mut self, tex: u32) -> Option<Self::Image> {
+        let map = self.map_lock.read().unwrap();
+        let tex = map.get_texture(tex)?;
         let path = self.path.join(&tex.name);
 
+        drop(tex);
+        drop(map);
+
         if let Ok(file) = Reader::open(path) {
             if let Ok(guessed) = file.with_guessed_format() {
                 if let Ok(decoded) = guessed.decode() {