bevy_remote

Cargo.toml

@@ -66,6 +66,7 @@ default = [
   "bevy_sprite",
   "bevy_text",
   "bevy_ui",
+  "bevy_remote",
   "multi-threaded",
   "png",
   "hdr",
@@ -135,6 +136,12 @@ bevy_ui = [
   "bevy_sprite",
 ]
 
+# Provides remote inspection functionality
+bevy_remote = ["serialize", "bevy_internal/bevy_remote"]
+
+# Provides remote inspection functionality over HTTP
+remote_http = ["bevy_remote", "bevy_internal/remote_http"]
+
 # winit window and input backend
 bevy_winit = ["bevy_internal/bevy_winit"]
 
@@ -2643,6 +2650,18 @@ description = "Demonstrates creating and using custom Ui materials"
 category = "UI (User Interface)"
 wasm = true
 
+[[example]]
+name = "remote_http"
+path = "examples/remote/http.rs"
+doc-scrape-examples = true
+required-features = ["remote_http"]
+
+[package.metadata.example.remote_http]
+name = "Remote via HTTP"
+description = "Demonstrate the use of the Remote plugin with HTTP"
+category = "Remote"
+wasm = false
+
 [[example]]
 name = "render_primitives"
 path = "examples/math/render_primitives.rs"

crates/bevy_asset/src/handle.rs

@@ -3,9 +3,10 @@ use crate::{
     UntypedAssetId,
 };
 use bevy_ecs::prelude::*;
-use bevy_reflect::{Reflect, TypePath};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect, ReflectSerialize, TypePath};
 use bevy_utils::{get_short_name, Uuid};
 use crossbeam_channel::{Receiver, Sender};
