feat(engine): add Assets::get_status & Assets::get_status_by_id fns

1 files changed, 82 insertions, 0 deletions

diff --git a/engine/src/asset.rs b/engine/src/asset.rs
index 31d6e06..e8753bc 100644
--- a/engine/src/asset.rs
+++ b/engine/src/asset.rs
@@ -332,6 +332,88 @@ impl Assets
         Some(metadata_lut.get(&id)?.label.clone().into_label())
     }
 
+    pub fn get_status<AssetT: Asset>(&self, handle: &Handle<AssetT>) -> Status
+    {
+        self.get_status_by_id(handle.id())
+    }
+
+    pub fn get_status_by_id(&self, asset_id: Id) -> Status
+    {
+        let Some(asset_id) = asset_id.into_valid() else {
+            return Status::NotFound;
+        };
+
+        let metadata_lut = self.metadata_lut.borrow();
+
+        let Some(asset_metadata) = metadata_lut.get(&asset_id) else {
+            return Status::NotFound;
+        };
+
+        let mut is_asset_loading = false;
+
+        match &asset_metadata.state {
+            AssetState::DependenciesPending { .. } => {
+                return Status::Pending;
+            }
+            AssetState::Failed { reason, .. } => {
+                return Status::Failed(*reason);
+            }
+            AssetState::Ready => {
+                return Status::Ready;
+            }
+            AssetState::Loading => {
+                // TODO: It might be possible to just return Status::Pending here
+                // since asset states are propagated to their related assets
+                is_asset_loading = true;
+            }
+            AssetState::NotStored => {}
+        }
+
+        if matches!(asset_metadata.relation, AssetRelation::Parent { .. }) {
+            return if is_asset_loading {
+                Status::Pending
+            } else {
+                Status::NotFound
+            };
+        }
+
+        let parent_asset_state = (|| {
+            let parent_asset_id = match &asset_metadata.relation {
+                AssetRelation::Child { parent } => *parent,
+                AssetRelation::Parent { .. } => {
+                    // label.name is Some so the asset can not be a parent
+                    unreachable!()
+                }
+            };
+
+            let parent_asset_metadata = metadata_lut.get(&parent_asset_id)?;
+
+            match &parent_asset_metadata.state {
+                AssetState::Failed { reason, .. } => Some(Status::Failed(*reason)),
+                AssetState::Ready
+                | AssetState::NotStored
+                | AssetState::Loading
+                | AssetState::DependenciesPending { .. } => None,
+            }
+        })();
+
+        match parent_asset_state {
+            Some(Status::Failed(FailureReason::Dependency)) => {
+                // It would make no sense for a asset's status to be Status::Failed if the
+                // parent asset has a missing dependency
+
+                if is_asset_loading {
+                    Status::Pending
+                } else {
+                    Status::NotFound
+                }
+            }
+            Some(parent_asset_state) => parent_asset_state,
+            None if is_asset_loading => Status::Pending,
+            None => Status::NotFound,
+        }
+    }
+
     pub fn get_status_by_label(&self, label: &Label<'_>) -> Status
     {
         let id_lut = self.id_lut.borrow();