Build production-ready editor authoring workflows
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-07-11 12:41:04 -04:00
1 parent cc1fa6ea3b
commit 0553a85220
163 files changed
+34547 -1565

No files matched your search

+5 -1
View File
@@ -22,8 +22,10 @@ use lights::{hydrate_lights, reconcile_missing_runtime_lights};
use materials::hydrate_materials;
pub use materials::material_from_desc;
use models::hydrate_models;
pub use models::HydratedModelRoot;
use physics::hydrate_physics;
use prefabs::hydrate_prefabs;
use prefabs::{hydrate_prefabs, tag_hydrated_prefab_members};
pub use prefabs::{HydratedPrefabMember, HydratedPrefabReady, PrefabHydrationBlocked};
use primitives::{hydrate_primitives, primitive_mesh};
use static_meshes::{
hydrate_static_mesh_renderers, spawn_static_mesh_parts, HydratedStaticMeshPart,
@@ -47,6 +49,8 @@ pub struct HydrationPlugin;
impl Plugin for HydrationPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<StaticMeshArtifactCache>()
.add_observer(tag_hydrated_prefab_members)
.add_observer(crate::prefab_overrides::apply_prefab_overrides_on_ready)
.add_systems(
Update,
(
+185 -6
View File
@@ -6,7 +6,13 @@ use bevy::prelude::*;
use crate::{asset_server_path, LevelObject, ModelRef};
use super::strip::despawn_generated_children;
use super::static_meshes::static_mesh_source_path;
/// Runtime root generated for one authored [`ModelRef`].
#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
pub struct HydratedModelRoot {
pub owner: Entity,
}
#[allow(clippy::type_complexity)]
pub fn hydrate_models(
@@ -16,21 +22,194 @@ pub fn hydrate_models(
(Entity, &ModelRef),
(With<LevelObject>, Or<(Added<ModelRef>, Changed<ModelRef>)>),
>,
children: Query<&Children>,
generated_roots: Query<(Entity, &HydratedModelRoot)>,
) {
for (entity, model) in &models {
if let Ok(child_list) = children.get(entity) {
despawn_generated_children(&mut commands, entity, child_list);
for (root, generated) in &generated_roots {
if generated.owner == entity {
commands.entity(root).despawn();
}
}
// Remove roots created by the legacy hydration path without touching authored children.
commands.entity(entity).remove::<WorldAssetRoot>();
let path = asset_server_path(&model.path);
let resolved_path = if model.asset_id.trim().is_empty() {
model.path.clone()
} else {
match static_mesh_source_path(&model.asset_id) {
Ok(path) => path,
Err(error) => {
warn!(
"ModelRef {} could not resolve stable asset {}: {error}; falling back to cached path {}",
entity,
model.asset_id,
model.path
);
model.path.clone()
}
}
};
let path = asset_server_path(&resolved_path);
let handle = if path.ends_with(".fbx") {
asset_server.load(ModelRef::fbx_scene_asset_path(&path, model.scene_index))
} else {
asset_server.load(GltfAssetLabel::Scene(model.scene_index).from_asset(path))
};
commands.entity(entity).insert(WorldAssetRoot(handle));
commands.spawn((
Name::new("Hydrated Imported Model Root"),
HydratedModelRoot { owner: entity },
WorldAssetRoot(handle),
ChildOf(entity),
));
}
}
#[cfg(test)]
mod tests {
use super::*;
use bevy::asset::{AssetApp, AssetPlugin};
use bevy::prelude::WorldAsset;
use std::path::{Path, PathBuf};
struct TestManifest(PathBuf);
impl Drop for TestManifest {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.0);
}
}
fn write_test_manifest(asset_id: &str, source_path: &str) -> TestManifest {
let path = PathBuf::from(super::super::static_meshes::static_mesh_manifest_path(
asset_id,
));
std::fs::create_dir_all(path.parent().expect("manifest has a parent directory"))
.expect("generated static mesh directory should be writable");
std::fs::write(
&path,
format!(
r#"(
source: (path: "{source_path}"),
parts: [],
)"#
),
)
.expect("test static mesh manifest should be writable");
TestManifest(path)
}
fn hydration_app() -> App {
let mut app = App::new();
app.add_plugins((MinimalPlugins, AssetPlugin::default()))
.init_asset::<WorldAsset>()
.add_systems(Update, hydrate_models);
app
}
fn generated_roots(world: &mut World, owner: Entity) -> Vec<Entity> {
world
.query::<(Entity, &HydratedModelRoot)>()
.iter(world)
.filter_map(|(entity, generated)| (generated.owner == owner).then_some(entity))
.collect()
}
#[test]
fn hydration_preserves_arbitrary_authored_children() {
let mut app = hydration_app();
let owner = app
.world_mut()
.spawn((LevelObject, ModelRef::new("assets/models/first.glb")))
.id();
let authored_child = app
.world_mut()
.spawn((Name::new("Authored Child"), ChildOf(owner)))
.id();
app.update();
assert!(app.world().get_entity(authored_child).is_ok());
assert_eq!(
app.world().get::<ChildOf>(authored_child).unwrap().parent(),
owner
);
assert_eq!(generated_roots(app.world_mut(), owner).len(), 1);
}
#[test]
fn model_ref_change_replaces_only_the_generated_root() {
let mut app = hydration_app();
let owner = app
.world_mut()
.spawn((LevelObject, ModelRef::new("assets/models/first.glb")))
.id();
let authored_child = app
.world_mut()
.spawn((Name::new("Authored Child"), ChildOf(owner)))
.id();
app.update();
let first_root = generated_roots(app.world_mut(), owner)
.into_iter()
.next()
.unwrap();
app.world_mut().get_mut::<ModelRef>(owner).unwrap().path =
"assets/models/second.glb".into();
app.update();
let roots = generated_roots(app.world_mut(), owner);
assert_eq!(roots.len(), 1);
assert_ne!(roots[0], first_root);
assert!(app.world().get_entity(first_root).is_err());
assert!(app.world().get_entity(authored_child).is_ok());
assert_eq!(
app.world().get::<ChildOf>(authored_child).unwrap().parent(),
owner
);
}
#[test]
fn stable_asset_id_resolves_relocated_model_source_from_manifest() {
const ASSET_ID: &str = "34b80e75-f00c-4ead-91cb-54bd9b66ad55";
const CACHED_PATH: &str = "assets/models/stale_cached_path.glb";
const MANIFEST_PATH: &str = "assets/models/relocated/source.glb";
let _manifest = write_test_manifest(ASSET_ID, MANIFEST_PATH);
let mut app = hydration_app();
let owner = app
.world_mut()
.spawn((
LevelObject,
ModelRef {
asset_id: ASSET_ID.into(),
path: CACHED_PATH.into(),
scene_index: 3,
},
))
.id();
app.update();
let root_entity = generated_roots(app.world_mut(), owner)
.into_iter()
.next()
.expect("stable model reference should create a hydrated root");
let root = app
.world()
.get::<WorldAssetRoot>(root_entity)
.expect("generated root should retain its world asset handle");
let loaded_path = app
.world()
.resource::<AssetServer>()
.get_path(root.0.id())
.expect("world asset handle should retain its resolved source path");
assert_eq!(loaded_path.path(), Path::new("models/relocated/source.glb"));
assert_eq!(loaded_path.label(), Some("Scene3"));
assert_ne!(
loaded_path.path(),
Path::new("models/stale_cached_path.glb")
);
}
}
+91 -6
View File
@@ -2,11 +2,28 @@
use bevy::prelude::DynamicWorldRoot;
use bevy::prelude::*;
use bevy::world_serialization::{WorldInstanceReady, WorldInstanceSpawner};
use crate::{LevelObject, PrefabInstance, PrefabRef};
use crate::asset_server_path;
/// Runtime ownership for entities spawned from a linked prefab source.
#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
pub struct HydratedPrefabMember {
pub instance_root: Entity,
}
/// Runtime marker that the linked prefab instance finished spawning.
#[derive(Component, Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct HydratedPrefabReady;
/// Runtime-only guard used by editor recovery when a prefab source is invalid.
#[derive(Component, Debug, Clone, PartialEq, Eq)]
pub struct PrefabHydrationBlocked {
pub reason: String,
}
#[allow(clippy::type_complexity)]
pub fn hydrate_prefabs(
mut commands: Commands,
@@ -23,21 +40,89 @@ pub fn hydrate_prefabs(
(Entity, &PrefabInstance),
(
With<LevelObject>,
Without<PrefabHydrationBlocked>,
Or<(Added<PrefabInstance>, Changed<PrefabInstance>)>,
),
>,
) {
for (entity, prefab) in &prefabs {
commands.entity(entity).insert(DynamicWorldRoot(
asset_server.load(asset_server_path(&prefab.path)),
commands.entity(entity).insert(PrefabInstance::new(
format!("legacy:{}", prefab.path),
prefab.path.clone(),
));
}
for (entity, instance) in &prefab_instances {
let path = asset_server_path(&instance.source_path);
commands.entity(entity).insert((
PrefabRef::new(instance.source_path.clone()),
DynamicWorldRoot(asset_server.load(path)),
));
commands
.entity(entity)
.remove::<HydratedPrefabReady>()
.insert((
PrefabRef::new(instance.source_path.clone()),
DynamicWorldRoot(asset_server.load(path)),
));
}
}
pub fn tag_hydrated_prefab_members(
ready: On<WorldInstanceReady>,
prefab_roots: Query<(), With<PrefabInstance>>,
instance_spawner: Res<WorldInstanceSpawner>,
mut commands: Commands,
) {
if prefab_roots.get(ready.entity).is_err() {
return;
}
for member in instance_spawner.iter_instance_entities(ready.instance_id) {
commands.entity(member).insert(HydratedPrefabMember {
instance_root: ready.entity,
});
}
commands.entity(ready.entity).insert(HydratedPrefabReady);
}
#[cfg(test)]
mod tests {
use super::*;
use bevy::asset::AssetPlugin;
use bevy::world_serialization::{DynamicWorld, WorldSerializationPlugin};
#[test]
fn spawned_prefab_entities_receive_runtime_ownership() {
let mut app = App::new();
app.add_plugins((AssetPlugin::default(), WorldSerializationPlugin))
.register_type::<crate::LevelObject>()
.register_type::<crate::ActorId>()
.add_observer(tag_hydrated_prefab_members);
let mut source = World::new();
source.spawn((crate::LevelObject, crate::ActorId::new("child")));
let dynamic_world = DynamicWorld::from_world_with(
&source,
&app.world().resource::<AppTypeRegistry>().read(),
);
let handle = app
.world_mut()
.resource_mut::<Assets<DynamicWorld>>()
.add(dynamic_world);
let root = app
.world_mut()
.spawn((
PrefabInstance::new("prefab", "assets/prefabs/test.scn.ron"),
DynamicWorldRoot(handle),
))
.id();
app.update();
let world = app.world_mut();
let members: Vec<_> = world
.query::<(Entity, &HydratedPrefabMember)>()
.iter(world)
.map(|(entity, owner)| (entity, owner.instance_root))
.collect();
assert_eq!(members.len(), 1);
assert_eq!(members[0].1, root);
assert!(world.get::<HydratedPrefabReady>(root).is_some());
}
}
+17 -5
View File
@@ -7,9 +7,9 @@ use serde::Deserialize;
use std::collections::{HashMap, HashSet};
use crate::{
asset_server_path, inspector_component_active, ColliderDesc, ColliderShapeDesc, EditorAssetRef,
InspectorOrder, LevelObject, MaterialDesc, MaterialOverride, StaticMeshRenderer,
StaticMeshRendererEntry, COMPONENT_COLLIDER_DESC, COMPONENT_MATERIAL_DESC,
asset_server_path, inspector_component_active, standard_material_asset_path, ColliderDesc,
ColliderShapeDesc, EditorAssetRef, InspectorOrder, LevelObject, MaterialDesc, MaterialOverride,
StaticMeshRenderer, StaticMeshRendererEntry, COMPONENT_COLLIDER_DESC, COMPONENT_MATERIAL_DESC,
COMPONENT_STATIC_MESH_RENDERER,
};
@@ -318,7 +318,7 @@ fn material_for_entry(
if let Some(material_ref) = entry.material.as_ref() {
if let Some(resolved_material) = artifact_cache.resolve_material(material_ref) {
let source_path = asset_server_path(&resolved_material.source_path);
return asset_server.load(labeled_asset_path(
return asset_server.load(standard_material_asset_path(
&source_path,
&resolved_material.material_label,
));
@@ -331,7 +331,7 @@ fn material_for_entry(
if let Some(label) = resolved.material_label.as_deref() {
let source_path = asset_server_path(&resolved.source_path);
return asset_server.load(labeled_asset_path(&source_path, label));
return asset_server.load(standard_material_asset_path(&source_path, label));
}
materials.add(StandardMaterial::default())
@@ -361,6 +361,18 @@ pub fn static_mesh_manifest_path(asset_id: &str) -> String {
format!("{STATIC_MESH_ARTIFACT_DIR}/{asset_id}.static_mesh.ron")
}
pub(super) fn static_mesh_source_path(asset_id: &str) -> Result<String, String> {
let path = static_mesh_manifest_path(asset_id);
let text = std::fs::read_to_string(&path)
.map_err(|error| format!("could not read {path}: {error}"))?;
let manifest: StaticMeshResolveManifest =
ron::from_str(&text).map_err(|error| format!("could not parse {path}: {error}"))?;
if manifest.source.path.trim().is_empty() {
return Err(format!("static mesh manifest {path} has no source path"));
}
Ok(manifest.source.path)
}
fn part_id_from_label(label: &str) -> String {
format!("mesh:{}", stable_sub_asset_slug(label))
}
-8
View File
@@ -30,11 +30,3 @@ pub fn strip_hydrated(entity_commands: &mut EntityCommands<'_>) {
.remove::<RigidBody>()
.remove::<Collider>();
}
/// Despawns all child entities (e.g. prior `WorldAssetRoot` instance hierarchy).
pub fn despawn_generated_children(commands: &mut Commands, entity: Entity, children: &Children) {
for child in children.iter() {
commands.entity(child).despawn();
}
commands.entity(entity).remove::<Children>();
}