Add support for tracking Meshes and Images.

Author: BGR360

Cargo.toml

@@ -4,5 +4,48 @@ version = "0.0.1"
 edition = "2021"
 
 [dependencies]
-bevy = { version = "0.6", default-features = false, features = [] }
+bevy = { version = "0.6", default-features = false }
 datasize = "0.2"
+
+[dev-dependencies]
+maplit = "1"
+
+[features]
+default = [
+    "render"
+]
+
+# Enables support for tracking Bevy render resources.
+render = [
+    "mesh",
+    "image",
+]
+# Enables support for tracking `Mesh`.
+mesh = ["bevy_render"]
+# Enables support for tracking `Image`.
+image = ["bevy_render"]
+
+# Features required to run all the examples
+examples = [
+    "bevy_render_all",
+    "bevy_png",
+    "bevy_winit",
+]
+
+# Forwarded bevy features
+bevy_pbr = ["bevy/bevy_pbr"]
+bevy_png = ["bevy/png"]
+bevy_render_all = ["bevy/render"]
+bevy_render = ["bevy/bevy_render"]
+bevy_winit = ["bevy/bevy_winit"]
+
+[[example]]
+name = "custom_types"
+
+[[example]]
+name = "render_resources"
+required-features = [
+    "bevy_render_all",
+    "bevy_png",
+    "bevy_winit"
+]

README.md

@@ -20,7 +20,42 @@ See the [`datasize`] docs for more info on that.
 Rustdocs for the main branch can be found
 [here](https://bgr360.github.io/bevy_datasize/bevy_datasize/)
 
-## Example
+## Examples
+
+### Basic Usage
+
+The following example demonstrates how to show the memory usage of all loaded
+`Image`s:
+
+```rust,no_run
+use bevy::prelude::*;
+use bevy_datasize::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugin(DefaultMemoryUsagePlugins)
+        .add_system(print_image_usage)
+        .run();
+}
+
+fn print_image_usage(memory_usage: Res<MemoryUsage>) {
+    let MemoryStats {
+        count,
+        total_stack_bytes,
+        total_heap_bytes,
+    } = memory_usage.get_stats::<Image>().unwrap();
+
+    println!("Image count: {count}");
+    println!("Total stack usage: {total_stack_bytes} bytes");
+    println!("Total heap usage: {total_heap_bytes} bytes");
+}
+```
+
+### Custom Data Types
+
+The following example demonstrates how to track memory usage for a custom
+`Component` type when using minimal plugins:
 
 ```rust,no_run
 use bevy::prelude::*;
@@ -36,11 +71,11 @@ fn main() {
         .add_plugins(MinimalPlugins)
         .add_plugin(MemoryUsagePlugin)
         .register_sized_component::<MyComponent>()
-        .add_system(print_datasize)
+        .add_system(print_custom_usage)
         .run();
 }
 
-fn print_datasize(memory_usage: Res<MemoryUsage>) {
+fn print_custom_usage(memory_usage: Res<MemoryUsage>) {
     let MemoryStats {
         count,
         total_stack_bytes,
@@ -53,6 +88,10 @@ fn print_datasize(memory_usage: Res<MemoryUsage>) {
 }
 ```
 
+### More
+
+See the [`examples`](examples/) directory for more examples.
+
 ## License
 
 Licensed under either of

assets/README.md

@@ -0,0 +1,18 @@
+# Assets
+
+These are just used for the examples.
+
+## Attribution
+
+### [`grass_0_0.png`](grass_0_0.png)
+
+Title: "Grass 001"
+
+Description: 512x512 seamless grass texture, made using CC-BY 3.0 photos from
+the Yo Frankie! DVD.
+
+Link: https://opengameart.org/node/7806
+
+No changes were made.
+
+(c) copyright Blender Foundation | apricot.blender.org

assets/grass_0_0.png

@@ -0,0 +1,7 @@
+# bevy_datasize examples
+
+To run the examples, you must enable the `examples` feature:
+
+```
+$ cargo run --features examples --example <EXAMPLE>
+```

examples/README.md

@@ -0,0 +1,58 @@
+//! This example shows demonstrates tracking memory usage for render resources
+//! like meshes, images, and materials.
+//!
+//! Adapted from the official Bevy `many_cubes` example.
+
+use bevy::prelude::*;
+use bevy_datasize::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(DefaultMemoryUsagePlugins)
+        .add_startup_system(setup)
+        .add_system(print_sizes)
+        .run();
+}
+
+fn setup(
+    asset_server: Res<AssetServer>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    const WIDTH: usize = 10;
+    const HEIGHT: usize = 10;
+    let texture = asset_server.load("grass_0_0.png");
+    let material = materials.add(StandardMaterial {
+        base_color_texture: Some(texture),
+        ..Default::default()
+    });
+    for x in 0..WIDTH {
+        for y in 0..HEIGHT {
+            // cube
+            commands.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+                material: material.clone(),
+                transform: Transform::from_xyz((x as f32) * 2.0, (y as f32) * 2.0, 0.0),
+                ..Default::default()
+            });
+        }
+    }
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(80.0, 80.0, 300.0),
+        ..Default::default()
+    });
+}
+
+fn print_sizes(memory_usage: Res<MemoryUsage>) {
+    let mesh_stats = memory_usage.get_stats::<Mesh>().unwrap();
+    let image_stats = memory_usage.get_stats::<Image>().unwrap();
+
+    println!();
+    println!("Memory usage:");
+    println!("Meshes: {:#?}", mesh_stats);
+    println!("Images: {:#?}", image_stats);
+}