+use serde::Serialize;
 use std::{
     any::TypeId,
     hash::{Hash, Hasher},
@@ -121,7 +122,7 @@ impl std::fmt::Debug for StrongHandle {
 ///
 /// [`Handle::Strong`] also provides access to useful [`Asset`] metadata, such as the [`AssetPath`] (if it exists).
 #[derive(Component, Reflect)]
-#[reflect(Component)]
+#[reflect(Component, Serialize, Default)]
 pub enum Handle<A: Asset> {
     /// A "strong" reference to a live (or loading) [`Asset`]. If a [`Handle`] is [`Handle::Strong`], the [`Asset`] will be kept
     /// alive until the [`Handle`] is dropped. Strong handles also provide access to additional asset metadata.
@@ -131,6 +132,22 @@ pub enum Handle<A: Asset> {
     Weak(AssetId<A>),
 }
 
+impl<A: Asset> Serialize for Handle<A> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let Handle::Weak(id) = self.clone_weak() else {
+            // `.clone_weak()` will always return a weak handle
+            unreachable!();
+        };
+
+        // Always serialize as a weak handle, as the asset is not guaranteed to be alive
+        // when we later deserialize this handle.
+        serializer.serialize_newtype_variant(std::any::type_name::<Self>(), 1, "Weak", &id)
+    }
+}
+
 impl<T: Asset> Clone for Handle<T> {
     fn clone(&self) -> Self {
         match self {

crates/bevy_asset/src/id.rs

@@ -1,7 +1,7 @@
 use crate::{Asset, AssetIndex};
-use bevy_reflect::Reflect;
+use bevy_reflect::{Reflect, ReflectSerialize};
 use bevy_utils::Uuid;
-
+use serde::Serialize;
 use std::{
     any::TypeId,
     fmt::{Debug, Display},
@@ -16,7 +16,8 @@ use thiserror::Error;
 /// For an identifier tied to the lifetime of an asset, see [`Handle`](`crate::Handle`).
 ///
 /// For an "untyped" / "generic-less" id, see [`UntypedAssetId`].
-#[derive(Reflect)]
+#[derive(Reflect, Serialize)]
+#[reflect(Serialize)]
 pub enum AssetId<A: Asset> {
     /// A small / efficient runtime identifier that can be used to efficiently look up an asset stored in [`Assets`]. This is
     /// the "default" identifier used for assets. The alternative(s) (ex: [`AssetId::Uuid`]) will only be used if assets are
@@ -26,6 +27,7 @@ pub enum AssetId<A: Asset> {
     Index {
         index: AssetIndex,
         #[reflect(ignore)]
+        #[serde(skip)]
         marker: PhantomData<fn() -> A>,
     },
     /// A stable-across-runs / const asset identifier. This will only be used if an asset is explicitly registered in [`Assets`]

crates/bevy_asset/src/lib.rs

@@ -228,6 +228,8 @@ impl Plugin for AssetPlugin {
         let mut order = app.world.resource_mut::<MainScheduleOrder>();
         order.insert_after(First, UpdateAssets);
         order.insert_after(PostUpdate, AssetEvents);
+
+        app.register_type::<AssetIndex>();
     }
 }
 

crates/bevy_ecs/src/storage/resource.rs

@@ -50,10 +50,7 @@ impl<const SEND: bool> ResourceData<SEND> {
     /// If `SEND` is false, this will panic if called from a different thread than the one it was inserted from.
     #[inline]
     fn validate_access(&self) {
-        if SEND {
-            return;
-        }
-        if self.origin_thread_id != Some(std::thread::current().id()) {
+        if !self.can_access() {
             // Panic in tests, as testing for aborting is nearly impossible
             panic!(
                 "Attempted to access or drop non-send resource {} from thread {:?} on a thread {:?}. This is not allowed. Aborting.",
@@ -64,6 +61,18 @@ impl<const SEND: bool> ResourceData<SEND> {
         }
     }
 
+    /// Returns whether the current thread can access a resource or not:
+    ///
+    /// - For `!Send` resources, this will return `true` if the current thread is the same as the one it was inserted from;
+    /// - For `Send` resources, this will always return `true`.
+    #[inline]
+    pub fn can_access(&self) -> bool {
+        if SEND {
+            return true;
+        }
+        self.origin_thread_id == Some(std::thread::current().id())
+    }
+
     /// Returns true if the resource is populated.
     #[inline]
     pub fn is_present(&self) -> bool {

crates/bevy_ecs/src/world/mod.rs

@@ -27,7 +27,7 @@ use crate::{
     query::{DebugCheckedUnwrap, QueryData, QueryEntityError, QueryFilter, QueryState},
     removal_detection::RemovedComponentEvents,
     schedule::{Schedule, ScheduleLabel, Schedules},
-    storage::{ResourceData, Storages},
+    storage::{ResourceData, Resources, Storages},
     system::{Res, Resource},
     world::error::TryRunScheduleError,
 };
@@ -2040,6 +2040,79 @@ impl World {
         self.storages.resources.clear();
         self.storages.non_send_resources.clear();
     }
+
+    /// Iterates over all resources in the world
+    pub fn iter_resources(&self) -> impl Iterator<Item = (&ComponentInfo, Ptr<'_>)> {
+        self.iter_resources_internal(&self.storages.resources)
+    }
+
+    /// Mutably iterates over all resources in the world
+    pub fn iter_resources_mut(&mut self) -> impl Iterator<Item = (&ComponentInfo, MutUntyped<'_>)> {
+        // SAFETY: `&mut self` ensures that all accessed data is unaliased
+        unsafe { self.iter_resources_mut_internal(&self.storages.resources) }
+    }
+
+    /// Iterates over all `!Send` resources in the world that are accessible from the current thread.
+    ///
+    /// Resources that were inserted from a different thread are skipped.
+    pub fn iter_non_send(&self) -> impl Iterator<Item = (&ComponentInfo, Ptr<'_>)> {
+        self.iter_resources_internal(&self.storages.non_send_resources)
+    }
+
+    /// Mutably iterates over all `!Send` resources in the world that are accessible from the current thread.
+    ///
+    /// Resources that were inserted from a different thread are skipped.
+    pub fn iter_non_send_mut(&mut self) -> impl Iterator<Item = (&ComponentInfo, MutUntyped<'_>)> {
+        // SAFETY: `&mut self` ensures that all accessed data is unaliased
+        unsafe { self.iter_resources_mut_internal(&self.storages.non_send_resources) }
+    }
+
+    fn iter_resources_internal<'w, const SEND: bool>(
+        &'w self,
+        resources: &'w Resources<SEND>,
+    ) -> impl Iterator<Item = (&ComponentInfo, Ptr<'_>)> {
+        resources.iter().filter(|(_, data)| data.can_access()).map(|(component_id, data)| {
+            let component_info = self.components.get_info(component_id).unwrap_or_else(|| {
+                panic!("ComponentInfo should exist for all resources in the world, but it does not for {:?}", component_id);
+            });
+            let ptr = data.get_data().unwrap_or_else(|| {
+                panic!(
+                    "When iterating all resources, resource of type {} was supposed to exist, but did not.",
+                    component_info.name()
+                )
+            });
+            (component_info, ptr)
+        })
+    }
+
+    /// # Safety
+    /// - Caller must have exclusive access to the world
+    unsafe fn iter_resources_mut_internal<'w, const SEND: bool>(
+        &'w self,
+        resources: &'w Resources<SEND>,
+    ) -> impl Iterator<Item = (&ComponentInfo, MutUntyped<'_>)> {
+        resources.iter().filter(|(_, data)| data.can_access()).map(|(component_id, data)| {
+            let component_info = self.components.get_info(component_id).unwrap_or_else(|| {
+                panic!("ComponentInfo should exist for all resources in the world, but it does not for {:?}", component_id);
+            });
+
+            let (ptr, ticks) = data.get_with_ticks().unwrap_or_else(|| {
+                panic!(
+                    "When iterating all resources, resource of type {} was supposed to exist, but did not.",
+                    component_info.name()
+                )
+            });
+
+            let ticks = TicksMut::from_tick_cells(ticks, self.last_change_tick(), self.read_change_tick());
+
+            let mut_untyped = MutUntyped {
+                value: ptr.assert_unique(),
+                ticks,
+            };
+
+            (component_info, mut_untyped)
+        })
+    }
 }
 
 impl World {

crates/bevy_internal/Cargo.toml

@@ -137,6 +137,10 @@ bevy_text = ["dep:bevy_text", "bevy_ui?/bevy_text"]
 
 bevy_render = ["dep:bevy_render", "bevy_scene?/bevy_render"]
 
+bevy_remote = ["dep:bevy_remote"]
+
+remote_http = ["bevy_remote/http"]
+
 # Enable assertions to check the validity of parameters passed to glam
 glam_assert = ["bevy_math/glam_assert"]
 
@@ -197,6 +201,7 @@ bevy_ui = { path = "../bevy_ui", optional = true, version = "0.13.0" }
 bevy_winit = { path = "../bevy_winit", optional = true, version = "0.13.0" }
 bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.13.0" }
 bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.13.0", default-features = false }
+bevy_remote = { path = "../bevy_remote", optional = true, version = "0.13.0" }
 
 [lints]
 workspace = true

crates/bevy_internal/src/default_plugins.rs

@@ -134,6 +134,11 @@ impl PluginGroup for DefaultPlugins {
             group = group.add(bevy_gizmos::GizmoPlugin);
         }
 
+        #[cfg(feature = "bevy_remote")]
+        {
+            group = group.add(bevy_remote::RemotePlugin);
+        }
+
         group = group.add(IgnoreAmbiguitiesPlugin);
 
         group

crates/bevy_remote/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "bevy_remote"
+version = "0.13.0"
+edition = "2021"
+description = "Provides remote inspection capabilities for Bevy Engine via the BRP (Bevy Remote Protocol)"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT OR Apache-2.0"
+keywords = ["bevy"]
+
+[features]
+http = ["dep:rouille"]
+
+[dependencies]
+bevy_app = { path = "../bevy_app", version = "0.13.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.13.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.13.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.13.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.13.0" }
+bevy_log = { path = "../bevy_log", version = "0.13.0" }
+
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+ron = "0.8.0"
+json5 = "0.4.1"
+crossbeam-channel = "0.5.0"
+rouille = { version = "3.6.2", optional = true }
+wasm-bindgen = "0.2"
+serde-wasm-bindgen = "0.6"
+js-sys = "0.3"
+
+[lints]
+workspace = true