Basics implemented for scene serde, serialisation working for some co…

…mponents.

cobalt_assets/src/asset.rs

@@ -1,7 +1,7 @@
 
 use cobalt_ecs::exports::Component;
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use serde::Serialize;
+use serde::{de::DeserializeSeed, Serialize};
 use std::{
     any::Any,
     fmt::{Debug, Formatter},
@@ -135,7 +135,31 @@ impl<T: AssetTrait> PartialEq for Asset<T> {
     }
 }
 
-impl<T: AssetTrait> Component for Asset<T> {}
+impl<T: AssetTrait> Component for Asset<T> {
+    type DeContext<'a> = ();
+    type SerContext<'a> = ();
+
+    fn deserialise<'de, D>(context: Self::DeContext<'de>, deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+        todo!()
+    }
+
+    fn serialize<'se, S>(&self, context: Self::DeContext<'se>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer {
+        todo!()
+    }
+}
+
+
+impl<'de, T: AssetTrait> serde::Deserialize<'de> for Asset<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+        todo!()
+    }
+}
 
 impl<T: AssetTrait> Eq for Asset<T> {}
 
@@ -220,22 +244,6 @@ impl<T: AssetTrait> Asset<T> {
     }
 }
 
-impl<T: AssetTrait> Serialize for Asset<T> {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.asset_id.serialize(serializer)
-    }
-}
-
-impl<'de, T: AssetTrait> serde::Deserialize<'de> for Asset<T> {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let asset_id = uuid::Uuid::deserialize(deserializer)?;
-
-        log::error!("Attempted to deserialise asset with id: {:?}", asset_id);
-
-        todo!("Implement Asset<T> deserialization from asset_id")
-    }
-}
-
 impl<T: AssetTrait> Drop for Asset<T> {
     fn drop(&mut self) {
         // If it can't be upgraded, the asset server has been dropped.

cobalt_core/Cargo.toml

@@ -61,6 +61,7 @@ bincode = "1.3.3"
 zstd = "0.13.2"
 
 cobalt_ecs = { path = "../cobalt_ecs" }
+serde_yaml = "0.9.30"
 
 [dev-dependencies]
 simple_logger = "5.0.0"

cobalt_core/src/components/entity_name.rs

@@ -1,10 +1,27 @@
 use cobalt_ecs::exports::Component;
 
 
-
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct EntityName(pub String);
 
-impl Component for EntityName {}
+impl Component for EntityName {
+    type DeContext<'a> = ();
+
+    fn deserialise<'de, D>(_context: Self::DeContext<'de>, deserializer: D) -> Result<Self, D::Error>
+    where
+    D: serde::Deserializer<'de> {
+        let name: EntityName = serde::Deserialize::deserialize(deserializer)?;
+        Ok(name)
+    }
+
+    type SerContext<'a> = ();
+
+    fn serialize<'se, S>(&self, _context: Self::DeContext<'se>, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer {
+        serde::Serialize::serialize(&self, serializer)
+    }
+}
 
 impl std::fmt::Display for EntityName {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

cobalt_core/src/components/mod.rs

@@ -1,9 +1,11 @@
 pub mod transform;
 pub mod entity_name;
+pub mod state;
 
 pub mod exports {
     pub use super::entity_name::EntityName;
     pub use super::transform::Transform;
     pub use crate::renderer::camera::Camera;
+    pub use super::state::State;
     pub use crate::renderer::renderable::Renderable;
 }

cobalt_core/src/components/state.rs

@@ -0,0 +1,42 @@
+use cobalt_ecs::exports::Component;
+
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct State(hashbrown::HashMap<String, StateValue>);
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub enum StateValue {
+    Bool(bool),
+    U8(u8),
+    U16(u16),
+    U32(u32),
+    U64(u64),
+    I8(i8),
+    I16(i16),
+    I32(i32),
+    I64(i64),
+    F32(f32),
+    F64(f64),
+    String(String),
+    Array(Vec<StateValue>),
+    Map(hashbrown::HashMap<String, StateValue>),
+}
+
+impl Component for State {
+    type SerContext<'a> = ();
+
+    fn serialize<'se, S>(&self, _context: Self::SerContext<'se>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer {
+        serde::Serialize::serialize(&self, serializer)
+    }
+
+    type DeContext<'a> = ();
+
+    fn deserialise<'de, D>(_context: Self::DeContext<'de>, deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+        let state: State = serde::Deserialize::deserialize(deserializer)?;
+        Ok(state)
+    }
+}

