directional light

src/scene/light.rs

@@ -1,6 +1,22 @@
 use cgmath::{InnerSpace, MetricSpace, Vector3};
 
 use crate::vertex;
+use super::memorizable::Memorizable;
+use super::AppData;
+use super::Scene;
+
+pub enum LightType {
+    POINT,
+    DIRECTION
+}
+
+pub trait Light {
+    fn get_light_type(&self) -> LightType;
+    fn weighted_distance(&self, center: Vector3<usize>) -> f32;
+}
+
+pub trait LightSource: Light + Memorizable {}
+
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct PointLight{
@@ -9,26 +25,151 @@ pub struct PointLight{
     pub memory_start: usize,
 }
 
-impl PointLight {
-    pub fn get_buffer_mem_size(&self) -> u32 {
-        3 + 3
+impl Memorizable for PointLight {
+    fn get_buffer_mem_size(&self, data: &AppData) -> u32 {
+        1 + 3 + 3
     }
 
-    pub fn insert_into_memory(&self, mut v: Vec<u32>) -> Vec<u32> { 
-        v[self.memory_start] = u32::from_ne_bytes(self.pos.x.to_ne_bytes());
-        v[self.memory_start + 1] = u32::from_ne_bytes(self.pos.y.to_ne_bytes());
-        v[self.memory_start + 2] = u32::from_ne_bytes(self.pos.z.to_ne_bytes());
+    fn insert_into_memory(&self, mut v: Vec<u32>, data: &AppData, scene: &Scene) -> Vec<u32> { 
+        v[self.memory_start] = LightType::POINT as u32;
 
-        v[self.memory_start + 3] = (self.color.x * 255.0) as u32;
-        v[self.memory_start + 4] = (self.color.y * 255.0) as u32;
-        v[self.memory_start + 5] = (self.color.z * 255.0) as u32;
+        v[self.memory_start + 1] = u32::from_ne_bytes(self.pos.x.to_ne_bytes());
+        v[self.memory_start + 2] = u32::from_ne_bytes(self.pos.y.to_ne_bytes());
+        v[self.memory_start + 3] = u32::from_ne_bytes(self.pos.z.to_ne_bytes());
+
+        v[self.memory_start + 4] = (self.color.x * 255.0) as u32;
+        v[self.memory_start + 5] = (self.color.y * 255.0) as u32;
+        v[self.memory_start + 6] = (self.color.z * 255.0) as u32;
         v
     }
 
-    pub fn weighted_distance(&self, center: Vector3<usize>) -> f32 {
+    fn get_memory_start(&self) -> usize {
+        self.memory_start
+    }
+
+    fn set_memory_start(&mut self, memory_start: usize) {
+        self.memory_start = memory_start;
+    }
+}
+
+impl Light for PointLight {
+    fn get_light_type(&self) -> LightType {
+        LightType::POINT
+    }
+
+    fn weighted_distance(&self, center: Vector3<usize>) -> f32 {
         let distance = self.pos.distance(vertex::Vec3{x: center.x as f32, y: center.y as f32, z: center.z as f32});
         let light_intensity = self.color.magnitude();
 
         light_intensity / distance.powf(2.0)        
     }
+}
+
+impl LightSource for PointLight {}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct DirectionalLight{
+    pub direction: vertex::Vec3,
+    pub color: vertex::Vec3,
+    pub memory_start: usize,
+}
+
+impl Memorizable for DirectionalLight {
+    fn get_buffer_mem_size(&self, data: &AppData) -> u32 {
+        1 + 3 + 3
+    }
+
+    fn insert_into_memory(&self, mut v: Vec<u32>, data: &AppData, scene: &Scene) -> Vec<u32> { 
+        v[self.memory_start] = LightType::DIRECTION as u32;
+
+        v[self.memory_start + 1] = u32::from_ne_bytes(self.direction.x.to_ne_bytes());
+        v[self.memory_start + 2] = u32::from_ne_bytes(self.direction.y.to_ne_bytes());
+        v[self.memory_start + 3] = u32::from_ne_bytes(self.direction.z.to_ne_bytes());
+
+        v[self.memory_start + 4] = (self.color.x * 255.0) as u32;
+        v[self.memory_start + 5] = (self.color.y * 255.0) as u32;
+        v[self.memory_start + 6] = (self.color.z * 255.0) as u32;
+        v
+    }
+
+    fn get_memory_start(&self) -> usize {
+        self.memory_start
+    }
+
+    fn set_memory_start(&mut self, memory_start: usize) {
+        self.memory_start = memory_start;
+    }
+}
+
+impl Light for DirectionalLight {
+    fn get_light_type(&self) -> LightType {
+        LightType::DIRECTION
+    }
+
+    fn weighted_distance(&self, center: Vector3<usize>) -> f32 {
+        let light_intensity = self.color.magnitude();
+
+        light_intensity
+    }
+}
+
+impl LightSource for DirectionalLight {}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_memorizable() {
+        let p = PointLight {pos: vertex::Vec3 { x: 1.0, y: 2.0, z: 3.0}, color: vertex::Vec3 { x: 0.0, y: 1.0, z: 0.0}, memory_start: 0};
+        let data= AppData::default();
+        let scene = Scene::default();
+
+        let mem_size = p.get_buffer_mem_size(&data);
+        assert!(mem_size == 7);
+
+        let mut memory = vec![0; 7];
+        p.insert_into_memory(memory, &data, &scene);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_mem_size() {
+        let p = PointLight {pos: vertex::Vec3 { x: 1.0, y: 2.0, z: 3.0}, color: vertex::Vec3 { x: 0.0, y: 1.0, z: 0.0}, memory_start: 0};
+        let data= AppData::default();
+        let scene = Scene::default();
+
+        let mem_size = p.get_buffer_mem_size(&data);
+        assert!(mem_size == 7);
+
+        let mut memory = vec![0; 6];
+        p.insert_into_memory(memory, &data, &scene);
+    }
+
+    #[test]
+    fn test_memorizable_directional_light() {
+        let p = DirectionalLight {direction: vertex::Vec3 { x: 1.0, y: 2.0, z: 3.0}, color: vertex::Vec3 { x: 0.0, y: 1.0, z: 0.0}, memory_start: 0};
+        let data= AppData::default();
+        let scene = Scene::default();
+
+        let mem_size = p.get_buffer_mem_size(&data);
+        assert!(mem_size == 7);
+
+        let mut memory = vec![0; 7];
+        p.insert_into_memory(memory, &data, &scene);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_mem_size_directional_light() {
+        let p = DirectionalLight {direction: vertex::Vec3 { x: 1.0, y: 2.0, z: 3.0}, color: vertex::Vec3 { x: 0.0, y: 1.0, z: 0.0}, memory_start: 0};
+        let data= AppData::default();
+        let scene = Scene::default();
+
+        let mem_size = p.get_buffer_mem_size(&data);
+        assert!(mem_size == 7);
+
+        let mut memory = vec![0; 6];
+        p.insert_into_memory(memory, &data, &scene);
+    }
 }