refactor(engine): change Color struct into a enum

3 files changed, 52 insertions, 35 deletions

diff --git a/engine/src/rendering/backend/opengl.rs b/engine/src/rendering/backend/opengl.rs
index 95aef27..bab916a 100644
--- a/engine/src/rendering/backend/opengl.rs
+++ b/engine/src/rendering/backend/opengl.rs
@@ -66,9 +66,10 @@ use opengl_bindings::{
 };
 use raw_window_handle::WindowHandle;
 use safer_ffi::layout::ReprC;
-use zerocopy::{Immutable, IntoBytes};
+use zerocopy::IntoBytes;
 
 use crate::asset::Assets;
+use crate::data_types::color::Color;
 use crate::data_types::dimens::Dimens;
 use crate::ecs::actions::Actions;
 use crate::ecs::query::term::Without;
@@ -676,6 +677,7 @@ fn handle_commands(
                 );
 
                 let fvec3_value;
+                let mut color_value = [0.0; 4];
 
                 uniform_buffer
                     .store_at_byte_offset(
@@ -686,10 +688,34 @@ fn handle_commands(
                             ShaderBindingValue::Int(ref value) => value.as_bytes(),
                             ShaderBindingValue::Float(ref value) => value.as_bytes(),
                             ShaderBindingValue::FVec3(value) => {
-                                fvec3_value = CF32Vec3::from(value);
-
+                                fvec3_value = [value.x, value.y, value.z];
                                 fvec3_value.as_bytes()
                             }
+                            ShaderBindingValue::Color(value) => match value {
+                                Color::Rgb(value) => {
+                                    color_value[..3]
+                                        .copy_from_slice(&[value.r, value.g, value.b]);
+
+                                    color_value[..3].as_bytes()
+                                }
+                                Color::Rgba(value) => {
+                                    color_value[..4].copy_from_slice(&[
+                                        value.r, value.g, value.b, value.a,
+                                    ]);
+
+                                    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()
                             }
@@ -1503,23 +1529,6 @@ impl From<crate::draw_flags::PolygonModeFace> for opengl_bindings::misc::Polygon
     }
 }
 
-#[derive(Debug, IntoBytes, Immutable)]
-#[repr(C)]
-pub struct CF32Vec3
-{
-    x: f32,
-    y: f32,
-    z: f32,
-}
-
-impl From<Vec3<f32>> for CF32Vec3
-{
-    fn from(src: Vec3<f32>) -> Self
-    {
-        Self { x: src.x, y: src.y, z: src.z }
-    }
-}
-
 fn blending_factor_to_gl(blending_factor: BlendingFactor) -> GlBlendingFactor
 {
     match blending_factor {
diff --git a/engine/src/rendering/shader/cursor.rs b/engine/src/rendering/shader/cursor.rs
index 17f5748..8aab4f2 100644
--- a/engine/src/rendering/shader/cursor.rs
+++ b/engine/src/rendering/shader/cursor.rs
@@ -1,3 +1,4 @@
+use crate::color::Color;
 use crate::data_types::matrix::Matrix;
 use crate::data_types::vector::Vec3;
 use crate::rendering::object::Id as RenderingObjectId;
@@ -114,6 +115,7 @@ pub enum BindingValue
     Int(i32),
     Float(f32),
     FVec3(Vec3<f32>),
+    Color(Color<f32>),
     FMat4x4(Matrix<f32, 4, 4>),
     Texture(RenderingObjectId),
 }
@@ -150,6 +152,14 @@ impl From<Vec3<f32>> for BindingValue
     }
 }
 
+impl From<Color<f32>> for BindingValue
+{
+    fn from(color: Color<f32>) -> Self
+    {
+        BindingValue::Color(color)
+    }
+}
+
 impl From<Matrix<f32, 4, 4>> for BindingValue
 {
     fn from(matrix: Matrix<f32, 4, 4>) -> Self
diff --git a/engine/src/rendering/shader/default.rs b/engine/src/rendering/shader/default.rs
index 3194706..bb5c366 100644
--- a/engine/src/rendering/shader/default.rs
+++ b/engine/src/rendering/shader/default.rs
@@ -142,7 +142,7 @@ pub fn enqueue_set_shader_bindings(
             MaterialSearchResult::NotFound => {
                 continue;
             }
-            MaterialSearchResult::NoMaterials => &const { Material::builder().build() },
+            MaterialSearchResult::NoMaterials => &Material::builder().build(),
         };
 
         if [
@@ -181,23 +181,21 @@ pub fn enqueue_set_shader_bindings(
             ),
             (
                 material_shader_cursor.field("ambient"),
-                Vec3::from(
-                    if material_flags.use_ambient_color {
-                        &model_material.ambient
-                    } else {
-                        &global_light.ambient
-                    }
-                    .clone(),
-                )
+                (if material_flags.use_ambient_color {
+                    &model_material.ambient
+                } else {
+                    &global_light.ambient
+                }
+                .clone())
                 .into(),
             ),
             (
                 material_shader_cursor.field("diffuse"),
-                Vec3::from(model_material.diffuse.clone()).into(),
+                model_material.diffuse.clone().into(),
             ),
             (
                 material_shader_cursor.field("specular"),
-                Vec3::from(model_material.specular.clone()).into(),
+                model_material.specular.clone().into(),
             ),
             (
                 material_shader_cursor.field("shininess"),
@@ -243,11 +241,11 @@ pub fn enqueue_set_shader_bindings(
                 [
                     (
                         phong_shader_cursor.field("diffuse"),
-                        Vec3::from(point_light.diffuse.clone()).into(),
+                        point_light.diffuse.clone().into(),
                     ),
                     (
                         phong_shader_cursor.field("specular"),
-                        Vec3::from(point_light.specular.clone()).into(),
+                        point_light.specular.clone().into(),
                     ),
                     (
                         point_light_shader_cursor.field("position"),
@@ -281,11 +279,11 @@ pub fn enqueue_set_shader_bindings(
                 [
                     (
                         phong_shader_cursor.field("diffuse"),
-                        Vec3::from(directional_light.diffuse.clone()).into(),
+                        directional_light.diffuse.clone().into(),
                     ),
                     (
                         phong_shader_cursor.field("specular"),
-                        Vec3::from(directional_light.specular.clone()).into(),
+                        directional_light.specular.clone().into(),
                     ),
                     (
                         directional_light_shader_cursor.field("direction"),