From 36c3860ddf47c1c7c2ccad43512091d20f5a2dff Mon Sep 17 00:00:00 2001
From: HampusM <hampus@hampusmat.com>
Date: Mon, 28 Sep 2026 22:58:05 +0200
Subject: refactor(engine): make model & material assets use asset dependencies

---
 engine/src/model.rs | 167 ++++++++++++++++++++++++++--------------------------
 1 file changed, 83 insertions(+), 84 deletions(-)

(limited to 'engine/src/model.rs')

diff --git a/engine/src/model.rs b/engine/src/model.rs
index 220e4f6..c231a9f 100644
--- a/engine/src/model.rs
+++ b/engine/src/model.rs
@@ -1,125 +1,124 @@
-use crate::asset::{Asset, Assets, Handle as AssetHandle};
+use crate::asset::{
+    Asset,
+    Assets,
+    Dependency as AssetDependency,
+    Event as AssetEvent,
+    Events as AssetEvents,
+    Handle as AssetHandle,
+    Label as AssetLabel,
+};
+use crate::ecs::sole::Single;
 use crate::ecs::Component;
 use crate::material::Material;
 use crate::mesh::Mesh;
 
 pub mod asset;
 
-#[derive(Debug, Clone, Component)]
+#[derive(Debug, Default)]
 #[non_exhaustive]
-pub struct Model
-{
-    pub spec_asset: AssetHandle<Spec>,
-}
+pub struct Model {}
 
-impl Model
+impl Asset for Model
 {
-    #[must_use]
-    pub fn new(asset_handle: AssetHandle<Spec>) -> Self
+    fn dependencies(&self) -> impl Iterator<Item = AssetDependency<'_>>
     {
-        Self { spec_asset: asset_handle }
+        [].into_iter()
     }
 }
 
+#[derive(Debug, Clone, Component)]
+#[allow(clippy::module_name_repetitions)]
+pub struct ModelMesh
+{
+    pub asset: AssetHandle<Mesh>,
+}
+
+#[derive(Debug, Clone, Component)]
+#[allow(clippy::module_name_repetitions)]
+pub struct ModelMaterial
+{
+    pub asset: AssetHandle<MaterialDescription>,
+}
+
 #[derive(Debug, Clone)]
 #[non_exhaustive]
-pub struct Spec
+pub struct MaterialDescription
 {
-    pub mesh_asset: Option<AssetHandle<Mesh>>,
-    pub materials: Vec<MaterialDescription>,
+    pub asset: AssetHandle<Material>,
+    pub loading_material: Option<AssetLabel<'static>>,
 }
 
-impl Spec
+impl MaterialDescription
 {
     #[must_use]
-    pub fn builder() -> SpecBuilder
+    pub fn new(asset: AssetHandle<Material>) -> Self
     {
-        SpecBuilder::default()
+        Self { asset, loading_material: None }
     }
 
-    pub fn find_first_material<'assets>(
-        &'assets self,
-        assets: &'assets Assets,
-    ) -> MaterialSearchResult<'assets>
+    #[must_use]
+    pub fn with_loading_material(mut self, loading_material: AssetLabel<'static>)
+        -> Self
     {
-        let Some(material_desc) = self.materials.first() else {
-            return MaterialSearchResult::NoMaterials;
-        };
-
-        if assets.get(&material_desc.asset).is_none() {
-            tracing::trace!("Missing material asset");
-            return MaterialSearchResult::NotFound;
-        }
-
-        MaterialSearchResult::Found(&material_desc.asset)
+        self.loading_material = Some(loading_material);
+        self
     }
 }
 
-impl Asset for Spec
+impl Asset for MaterialDescription
 {
-    fn dependencies(&self) -> impl Iterator<Item = crate::asset::Dependency<'_>>
+    fn dependencies(&self) -> impl Iterator<Item = AssetDependency<'_>>
     {
-        [].into_iter()
+        self.loading_material.iter().map(|material_label| {
+            AssetDependency::new::<Material>(AssetLabel {
+                path: (&*material_label.path).into(),
+                name: material_label.name.as_deref().map(Into::into),
+            })
+        })
     }
 }
 
-#[derive(Debug, Default, Clone)]
-pub struct SpecBuilder
+pub(crate) fn set_stored_mat_descs_handles(
+    mut assets: Single<Assets>,
+    asset_events: Single<AssetEvents>,
+)
 {
-    mesh_asset: Option<AssetHandle<Mesh>>,
-    materials: Vec<MaterialDescription>,
-}
+    let assets = assets.get_mut().unwrap();
+    let asset_events = asset_events.get().unwrap();
 
-impl SpecBuilder
-{
-    #[must_use]
-    pub fn mesh(mut self, asset: AssetHandle<Mesh>) -> Self
-    {
-        self.mesh_asset = Some(asset);
+    for AssetEvent::Stored(asset_id, ..) in asset_events.iter_last_tick() {
+        let asset_handle = AssetHandle::<MaterialDescription>::from_id(*asset_id);
 
-        self
-    }
-
-    #[must_use]
-    pub fn materials(
-        mut self,
-        materials: impl IntoIterator<Item = MaterialDescription>,
-    ) -> Self
-    {
-        self.materials = materials.into_iter().collect();
+        if !assets.is_loaded_and_has_type(&asset_handle) {
+            continue;
+        }
 
-        self
-    }
+        let material_asset = {
+            let Some(material_desc) = assets.get(&asset_handle) else {
+                unreachable!();
+            };
+
+            if let Some(material_label) = &material_desc.loading_material {
+                let Some(material_asset) =
+                    assets.get_handle_to_loaded::<Material>(material_label.clone())
+                else {
+                    unreachable!();
+                };
+
+                Some(material_asset)
+            } else {
+                None
+            }
+        };
 
-    #[tracing::instrument(skip_all)]
-    pub fn build(self) -> Spec
-    {
-        Spec {
-            mesh_asset: self.mesh_asset,
-            materials: self.materials,
-        }
-    }
-}
+        let Some(material_asset) = material_asset else {
+            continue;
+        };
 
-#[derive(Debug, Clone)]
-#[non_exhaustive]
-pub struct MaterialDescription
-{
-    pub asset: AssetHandle<Material>,
-}
+        let Some(material_desc) = assets.get_mut(&asset_handle) else {
+            unreachable!();
+        };
 
-impl MaterialDescription
-{
-    #[must_use]
-    pub fn new(asset: AssetHandle<Material>) -> Self
-    {
-        Self { asset }
+        material_desc.asset = material_asset;
     }
 }
-
-pub enum MaterialSearchResult<'a>
-{
-    Found(&'a AssetHandle<Material>),
-    NotFound,
-    NoMaterials,
-}
-- 
cgit v1.2.3-18-g5258