1 files changed, 42 insertions, 144 deletions

diff --git a/engine/src/texture.rs b/engine/src/texture.rs
index 16c1941..d02b9ff 100644
--- a/engine/src/texture.rs
+++ b/engine/src/texture.rs
@@ -1,152 +1,37 @@
-use std::fmt::Display;
-use std::path::Path;
-use std::sync::atomic::{AtomicU32, Ordering};
-
-use image::io::Reader as ImageReader;
-use image::{DynamicImage, ImageError, Rgb, RgbImage};
-
-use crate::color::Color;
-use crate::data_types::dimens::Dimens;
-use crate::opengl::texture::PixelDataFormat;
-
-static NEXT_ID: AtomicU32 = AtomicU32::new(0);
-
-mod reexports
-{
-    pub use crate::opengl::texture::{Filtering, Wrapping};
-}
-
-pub use reexports::*;
+use crate::asset::Handle as AssetHandle;
+use crate::image::Image;
+use crate::builder;
 
 #[derive(Debug, Clone)]
+#[non_exhaustive]
 pub struct Texture
 {
-    id: Id,
-    image: DynamicImage,
-    pixel_data_format: PixelDataFormat,
-    dimensions: Dimens<u32>,
-    properties: Properties,
+    pub asset_handle: AssetHandle<Image>,
+    pub properties: Properties,
 }
 
 impl Texture
 {
-    /// Opens a texture image.
-    ///
-    /// # Errors
-    /// Will return `Err` if:
-    /// - Opening the image fails
-    /// - The image data is not 8-bit/color RGB
-    #[allow(clippy::new_without_default)]
-    pub fn open(path: &Path) -> Result<Self, Error>
-    {
-        let image = ImageReader::open(path)
-            .map_err(Error::OpenImageFailed)?
-            .decode()
-            .map_err(Error::DecodeImageFailed)?;
-
-        let pixel_data_format = match &image {
-            DynamicImage::ImageRgb8(_) => PixelDataFormat::Rgb8,
-            DynamicImage::ImageRgba8(_) => PixelDataFormat::Rgba8,
-            _ => {
-                return Err(Error::UnsupportedImageDataKind);
-            }
-        };
-
-        let dimensions = Dimens {
-            width: image.width(),
-            height: image.height(),
-        };
-
-        let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
-
-        Ok(Self {
-            id: Id::new(id),
-            image,
-            pixel_data_format,
-            dimensions,
-            properties: Properties::default(),
-        })
-    }
-
-    #[must_use]
-    pub fn new_from_color(dimensions: &Dimens<u32>, color: &Color<u8>) -> Self
+    pub fn new(asset_handle: AssetHandle<Image>) -> Self
     {
-        let image = RgbImage::from_pixel(
-            dimensions.width,
-            dimensions.height,
-            Rgb([color.red, color.green, color.blue]),
-        );
-
-        let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
-
         Self {
-            id: Id::new(id),
-            image: image.into(),
-            pixel_data_format: PixelDataFormat::Rgb8,
-            dimensions: *dimensions,
+            asset_handle,
             properties: Properties::default(),
         }
     }
 
-    #[must_use]
-    pub fn id(&self) -> Id
-    {
-        self.id
-    }
-
-    #[must_use]
-    pub fn properties(&self) -> &Properties
-    {
-        &self.properties
-    }
-
-    pub fn properties_mut(&mut self) -> &mut Properties
+    pub fn with_properties(
+        asset_handle: AssetHandle<Image>,
+        properties: Properties,
+    ) -> Self
     {
-        &mut self.properties
-    }
-
-    #[must_use]
-    pub fn dimensions(&self) -> &Dimens<u32>
-    {
-        &self.dimensions
-    }
-
-    #[must_use]
-    pub fn pixel_data_format(&self) -> PixelDataFormat
-    {
-        self.pixel_data_format
-    }
-
-    #[must_use]
-    pub fn image(&self) -> &DynamicImage
-    {
-        &self.image
-    }
-}
-
-impl Drop for Texture
-{
-    fn drop(&mut self)
-    {
-        NEXT_ID.fetch_sub(1, Ordering::Relaxed);
+        Self { asset_handle, properties }
     }
 }
 
-/// Texture error.
-#[derive(Debug, thiserror::Error)]
-pub enum Error
-{
-    #[error("Failed to open texture image")]
-    OpenImageFailed(#[source] std::io::Error),
-
-    #[error("Failed to decode texture image")]
-    DecodeImageFailed(#[source] ImageError),
-
-    #[error("Unsupported image data kind")]
-    UnsupportedImageDataKind,
-}
-
+builder! {
 /// Texture properties
+#[builder(name = PropertiesBuilder, derives=(Debug, Clone))]
 #[derive(Debug, Clone)]
 #[non_exhaustive]
 pub struct Properties
@@ -155,6 +40,15 @@ pub struct Properties
     pub magnifying_filter: Filtering,
     pub minifying_filter: Filtering,
 }
+}
+
+impl Properties
+{
+    pub fn builder() -> PropertiesBuilder
+    {
+        PropertiesBuilder::default()
+    }
+}
 
 impl Default for Properties
 {
@@ -168,25 +62,29 @@ impl Default for Properties
     }
 }
 
-/// Texture ID.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Id
+impl Default for PropertiesBuilder
 {
-    id: u32,
+    fn default() -> Self
+    {
+        Properties::default().into()
+    }
 }
 
-impl Id
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub enum Filtering
 {
-    fn new(id: u32) -> Self
-    {
-        Self { id }
-    }
+    Nearest,
+    Linear,
 }
 
-impl Display for Id
+/// Texture wrapping.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub enum Wrapping
 {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        self.id.fmt(formatter)
-    }
+    Repeat,
+    MirroredRepeat,
+    ClampToEdge,
+    ClampToBorder,
 }