material parser

4 files changed, 116 insertions, 21 deletions

diff --git a/src/classes/gameobject.rs b/src/classes/gameobject.rs
index d629231..494f3db 100644
--- a/src/classes/gameobject.rs
+++ b/src/classes/gameobject.rs
@@ -19,11 +19,7 @@ impl FromValue for GameObject {
             components: fields
                 .remove("m_Component")
                 .unwrap()
-                .as_class("vector")
-                .unwrap()
-                .remove("Array")
-                .unwrap()
-                .as_array()
+                .as_vector()
                 .unwrap()
                 .into_iter()
                 .map(|e| {
diff --git a/src/classes/material.rs b/src/classes/material.rs
new file mode 100644
index 0000000..354e319
--- /dev/null
+++ b/src/classes/material.rs
@@ -0,0 +1,70 @@
+use super::{pptr::PPtr, texture2d::Texture2D, vectors::ColorRGBA};
+use crate::object::{Value, parser::FromValue};
+use glam::Vec2;
+use serde::Serialize;
+use std::collections::BTreeMap;
+
+#[derive(Debug, Serialize)]
+pub struct Material {
+    pub name: String,
+    pub shader: PPtr<Shader>,
+    pub properties: UnityPropertySheet,
+    pub lightmap_flags: u32,
+    pub double_sided_gi: bool,
+    pub custom_render_queue: i32,
+    pub enable_instancing_variants: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub struct UnityPropertySheet {
+    pub colors: BTreeMap<String, ColorRGBA>,
+    pub floats: BTreeMap<String, f32>,
+    pub textures: BTreeMap<String, UnityTexEnv>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct UnityTexEnv {
+    pub offset: Vec2,
+    pub scale: Vec2,
+    pub texture: PPtr<Texture2D>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Shader {}
+
+impl FromValue for Material {
+    fn from_value(v: Value) -> anyhow::Result<Self> {
+        let mut fields = v.as_class("Material")?;
+        Ok(Self {
+            custom_render_queue: fields.field("m_CustomRenderQueue")?,
+            double_sided_gi: fields.field("m_DoubleSidedGI")?,
+            properties: fields.field("m_SavedProperties")?,
+            enable_instancing_variants: fields.field("m_EnableInstancingVariants")?,
+            lightmap_flags: fields.field("m_LightmapFlags")?,
+            name: fields.field("m_Name")?,
+            shader: fields.field("m_Shader")?,
+        })
+    }
+}
+
+impl FromValue for UnityPropertySheet {
+    fn from_value(v: Value) -> anyhow::Result<Self> {
+        let mut fields = v.as_class("UnityPropertySheet")?;
+        Ok(Self {
+            colors: fields.field("m_Colors")?,
+            floats: fields.field("m_Floats")?,
+            textures: fields.field("m_TexEnvs")?,
+        })
+    }
+}
+
+impl FromValue for UnityTexEnv {
+    fn from_value(v: Value) -> anyhow::Result<Self> {
+        let mut fields = v.as_class("UnityTexEnv")?;
+        Ok(Self {
+            offset: fields.field("m_Offset")?,
+            scale: fields.field("m_Scale")?,
+            texture: fields.field("m_Texture")?,
+        })
+    }
+}
diff --git a/src/classes/mod.rs b/src/classes/mod.rs
index 038e701..52ed401 100644
--- a/src/classes/mod.rs
+++ b/src/classes/mod.rs
@@ -1,5 +1,6 @@
 pub mod assetinfo;
 pub mod gameobject;
+pub mod material;
 pub mod mesh;
 pub mod pptr;
 pub mod streaminginfo;
@@ -11,7 +12,8 @@ use crate::object::{Value, parser::FromValue};
 use anyhow::Result;
 use assetinfo::AssetInfo;
 use gameobject::GameObject;
-use mesh::{ChannelInfo, Mesh, SubMesh, VertexData};
+use material::Material;
+use mesh::Mesh;
 use pptr::PPtr;
 use serde::Serialize;
 use std::collections::BTreeMap;
@@ -25,12 +27,10 @@ pub enum HValue {
     GameObject(GameObject),
     Transform(Transform),
     PPtr(PPtr),
-    Texture2D(Texture2D),
     StreamingInfo(StreamingInfo),
-    SubMesh(SubMesh),
+    Texture2D(Texture2D),
     Mesh(Mesh),
-    VertexData(VertexData),
-    ChannelInfo(ChannelInfo),
+    Material(Material),
 
     Pair(Box<HValue>, Box<HValue>),
     Value([Value; 1]),
@@ -53,11 +53,8 @@ impl HValue {
                     "GameObject" => Self::GameObject(GameObject::from_value(value)?),
                     "Transform" => Self::Transform(Transform::from_value(value)?),
                     "Texture2D" => Self::Texture2D(Texture2D::from_value(value)?),
-                    // "StreamingInfo" => Self::StreamingInfo(StreamingInfo::from_value(value)?),
-                    // "SubMesh" => Self::SubMesh(SubMesh::from_value(value)?),
-                    // "Mesh" => Self::Mesh(Mesh::from_value(value)?),
-                    // "VertexData" => Self::VertexData(VertexData::from_value(value)?),
-                    // "ChannelInfo" => Self::ChannelInfo(ChannelInfo::from_value(value)?),
+                    "Mesh" => Self::Mesh(Mesh::from_value(value)?),
+                    "Material" => Self::Material(Material::from_value(value)?),
                     _ => Self::Value([value]),
                 }
             }
diff --git a/src/classes/vectors.rs b/src/classes/vectors.rs
index 76760bc..14c5a59 100644
--- a/src/classes/vectors.rs
+++ b/src/classes/vectors.rs
@@ -1,14 +1,46 @@
 use crate::object::{Value, parser::FromValue};
-use glam::{Mat4, Quat, Vec3};
+use glam::{Mat4, Quat, Vec2, Vec3, Vec4};
+use serde::Serialize;
 
+impl FromValue for Vec2 {
+    fn from_value(v: Value) -> anyhow::Result<Self> {
+        let mut fields = v.as_class("Vector2f").unwrap();
+        Ok(Self::new(fields.field("x")?, fields.field("y")?))
+    }
+}
 impl FromValue for Vec3 {
     fn from_value(v: Value) -> anyhow::Result<Self> {
         let mut fields = v.as_class("Vector3f").unwrap();
-        Ok(Self {
-            x: fields.field("x")?,
-            y: fields.field("y")?,
-            z: fields.field("z")?,
-        })
+        Ok(Self::new(
+            fields.field("x")?,
+            fields.field("y")?,
+            fields.field("z")?,
+        ))
+    }
+}
+impl FromValue for Vec4 {
+    fn from_value(v: Value) -> anyhow::Result<Self> {
+        let mut fields = v.as_class("Vector4f")?;
+        Ok(Self::new(
+            fields.field("x")?,
+            fields.field("y")?,
+            fields.field("z")?,
+            fields.field("w")?,
+        ))
+    }
+}
+
+#[derive(Debug, Serialize)]
+pub struct ColorRGBA(pub Vec4);
+impl FromValue for ColorRGBA {
+    fn from_value(v: Value) -> anyhow::Result<Self> {
+        let mut fields = v.as_class("ColorRGBA")?;
+        Ok(ColorRGBA(Vec4::new(
+            fields.field("r")?,
+            fields.field("g")?,
+            fields.field("b")?,
+            fields.field("a")?,
+        )))
     }
 }