examples/basic.rs examples/custom_types.rs

@@ -6,7 +6,7 @@ use bevy::{
     ecs::{component::Component, schedule::IntoSystemDescriptor, system::Resource},
 };
 
-use crate::{systems, DataSize, DataSizeEstimator, MemoryUsage};
+use crate::{estimator::ForwardingEstimator, systems, DataSize, MemoryUsage};
 
 /// [`App`] extension methods to register types for memory usage tracking.
 pub trait RegisterSizedTypes {
@@ -19,7 +19,9 @@ pub trait RegisterSizedTypes {
     where
         T: Any + DataSize + Component,
     {
-        self.register_sized_type::<T, T, _, _>(systems::update_stats_for_component::<T, T>)
+        self.register_sized_type::<T, _, _>(
+            systems::update_stats_for_component::<T, ForwardingEstimator<T>>,
+        )
     }
 
     /// Registers the given [`Resource`] type with the
@@ -31,7 +33,9 @@ pub trait RegisterSizedTypes {
     where
         T: Any + DataSize + Resource,
     {
-        self.register_sized_type::<T, T, _, _>(systems::update_stats_for_resource::<T, T>)
+        self.register_sized_type::<T, _, _>(
+            systems::update_stats_for_resource::<T, ForwardingEstimator<T>>,
+        )
     }
 
     /// Registers the given [`Asset`] type with the
@@ -43,23 +47,28 @@ pub trait RegisterSizedTypes {
     where
         T: Any + DataSize + Asset,
     {
-        self.register_sized_type::<T, T, _, _>(systems::update_stats_for_asset::<T, T>)
+        self.register_sized_type::<T, _, _>(
+            systems::update_stats_for_asset::<T, ForwardingEstimator<T>>,
+        )
     }
 
-    /// Registers a type that can be sized with the given [`DataSizeEstimator`]
-    /// type and updated using the provided `system`.
-    fn register_sized_type<T, E, S, Params>(&mut self, system: S) -> &mut Self
+    /// Registers a type whose [`MemoryStats`] will be updated with the given
+    /// `system`.
+    ///
+    /// The given type `T` will be available to query on the [`MemoryUsage`]
+    /// resource.
+    ///
+    /// [`MemoryStats`]: crate::MemoryStats
+    fn register_sized_type<T, S, Params>(&mut self, system: S) -> &mut Self
     where
         T: Any,
-        E: DataSizeEstimator<T>,
         S: IntoSystemDescriptor<Params>;
 }
 
 impl RegisterSizedTypes for App {
-    fn register_sized_type<T, E, S, Params>(&mut self, system: S) -> &mut Self
+    fn register_sized_type<T, S, Params>(&mut self, system: S) -> &mut Self
     where
         T: Any,
-        E: DataSizeEstimator<T>,
         S: IntoSystemDescriptor<Params>,
     {
         register_type::<T>(self);

examples/render_resources.rs

@@ -0,0 +1,25 @@
+//! Support for Bevy's built-in types.
+
+use bevy::app::{PluginGroup, PluginGroupBuilder};
+
+use crate::MemoryUsagePlugin;
+
+pub mod render;
+
+pub use render::RenderMemoryUsagePlugins;
+
+/// Adds memory tracking for the components, resources, and assets that are part
+/// of Bevy's [`DefaultPlugins`][bevy::prelude::DefaultPlugins].
+///
+/// This group registers the [`MemoryUsagePlugin`] as well as the following:
+///
+/// * [`RenderMemoryUsagePlugins`]
+pub struct DefaultMemoryUsagePlugins;
+
+impl PluginGroup for DefaultMemoryUsagePlugins {
+    fn build(&mut self, group: &mut PluginGroupBuilder) {
+        group.add(MemoryUsagePlugin);
+
+        RenderMemoryUsagePlugins.build(group);
+    }
+}

src/app_ext.rs

@@ -0,0 +1,27 @@
+//! Memory usage tracking for Bevy's [`Image`] type.
+use bevy::{app::Plugin, render::texture::Image};
+
+use crate::{systems, DataSize, DataSizeEstimator, RegisterSizedTypes};
+
+/// Adds memory tracking for [`Image`] assets.
+#[derive(Debug, Default)]
+pub struct ImageMemoryUsagePlugin;
+
+impl Plugin for ImageMemoryUsagePlugin {
+    fn build(&self, app: &mut bevy::prelude::App) {
+        app.register_sized_type::<Image, _, _>(
+            systems::update_stats_for_asset::<Image, ImageSizeEstimator>,
+        );
+    }
+}
+
+#[derive(Debug, Default)]
+struct ImageSizeEstimator;
+
+impl DataSizeEstimator<Image> for ImageSizeEstimator {
+    /// Returns the size of the image's data array.
+    #[inline]
+    fn estimate_heap_size(&self, image: &Image) -> usize {
+        image.data.estimate_heap_size()
+    }
+}