More accurate component, entity and resouce shallow size calculation (#33)

* Take `Entity` size into account

* Use `Layout` to measure component size

* Refactor `inspect_component_by_id`

* Make `ComponentInspection::memory_size` non-optional

* Use `ComponentId`'s `Layout` to calculate `Resource` size

* Update docs

Author: Nilirad

src/extension_methods.rs

@@ -194,8 +194,10 @@ impl WorldInspectionExtensionTrait for World {
 
             let total_bytes = components
                 .iter()
-                .filter_map(|comp| comp.memory_size.as_ref())
-                .fold(0usize, |acc, size| acc + size.as_bytes());
+                .map(|comp| comp.memory_size)
+                .fold(std::mem::size_of::<Entity>(), |acc, size| {
+                    acc + size.as_bytes()
+                });
             let total_memory_size = MemorySize::new(total_bytes);
 
             (Some(components), Some(total_memory_size))
@@ -248,28 +250,26 @@ impl WorldInspectionExtensionTrait for World {
         let component_info = self.components().get_info(component_id).ok_or(
             ComponentInspectionError::ComponentIdNotRegistered(component_id),
         )?;
+        let memory_size = MemorySize::new(component_info.layout().size());
 
         if !self.entity(entity).contains_id(component_id) {
             return Err(ComponentInspectionError::ComponentNotFound(component_id));
         }
 
         let name = component_info.name();
 
-        let (value, memory_size) = if settings.detail_level == ComponentDetailLevel::Names {
-            (None, None)
+        let value = if settings.detail_level == ComponentDetailLevel::Names {
+            None
         } else {
             match metadata.type_id {
                 Some(type_id) => match get_reflected_component_ref(self, entity, type_id) {
-                    Ok(reflected) => (
-                        Some(reflected_value_to_string(
-                            reflected,
-                            settings.full_type_names,
-                        )),
-                        Some(MemorySize::new(size_of_val(reflected))),
-                    ),
-                    Err(err) => (Some(format!("<Unreflectable: {}>", err)), None),
+                    Ok(reflected) => Some(reflected_value_to_string(
+                        reflected,
+                        settings.full_type_names,
+                    )),
+                    Err(err) => Some(format!("<Unreflectable: {}>", err)),
                 },
-                None => (Some("Dynamic Type".to_string()), None),
+                None => Some("Dynamic Type".to_string()),
             }
         };
 
@@ -317,6 +317,7 @@ impl WorldInspectionExtensionTrait for World {
             .components()
             .get_info(component_id)
             .ok_or(ResourceInspectionError::ResourceNotFound(component_id))?;
+        let memory_size = MemorySize::new(component_info.layout().size());
 
         let name = component_info.name();
         let type_id = component_info.type_id();
@@ -327,15 +328,13 @@ impl WorldInspectionExtensionTrait for World {
             None => None,
         };
 
-        let (value, memory_size) = match type_id {
+        let value = match type_id {
             Some(type_id) => match get_reflected_resource_ref(self, type_id) {
-                Ok(reflected) => (
-                    reflected_value_to_string(reflected, settings.full_type_names),
-                    Some(MemorySize::new(size_of_val(reflected))),
-                ),
-                Err(err) => (format!("<Unreflectable: {}>", err), None),
+                Ok(reflected) => reflected_value_to_string(reflected, settings.full_type_names),
+
+                Err(err) => format!("<Unreflectable: {}>", err),
             },
-            None => ("Dynamic Type".to_string(), None),
+            None => "Dynamic Type".to_string(),
         };
 
         Ok(ResourceInspection {

src/gui/panels/object_list.rs

@@ -207,7 +207,7 @@ fn generate_resource_list(world: &mut World) -> Vec<ObjectListEntry> {
             ObjectListEntry::Resource {
                 component_id: inspection.component_id,
                 display_name: name.to_string(),
-                memory_size: inspection.memory_size.unwrap_or(MemorySize::new(0)),
+                memory_size: inspection.memory_size,
             }
         })
         .collect()

src/inspection/component_inspection.rs

@@ -40,15 +40,11 @@ pub struct ComponentInspection {
         serde(with = "crate::serde_conversions::debug_name")
     )]
     pub name: DebugName,
-    /// The size, in bytes, of the component value.
+    /// The shallow size of the component in memory.
     ///
     /// Note that this may differ from the size of the component type
     /// if the component is a dynamically-sized type: heap-allocated data is not included.
-    ///
-    /// Computing this value requires reflection of the component value.
-    /// As a result, it may be `None` if the component type is not reflected and registered,
-    /// or if [`ComponentDetailLevel::Names`] was specified when inspecting the component.
-    pub memory_size: Option<MemorySize>,
+    pub memory_size: MemorySize,
     /// The value of the component as a string.
     ///
     /// This information is gathered via reflection,
@@ -61,14 +57,8 @@ impl Display for ComponentInspection {
         let shortname = self.name.shortname();
 
         match &self.value {
-            Some(value) => match &self.memory_size {
-                Some(size) => write!(f, "{shortname} ({}): {value}", size)?,
-                None => write!(f, "{shortname}: {value}")?,
-            },
-            None => match &self.memory_size {
-                Some(size) => write!(f, "{shortname} ({})", size)?,
-                None => write!(f, "{shortname}")?,
-            },
+            Some(value) => write!(f, "{shortname} ({}): {value}", &self.memory_size)?,
+            None => write!(f, "{shortname} ({})", &self.memory_size)?,
         }
 
         Ok(())

src/inspection/resource_inspection.rs

@@ -36,10 +36,11 @@ pub struct ResourceInspection {
     /// Note that dynamic types will not have a [`TypeId`].
     #[cfg_attr(feature = "serde", serde(skip))]
     pub type_id: Option<TypeId>,
-    /// The size of the resource in memory.
+    /// The shallow size of the resource in memory.
     ///
-    /// This is computed using [`core::mem::size_of_val`], and requires reflection of the resource value.
-    pub memory_size: Option<MemorySize>,
+    /// Note that this may differ from the size of the resource type
+    /// if it is a dynamically-sized: heap-allocated data is not included.
+    pub memory_size: MemorySize,
     /// The type information of the resource.
     ///
     /// This contains metadata about the resource's type,
@@ -59,10 +60,7 @@ pub struct ResourceInspection {
 impl Display for ResourceInspection {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let short_name = self.name.shortname();
-        match &self.memory_size {
-            Some(size) => write!(f, "{} ({}): {}", short_name, size, self.value)?,
-            None => write!(f, "{}: {}", short_name, self.value)?,
-        }
+        write!(f, "{} ({}): {}", short_name, self.memory_size, self.value)?;
 
         Ok(())
     }