cobalt_core/src/components/transform.rs

@@ -5,6 +5,7 @@
 
 use std::fmt::{Debug, Formatter};
 
+use serde::Serialize;
 use ultraviolet::{Mat3, Mat4, Rotor3, Vec3};
 use wgpu::{util::DeviceExt, BindGroupDescriptor};
 
@@ -95,7 +96,64 @@ impl Debug for Transform {
     }
 }
 
-impl Component for Transform {}
+#[derive(serde::Serialize, serde::Deserialize)]
+struct TransformSerdeBuffer {
+    position: Vec3,
+    rotation: Rotor3,
+    scale: Vec3,
+}
+
+impl Serialize for Transform {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer {
+        let buffer = TransformSerdeBuffer {
+            position: self.position,
+            rotation: self.rotation,
+            scale: self.scale,
+        };
+
+        serde::Serialize::serialize(&buffer, serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Transform {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+        let buffer: TransformSerdeBuffer = serde::Deserialize::deserialize(deserializer)?;
+
+        Ok(Self {
+            position: buffer.position,
+            rotation: buffer.rotation,
+            scale: buffer.scale,
+            model_matrix: Mat4::identity(),
+            normal_matrix: Mat3::identity(),
+            bind_group: None,
+            model_mat_buffer: None,
+            normal_mat_buffer: None,
+            model_dirty: true,
+            buffers_dirty: true,
+        })
+    }
+}
+
+impl Component for Transform {
+    type DeContext<'a> = ();
+    type SerContext<'a> = ();
+
+    fn deserialise<'de, D>(_context: Self::DeContext<'de>, deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+        serde::Deserialize::deserialize(deserializer)
+    }
+
+    fn serialize<'se, S>(&self, _context: Self::SerContext<'se>, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer {
+        serde::Serialize::serialize(self, serializer)
+    }
+}
 
 impl Transform {
     pub fn new() -> Self {

cobalt_core/src/renderer/camera.rs

@@ -1,12 +1,14 @@
 use cobalt_ecs::component::Component;
+use cobalt_graphics::context::Graphics;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub enum AspectRatio {
     Value(f32),
     Auto,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Projection {
     Perspective {
         /// Field of view in radians.
@@ -20,6 +22,7 @@ pub enum Projection {
     },
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Camera {
     pub enabled: bool,
     last_aspect_ratio: f32,
@@ -28,7 +31,24 @@ pub struct Camera {
     matrix_dirty: bool,
 }
 
-impl Component for Camera {}
+impl Component for Camera {
+    type SerContext<'a> = ();
+
+    fn serialize<'se, S>(&self, _context: Self::SerContext<'se>, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer {
+        serde::Serialize::serialize(&self, serializer)
+    }
+
+    type DeContext<'a> = ();
+
+    fn deserialise<'de, D>(_context: Self::DeContext<'de>, deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+        let camera: Camera = serde::Deserialize::deserialize(deserializer)?;
+        Ok(camera)
+    }
+}
 
 impl Camera {
     pub fn new(enabled: bool, projection: Projection) -> Self {

cobalt_core/src/renderer/deferred/material/mod.rs

@@ -1,5 +1,6 @@
 use std::sync::{atomic::AtomicUsize, Arc, Weak};
 
+use cobalt_ecs::exports::Component;
 use parking_lot::RwLock;
 use wgpu::util::DeviceExt;
 
@@ -9,7 +10,7 @@ use crate::{
 };
 use cobalt_assets::{
     asset::AssetFileSystemType,
-    exports::{Asset, AssetTrait},
+    exports::{Asset, AssetTrait}, server::AssetServer,
 };
 use cobalt_graphics::{
     context::Graphics,
@@ -51,6 +52,23 @@ pub struct Material {
     graphics_weak_ref: Weak<RwLock<Graphics>>,
 }
 
+impl Component for Material {
+    type DeContext<'a> = (&'a Graphics, &'a mut AssetServer);
+    type SerContext<'a> = ();
+
+    fn deserialise<'de, D>(context: Self::DeContext<'de>, deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+        todo!()
+    }
+
+    fn serialize<'se, S>(&self, context: Self::SerContext<'se>, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer {
+        todo!()
+    }
+}
+
 impl std::fmt::Debug for Material {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct(format!("Material [id: {}]", self.id).as_str())

cobalt_core/src/renderer/frame_data.rs

@@ -1,3 +1,4 @@
+use cobalt_ecs::exports::Component;
 use wgpu::TextureView;
 
 use super::{proj_view::ProjView, renderable::Renderable, renderer::FramePrepError};
@@ -29,7 +30,7 @@ pub struct FrameData<'a, M: ResourceTrait + Ord> {
     pub render_data_vec: Vec<RenderData<'a, M>>,
 }
 
-impl<'a, M: ResourceTrait + AssetTrait + Ord> FrameData<'a, M> {
+impl<'a, M: ResourceTrait + AssetTrait + Ord + Component> FrameData<'a, M> {
     /// Generates a list of `RenderData` from the world. It also performs other processing
     /// such as frustum culling and sorting by material.
     pub fn generate(
@@ -44,12 +45,12 @@ impl<'a, M: ResourceTrait + AssetTrait + Ord> FrameData<'a, M> {
             .query_mut::<(
                 Transform,
                 Renderable,
-                Optional<Resource<M>>,
                 Optional<Asset<M>>,
+                Optional<Resource<M>>,
             )>()
             .map_err(|_| FramePrepError::NoRenderables)?;
 
-        renderable_query.map(|(ent, (transform, renderable, resource_material, asset_material))| {
+        renderable_query.map(|(ent, (transform, renderable, material_asset, material_resource))| {
             // TODO: Normal matrix being calculated every frame, is this necessary?
             transform.calculate_normal_matrix(proj_view.view());
 
@@ -61,16 +62,16 @@ impl<'a, M: ResourceTrait + AssetTrait + Ord> FrameData<'a, M> {
                 // TODO: Is it faster to clone the `Resource` or take a reference to it?
                 material: {
                     // NOTE: Resource components take precedence over Asset components
-                    if let Some(resource) = resource_material {
+                    if let Some(resource) = material_resource {
                         #[cfg(debug_assertions)]
                         {
-                            if asset_material.is_some() {
+                            if material_asset.is_some() {
                                 log_once::warn_once!("Entity {:?} has both a resource and an asset material. The resource takes precedence and will be used.", ent);
                             }
                         }
 
                         resource.clone()
-                    } else if let Some(asset) = asset_material {
+                    } else if let Some(asset) = material_asset {
                         asset.clone().into()
                     } else {
                         return Err(FramePrepError::NoMaterial(ent))

cobalt_core/src/renderer/mod.rs

@@ -33,5 +33,5 @@ pub mod exports {
     // They are also allowed to export any other types they need, but some are required.
 
     #[cfg(feature = "deferred_renderer")]
-    pub use super::deferred::exports::*;
+    pub use super::deferred::exports as deferred;
 }

cobalt_core/src/renderer/render_pass.rs

@@ -1,4 +1,4 @@
-use super::renderer::RendererError;
+use super::{deferred::exports::Material, renderer::RendererError};
 
 /// The RenderPass should not alter FrameData.
 /// They are only mutable to allow for bind groups to be updated.
@@ -14,7 +14,8 @@ pub trait RenderPass<T> {
         &mut self,
         frame: &mut cobalt_graphics::frame::Frame,
         graphics: &cobalt_graphics::context::Graphics,
-        frame_data: &mut crate::renderer::FrameData<crate::renderer::exports::Material>,
+        // TODO: Make this material generic
+        frame_data: &mut crate::renderer::FrameData<Material>,
         extra_data: T,
     ) -> Result<(), RendererError>;