refactor(engine): simplify how model materials are handled

1 files changed, 14 insertions, 94 deletions

diff --git a/engine/src/model.rs b/engine/src/model.rs
index 60a5615..1269afd 100644
--- a/engine/src/model.rs
+++ b/engine/src/model.rs
@@ -1,9 +1,5 @@
-use std::borrow::Cow;
-use std::collections::HashMap;
-
 use crate::asset::{Assets, Handle as AssetHandle};
 use crate::ecs::Component;
-use crate::material::asset::Map as MaterialAssetMap;
 use crate::material::Material;
 use crate::mesh::Mesh;
 
@@ -29,8 +25,7 @@ impl Model
 pub struct Spec
 {
     pub mesh_asset: Option<AssetHandle<Mesh>>,
-    pub materials: Materials,
-    pub material_names: Vec<Cow<'static, str>>,
+    pub materials: Vec<MaterialDescription>,
 }
 
 impl Spec
@@ -45,31 +40,16 @@ impl Spec
         assets: &'assets Assets,
     ) -> MaterialSearchResult<'assets>
     {
-        let Some(material_name) = self.material_names.first() else {
+        let Some(material_desc) = self.materials.first() else {
             return MaterialSearchResult::NoMaterials;
         };
 
-        let material_asset = match &self.materials {
-            Materials::Maps(material_asset_map_assets) => material_asset_map_assets
-                .iter()
-                .find_map(|mat_asset_map_asset| {
-                    let mat_asset_map = assets.get(mat_asset_map_asset)?;
-
-                    mat_asset_map.assets.get(material_name)
-                }),
-            Materials::Direct(material_assets) => material_assets.get(material_name),
-        };
-
-        let Some(material_asset) = material_asset else {
-            return MaterialSearchResult::NotFound;
-        };
-
-        if assets.get(material_asset).is_none() {
+        if assets.get(&material_desc.asset).is_none() {
             tracing::trace!("Missing material asset");
             return MaterialSearchResult::NotFound;
         }
 
-        MaterialSearchResult::Found(material_asset)
+        MaterialSearchResult::Found(&material_desc.asset)
     }
 }
 
@@ -77,8 +57,7 @@ impl Spec
 pub struct SpecBuilder
 {
     mesh_asset: Option<AssetHandle<Mesh>>,
-    materials: Materials,
-    material_names: Vec<Cow<'static, str>>,
+    materials: Vec<MaterialDescription>,
 }
 
 impl SpecBuilder
@@ -90,29 +69,12 @@ impl SpecBuilder
         self
     }
 
-    pub fn materials(mut self, materials: Materials) -> Self
-    {
-        self.materials = materials;
-
-        self
-    }
-
-    pub fn material_name(mut self, material_name: impl Into<Cow<'static, str>>) -> Self
-    {
-        self.material_names.push(material_name.into());
-
-        self
-    }
-
-    pub fn material_names<MaterialName>(
+    pub fn materials(
         mut self,
-        material_names: impl IntoIterator<Item = MaterialName>,
+        materials: impl IntoIterator<Item = MaterialDescription>,
     ) -> Self
-    where
-        MaterialName: Into<Cow<'static, str>>,
     {
-        self.material_names
-            .extend(material_names.into_iter().map(|mat_name| mat_name.into()));
+        self.materials = materials.into_iter().collect();
 
         self
     }
@@ -120,67 +82,25 @@ impl SpecBuilder
     #[tracing::instrument(skip_all)]
     pub fn build(self) -> Spec
     {
-        if !self.materials.is_empty() && self.material_names.is_empty() {
-            tracing::warn!("Model spec will have materials but no material names");
-        }
-
-        if self.materials.is_empty() && !self.material_names.is_empty() {
-            tracing::warn!("Model spec will have material names but no materials");
-        }
-
         Spec {
             mesh_asset: self.mesh_asset,
             materials: self.materials,
-            material_names: self.material_names,
         }
     }
 }
 
 #[derive(Debug, Clone)]
-pub enum Materials
-{
-    Direct(HashMap<Cow<'static, str>, AssetHandle<Material>>),
-    Maps(Vec<AssetHandle<MaterialAssetMap>>),
-}
-
-impl Materials
+#[non_exhaustive]
+pub struct MaterialDescription
 {
-    pub fn direct<MaterialName>(
-        material_assets: impl IntoIterator<Item = (MaterialName, AssetHandle<Material>)>,
-    ) -> Self
-    where
-        MaterialName: Into<Cow<'static, str>>,
-    {
-        Self::Direct(
-            material_assets
-                .into_iter()
-                .map(|(material_name, mat_asset)| (material_name.into(), mat_asset))
-                .collect(),
-        )
-    }
-
-    pub fn is_empty(&self) -> bool
-    {
-        match self {
-            Self::Direct(material_assets) => material_assets.is_empty(),
-            Self::Maps(material_asset_map_assets) => material_asset_map_assets.is_empty(),
-        }
-    }
-
-    pub fn len(&self) -> usize
-    {
-        match self {
-            Self::Direct(material_assets) => material_assets.len(),
-            Self::Maps(material_asset_map_assets) => material_asset_map_assets.len(),
-        }
-    }
+    pub asset: AssetHandle<Material>,
 }
 
-impl Default for Materials
+impl MaterialDescription
 {
-    fn default() -> Self
+    pub fn new(asset: AssetHandle<Material>) -> Self
     {
-        Self::Maps(Vec::new())
+        Self { asset }
     }
 }