refactor(engine): remove support for lumen colors

4 files changed, 41 insertions, 90 deletions

diff --git a/engine/src/data_types/color.rs b/engine/src/data_types/color.rs
index 18d5334..4b981fd 100644
--- a/engine/src/data_types/color.rs
+++ b/engine/src/data_types/color.rs
@@ -44,16 +44,12 @@ macro_rules! gen_color {
 
 gen_color!(Rgb, components = (r, g, b));
 gen_color!(Rgba, components = (r, g, b, a));
-gen_color!(Luma, components = (l));
-gen_color!(LumaA, components = (l, a));
 
 #[derive(Debug, Clone)]
 pub enum Color<Component>
 {
     Rgb(Rgb<Component>),
     Rgba(Rgba<Component>),
-    Luma(Luma<Component>),
-    LumaA(LumaA<Component>),
 }
 
 impl<Component: Default> Default for Color<Component>
@@ -97,16 +93,6 @@ gen_scalar_math_op_impl!(Rgba, Sub, sub, components = (r, g, b, a));
 gen_scalar_math_op_impl!(Rgba, Mul, mul, components = (r, g, b, a));
 gen_scalar_math_op_impl!(Rgba, Div, div, components = (r, g, b, a));
 
-gen_scalar_math_op_impl!(Luma, Add, add, components = (l));
-gen_scalar_math_op_impl!(Luma, Sub, sub, components = (l));
-gen_scalar_math_op_impl!(Luma, Mul, mul, components = (l));
-gen_scalar_math_op_impl!(Luma, Div, div, components = (l));
-
-gen_scalar_math_op_impl!(LumaA, Add, add, components = (l, a));
-gen_scalar_math_op_impl!(LumaA, Sub, sub, components = (l, a));
-gen_scalar_math_op_impl!(LumaA, Mul, mul, components = (l, a));
-gen_scalar_math_op_impl!(LumaA, Div, div, components = (l, a));
-
 macro_rules! gen_enum_scalar_math_op_impl {
     (
         $ident: ident,
@@ -133,10 +119,10 @@ macro_rules! gen_enum_scalar_math_op_impl {
     };
 }
 
-gen_enum_scalar_math_op_impl!(Color, Add, add, variants = (Rgb, Rgba, Luma, LumaA));
-gen_enum_scalar_math_op_impl!(Color, Sub, sub, variants = (Rgb, Rgba, Luma, LumaA));
-gen_enum_scalar_math_op_impl!(Color, Mul, mul, variants = (Rgb, Rgba, Luma, LumaA));
-gen_enum_scalar_math_op_impl!(Color, Div, div, variants = (Rgb, Rgba, Luma, LumaA));
+gen_enum_scalar_math_op_impl!(Color, Add, add, variants = (Rgb, Rgba));
+gen_enum_scalar_math_op_impl!(Color, Sub, sub, variants = (Rgb, Rgba));
+gen_enum_scalar_math_op_impl!(Color, Mul, mul, variants = (Rgb, Rgba));
+gen_enum_scalar_math_op_impl!(Color, Div, div, variants = (Rgb, Rgba));
 
 mod sealed
 {
diff --git a/engine/src/image.rs b/engine/src/image.rs
index 18d3015..b01ea53 100644
--- a/engine/src/image.rs
+++ b/engine/src/image.rs
@@ -6,7 +6,7 @@ use std::path::Path;
 
 use image_rs::GenericImageView as _;
 
-use crate::color::{Luma, LumaA, Pixel as ColorPixel, Rgb, Rgba};
+use crate::color::{Pixel as ColorPixel, Rgb, Rgba};
 use crate::data_types::dimens::Dimens;
 use crate::vector::Vec2;
 
@@ -22,17 +22,14 @@ impl Image
     {
         let buffered_reader = BufReader::new(File::open(&path).map_err(Error::Io)?);
 
-        let image_reader = image_rs::ImageReader::with_format(
+        Self::from_reader(
             buffered_reader,
-            image_rs::ImageFormat::from_path(path)
-                .map_err(|_| Error::UnsupportedFormat)?,
-        );
-
-        Ok(Self {
-            inner: image_reader
-                .decode()
-                .map_err(|err| Error::DecodeFailed(DecodeError(err)))?,
-        })
+            Format::from_image_rs(
+                image_rs::ImageFormat::from_path(path)
+                    .map_err(|_| Error::UnsupportedFormat)?,
+            )
+            .ok_or(Error::UnsupportedFormat)?,
+        )
     }
 
     pub fn from_reader(reader: impl BufRead + Seek, format: Format)
@@ -41,12 +38,18 @@ impl Image
         let image_reader =
             image_rs::ImageReader::with_format(reader, format.into_image_rs());
 
-        Ok(Self {
-            inner: image_reader
-                .decode()
-                // TODO: err might be other errors than decode errors here
-                .map_err(|err| Error::DecodeFailed(DecodeError(err)))?,
-        })
+        let image = match image_reader
+            .decode()
+            .map_err(|err| Error::DecodeFailed(DecodeError(err)))?
+        {
+            image @ (image_rs::DynamicImage::ImageLuma8(_)
+            | image_rs::DynamicImage::ImageLumaA8(_)
+            | image_rs::DynamicImage::ImageLuma16(_)
+            | image_rs::DynamicImage::ImageLumaA16(_)) => image.into_rgba32f().into(),
+            image => image,
+        };
+
+        Ok(Self { inner: image })
     }
 
     pub fn from_pixels<PixelT, Buf>(
@@ -95,7 +98,7 @@ impl Image
         assert!(offset.x + size.width <= self.dimensions().width);
         assert!(offset.y + size.height <= self.dimensions().height);
 
-        SubView { image: &self.inner, offset, size }
+        SubView { image: &self, offset, size }
     }
 
     pub fn to_rgba8(&self) -> Self
@@ -192,12 +195,6 @@ gen_try_from_pixel_buffer_impl!(Rgba<u8>);
 gen_try_from_pixel_buffer_impl!(Rgba<u16>);
 gen_try_from_pixel_buffer_impl!(Rgba<f32>);
 
-gen_try_from_pixel_buffer_impl!(Luma<u8>);
-gen_try_from_pixel_buffer_impl!(Luma<u16>);
-
-gen_try_from_pixel_buffer_impl!(LumaA<u8>);
-gen_try_from_pixel_buffer_impl!(LumaA<u16>);
-
 #[derive(Debug)]
 pub struct PixelBuffer<PixelT, Buf>
 where
@@ -225,24 +222,12 @@ where
 #[non_exhaustive]
 pub enum ColorType
 {
-    /// Pixel is 8-bit luminance
-    L8,
-
-    /// Pixel is 8-bit luminance with an alpha channel
-    La8,
-
     /// Pixel contains 8-bit R, G and B channels
     Rgb8,
 
     /// Pixel is 8-bit RGB with an alpha channel
     Rgba8,
 
-    /// Pixel is 16-bit luminance
-    L16,
-
-    /// Pixel is 16-bit luminance with an alpha channel
-    La16,
-
     /// Pixel is 16-bit RGB
     Rgb16,
 
@@ -261,16 +246,16 @@ impl From<image_rs::ColorType> for ColorType
     fn from(color_type: image_rs::ColorType) -> Self
     {
         match color_type {
-            image_rs::ColorType::L8 => Self::L8,
-            image_rs::ColorType::La8 => Self::La8,
             image_rs::ColorType::Rgb8 => Self::Rgb8,
             image_rs::ColorType::Rgba8 => Self::Rgba8,
-            image_rs::ColorType::L16 => Self::L16,
-            image_rs::ColorType::La16 => Self::La16,
             image_rs::ColorType::Rgb16 => Self::Rgb16,
             image_rs::ColorType::Rgba16 => Self::Rgba16,
             image_rs::ColorType::Rgb32F => Self::Rgb32F,
             image_rs::ColorType::Rgba32F => Self::Rgba32F,
+            image_rs::ColorType::L8
+            | image_rs::ColorType::La8
+            | image_rs::ColorType::L16
+            | image_rs::ColorType::La16 => unimplemented!(),
             _ => {
                 panic!("Unrecognized image_rs::ColorType variant");
             }
@@ -297,11 +282,21 @@ impl Format
             Self::Ico => image_rs::ImageFormat::Ico,
         }
     }
+
+    fn from_image_rs(format: image_rs::ImageFormat) -> Option<Self>
+    {
+        match format {
+            image_rs::ImageFormat::Png => Some(Self::Png),
+            image_rs::ImageFormat::Jpeg => Some(Self::Jpeg),
+            image_rs::ImageFormat::Ico => Some(Self::Ico),
+            _ => None,
+        }
+    }
 }
 
 pub struct SubView<'image>
 {
-    image: &'image image_rs::DynamicImage,
+    image: &'image Image,
     offset: Vec2<u32>,
     size: Dimens<u32>,
 }
@@ -321,25 +316,13 @@ impl SubView<'_>
         }
 
         Image {
-            inner: match self.image {
-                image_rs::DynamicImage::ImageLuma8(image) => {
-                    create_sub_image(image, self).to_image().into()
-                }
-                image_rs::DynamicImage::ImageLumaA8(image) => {
-                    create_sub_image(image, self).to_image().into()
-                }
+            inner: match &self.image.inner {
                 image_rs::DynamicImage::ImageRgb8(image) => {
                     create_sub_image(image, self).to_image().into()
                 }
                 image_rs::DynamicImage::ImageRgba8(image) => {
                     create_sub_image(image, self).to_image().into()
                 }
-                image_rs::DynamicImage::ImageLuma16(image) => {
-                    create_sub_image(image, self).to_image().into()
-                }
-                image_rs::DynamicImage::ImageLumaA16(image) => {
-                    create_sub_image(image, self).to_image().into()
-                }
                 image_rs::DynamicImage::ImageRgb16(image) => {
                     create_sub_image(image, self).to_image().into()
                 }
diff --git a/engine/src/rendering/backend/opengl.rs b/engine/src/rendering/backend/opengl.rs
index 0dfe960..6a8637b 100644
--- a/engine/src/rendering/backend/opengl.rs
+++ b/engine/src/rendering/backend/opengl.rs
@@ -769,16 +769,6 @@ fn handle_commands(
 
                                     color_value[..4].as_bytes()
                                 }
-                                Color::Luma(ref value) => {
-                                    color_value[0] = value.l;
-
-                                    color_value[0].as_bytes()
-                                }
-                                Color::LumaA(value) => {
-                                    color_value[..2].copy_from_slice(&[value.l, value.a]);
-
-                                    color_value[..2].as_bytes()
-                                }
                             },
                             ShaderBindingValue::FMat4x4(ref value) => {
                                 value.items().as_bytes()
diff --git a/engine/src/rendering/shader/cursor.rs b/engine/src/rendering/shader/cursor.rs
index 47b388a..82b5ec0 100644
--- a/engine/src/rendering/shader/cursor.rs
+++ b/engine/src/rendering/shader/cursor.rs
@@ -246,14 +246,6 @@ impl BindingValue
                     && element_scalar_ty == Some(ScalarType::Float32)
                     && element_cnt == Some(4)
             }
-            Self::Color(Color::Luma(_)) => {
-                ty_kind == TypeKind::Scalar && scalar_ty == Some(ScalarType::Float32)
-            }
-            Self::Color(Color::LumaA(_)) => {
-                ty_kind == TypeKind::Vector
-                    && element_scalar_ty == Some(ScalarType::Float32)
-                    && element_cnt == Some(2)
-            }
             Self::FMat4x4(_) => {
                 ty_kind == TypeKind::Matrix
                     && element_scalar_ty == Some(ScalarType::Float32)