Build production-ready editor authoring workflows
CI / Format, lint, test, build (push) Waiting to run
CI / Format, lint, test, build (push) Waiting to run
This commit is contained in:
1 parent
cc1fa6ea3b
commit
0553a85220
163 files changed
+34547
-1565
No files matched your search
@@ -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,
|
||||
(
|
||||
|
||||
@@ -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")
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
|
||||
@@ -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>();
|
||||
}
|
||||
Reference in new issue
Block a user