Add editor sample regression pack

This commit is contained in:
Rbanh committed 2026-07-13 01:52:58 -04:00
1 parent c55f34780f
commit 06010c5922
31 files changed
+3258 -110

No files matched your search

+3
View File
@@ -27,6 +27,7 @@ pub use project::diagnostics_bundle;
pub use project::launcher;
pub use project::native_dialog;
pub use project::project_io;
pub use project::samples;
pub use project::session;
pub use project::settings_ui;
pub use scene::scene_io;
@@ -74,6 +75,7 @@ use play::audio_preview::AudioPreviewPlugin;
use play::PlaySessionPlugin;
use project::collaboration::CollaborationPlugin;
use project::native_dialog::NativeDialogPlugin;
use project::samples::SampleCatalogPlugin;
use project_io::ProjectIoPlugin;
use render_view::RenderViewPlugin;
use scene_io::SceneIoPlugin;
@@ -98,6 +100,7 @@ impl PluginGroup for EditorPluginGroup {
let group = PluginGroupBuilder::start::<Self>()
.add(EditorInfraPlugin)
.add(ProjectIoPlugin)
.add(SampleCatalogPlugin)
.add(NativeDialogPlugin)
.add(scene_schema::SceneSchemaPlugin)
.add(net_editor::NetEditorPlugin)
+1
View File
@@ -5,5 +5,6 @@ pub mod diagnostics_bundle;
pub mod launcher;
pub mod native_dialog;
pub mod project_io;
pub mod samples;
pub mod session;
pub mod settings_ui;
+208
View File
@@ -0,0 +1,208 @@
//! Cached project sample catalog used by editor scene-opening UI.
use std::path::{Path, PathBuf};
use bevy::prelude::*;
use scene::sample_pack::{
validate_editor_sample_pack, EditorSampleEntry, EDITOR_SAMPLE_MANIFEST_PATH,
};
use super::project_io::ProjectWorkspace;
const VALIDATION_HINT: &str = "Run `cargo validate-samples --project .` for details.";
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SampleCatalogEntry {
pub id: String,
pub label: String,
pub scene_path: PathBuf,
pub project_relative_scene: String,
pub summary: String,
pub checks: Vec<String>,
}
impl SampleCatalogEntry {
pub fn hover_text(&self) -> String {
let mut lines = vec![self.summary.clone()];
if !self.checks.is_empty() {
lines.push(format!("Checks: {}", self.checks.join(", ")));
}
lines.push(self.project_relative_scene.clone());
lines.join("\n")
}
}
#[derive(Resource, Debug, Clone)]
pub struct SampleCatalog {
entries: Vec<SampleCatalogEntry>,
unavailable_reason: Option<String>,
}
impl Default for SampleCatalog {
fn default() -> Self {
Self::unavailable("Sample catalog is loading")
}
}
impl SampleCatalog {
pub fn entries(&self) -> &[SampleCatalogEntry] {
&self.entries
}
pub fn entry(&self, stable_id: &str) -> Option<&SampleCatalogEntry> {
self.unavailable_reason
.is_none()
.then(|| self.entries.iter().find(|entry| entry.id == stable_id))
.flatten()
}
pub fn unavailable_reason(&self) -> Option<&str> {
self.unavailable_reason.as_deref()
}
#[cfg(test)]
pub(crate) fn available_entries(entries: Vec<SampleCatalogEntry>) -> Self {
Self {
entries,
unavailable_reason: None,
}
}
fn available(samples: Vec<EditorSampleEntry>) -> Self {
Self {
entries: samples.into_iter().map(catalog_entry).collect(),
unavailable_reason: None,
}
}
fn unavailable(reason: impl Into<String>) -> Self {
Self {
entries: Vec::new(),
unavailable_reason: Some(reason.into()),
}
}
}
fn catalog_entry(entry: EditorSampleEntry) -> SampleCatalogEntry {
SampleCatalogEntry {
id: entry.id,
label: entry.label,
scene_path: PathBuf::from(&entry.scene),
project_relative_scene: entry.scene,
summary: entry.summary,
checks: entry.checks,
}
}
fn load_catalog(project_root: &Path) -> SampleCatalog {
let validation = validate_editor_sample_pack(project_root);
if !validation.is_release_ready() {
let first_error = validation
.report
.findings
.iter()
.find(|finding| finding.severity == scene::ValidationSeverity::Error)
.map(|finding| finding.message.as_str())
.unwrap_or("sample pack validation failed");
return SampleCatalog::unavailable(format!(
"Sample manifest `{EDITOR_SAMPLE_MANIFEST_PATH}` is invalid: {first_error}\n{VALIDATION_HINT}"
));
}
if validation.samples.is_empty() {
return SampleCatalog::unavailable(format!(
"Sample manifest contains no scenes.\n{VALIDATION_HINT}"
));
}
SampleCatalog::available(validation.samples)
}
fn load_sample_catalog(world: &mut World) {
let project_root = PathBuf::from(&world.resource::<ProjectWorkspace>().root);
world.insert_resource(load_catalog(&project_root));
}
pub struct SampleCatalogPlugin;
impl Plugin for SampleCatalogPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<SampleCatalog>()
.add_systems(Startup, load_sample_catalog);
}
}
#[cfg(test)]
mod tests {
use super::*;
use scene::sample_pack::EditorSampleArea;
fn sample(id: &str, label: &str, scene: &str) -> EditorSampleEntry {
EditorSampleEntry {
id: id.into(),
label: label.into(),
area: EditorSampleArea::Brush,
scene: scene.into(),
summary: format!("Summary for {label}"),
checks: vec!["selection".into(), "undo".into()],
}
}
#[test]
fn available_catalog_preserves_manifest_order_and_resolves_paths() {
let catalog = SampleCatalog::available(vec![
sample(
"terrain",
"Terrain",
"assets/levels/samples/terrain.scn.ron",
),
sample("brush", "Brush", "assets/levels/samples/brush.scn.ron"),
]);
assert_eq!(
catalog
.entries()
.iter()
.map(|entry| entry.id.as_str())
.collect::<Vec<_>>(),
vec!["terrain", "brush"]
);
assert_eq!(
catalog.entry("brush").unwrap().scene_path,
PathBuf::from("assets/levels/samples/brush.scn.ron")
);
let hover = catalog.entry("brush").unwrap().hover_text();
assert!(hover.contains("Summary for Brush"));
assert!(hover.contains("Checks: selection, undo"));
assert!(hover.contains("assets/levels/samples/brush.scn.ron"));
}
#[test]
fn unavailable_catalog_never_resolves_entries() {
let catalog = SampleCatalog {
entries: vec![catalog_entry(sample(
"brush",
"Brush",
"assets/levels/samples/brush.scn.ron",
))],
unavailable_reason: Some("manifest invalid".into()),
};
assert!(catalog.entry("brush").is_none());
assert_eq!(catalog.unavailable_reason(), Some("manifest invalid"));
}
#[test]
fn missing_manifest_reports_repair_command() {
let root = std::env::temp_dir().join(format!(
"blacksite-missing-sample-catalog-{}",
uuid::Uuid::new_v4()
));
std::fs::create_dir_all(&root).unwrap();
let catalog = load_catalog(&root);
let reason = catalog.unavailable_reason().unwrap();
assert!(reason.contains(EDITOR_SAMPLE_MANIFEST_PATH));
assert!(reason.contains("cargo validate-samples --project ."));
std::fs::remove_dir_all(root).unwrap();
}
}
+335 -12
View File
@@ -25,6 +25,7 @@ use crate::assets::{import_external_assets, EditorAssets, IMPORTABLE_ASSET_EXTEN
use crate::history::{clear_level_objects, snapshot_entity, EditorHistory};
use crate::native_dialog::NativeDialogBroker;
use crate::project::collaboration::{publish_authored_file, FileSnapshot, FileWriteIntent};
use crate::project::samples::SampleCatalog;
use crate::scene::recovery::{
default_state_root, discard_recovery_snapshots, latest_recovery_snapshot,
write_recovery_snapshot,
@@ -49,6 +50,7 @@ pub enum SceneIoRequest {
SaveRecoveryCopyAs,
DiscardRecovery,
OpenRecent(usize),
OpenSample(String),
OpenPath(PathBuf),
SwitchTab(usize),
CloseTab(usize),
@@ -313,6 +315,7 @@ fn process_scene_io_requests(world: &mut World) {
SceneIoRequest::SaveRecoveryCopyAs => save_recovery_copy_with_dialog(world),
SceneIoRequest::DiscardRecovery => discard_recovery(world),
SceneIoRequest::OpenRecent(index) => open_recent(world, index),
SceneIoRequest::OpenSample(stable_id) => open_sample(world, &stable_id),
SceneIoRequest::OpenPath(path) => open_path(world, path),
SceneIoRequest::SwitchTab(index) => switch_scene_tab(world, index),
SceneIoRequest::CloseTab(index) => close_scene_tab(world, index),
@@ -377,13 +380,72 @@ fn open_recent(world: &mut World, index: usize) -> String {
open_path(world, path)
}
fn open_sample(world: &mut World, stable_id: &str) -> String {
let catalog_state = {
let catalog = world.resource::<SampleCatalog>();
(
catalog.entry(stable_id).cloned(),
catalog.unavailable_reason().map(str::to_string),
)
};
match catalog_state {
(Some(entry), _) => open_path(world, entry.scene_path),
(None, Some(reason)) => format!("Open sample failed: {reason}"),
(None, None) => format!("Open sample failed: unknown sample ID `{stable_id}`"),
}
}
/// Comparison-only key. Stored paths remain unchanged because recovery and bookmarks use them.
fn scene_path_identity(project_root: &Path, path: &Path) -> PathBuf {
let candidate = if path.is_absolute() {
path.to_path_buf()
} else {
project_root.join(path)
};
candidate.canonicalize().unwrap_or(candidate)
}
fn scene_paths_share_identity(project_root: &Path, first: &Path, second: &Path) -> bool {
scene_path_identity(project_root, first) == scene_path_identity(project_root, second)
}
fn remember_persisted_scene_path(
preferences: &mut crate::project_io::UserPreferences,
project_root: &Path,
path: &Path,
) {
preferences
.recent_levels
.retain(|recent| !scene_paths_share_identity(project_root, Path::new(recent), path));
preferences
.recent_levels
.insert(0, path.display().to_string());
preferences.recent_levels.truncate(8);
}
fn open_path(world: &mut World, path: PathBuf) -> String {
if let Some(index) = world
.resource::<SceneIo>()
.tabs
.iter()
.position(|tab| tab.path.as_ref() == Some(&path))
{
let project_root = PathBuf::from(
world
.resource::<crate::project_io::ProjectWorkspace>()
.root
.clone(),
);
let Ok(project_root) = project_root.canonicalize() else {
return format!(
"Open failed: could not resolve project root {}",
project_root.display()
);
};
let matching_tab = world.resource::<SceneIo>().tabs.iter().position(|tab| {
tab.path
.as_deref()
.is_some_and(|tab_path| scene_paths_share_identity(&project_root, tab_path, &path))
});
if let Some(index) = matching_tab {
let established_path = world.resource::<SceneIo>().tabs[index].path.clone();
if let Some(established_path) = established_path {
remember_path(world, established_path);
}
return switch_scene_tab(world, index);
}
if let Err(error) = capture_active_tab(world) {
@@ -2160,15 +2222,24 @@ fn backfill_missing_actor_kinds(world: &mut World) {
}
fn remember_path(world: &mut World, path: PathBuf) {
let mut io = world.resource_mut::<SceneIo>();
io.recent_paths.retain(|recent| recent != &path);
io.recent_paths.insert(0, path.clone());
io.recent_paths.truncate(8);
let configured_root = PathBuf::from(
world
.resource::<crate::project_io::ProjectWorkspace>()
.root
.clone(),
);
let project_root = configured_root.canonicalize().unwrap_or(configured_root);
{
let mut io = world.resource_mut::<SceneIo>();
io.recent_paths
.retain(|recent| !scene_paths_share_identity(&project_root, recent, &path));
io.recent_paths.insert(0, path.clone());
io.recent_paths.truncate(8);
}
if world.contains_resource::<crate::project_io::UserPreferences>() {
let path_label = path.display().to_string();
let mut prefs = world.resource_mut::<crate::project_io::UserPreferences>();
crate::project_io::push_recent(&mut prefs.recent_levels, path_label, 8);
remember_persisted_scene_path(&mut prefs, &project_root, &path);
if let Err(error) = crate::project_io::write_user_preferences(&prefs) {
warn!("Failed to save editor preferences: {error}");
}
@@ -3168,6 +3239,258 @@ mod tests {
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn unknown_sample_id_does_not_change_scene_state() {
let known = crate::project::samples::SampleCatalogEntry {
id: "known".into(),
label: "Known Sample".into(),
scene_path: PathBuf::from("assets/levels/samples/known.scn.ron"),
project_relative_scene: "assets/levels/samples/known.scn.ron".into(),
summary: "Known fixture".into(),
checks: vec!["opens".into()],
};
let mut world = World::new();
world.init_resource::<SceneIo>();
world.insert_resource(SampleCatalog::available_entries(vec![known]));
let original_tab_id = world.resource::<SceneIo>().tabs[0].id;
let status = open_sample(&mut world, "missing");
assert_eq!(status, "Open sample failed: unknown sample ID `missing`");
let io = world.resource::<SceneIo>();
assert_eq!(io.tabs.len(), 1);
assert_eq!(io.tabs[0].id, original_tab_id);
assert_eq!(io.active_path, None);
assert!(!io.dirty);
}
#[test]
fn in_project_absolute_and_relative_scene_paths_share_one_canonical_key() {
let root = std::env::temp_dir().join(format!(
"blacksite-scene-path-identity-{}",
uuid::Uuid::new_v4()
));
let scene = root.join("assets/levels/samples/alias.scn.ron");
std::fs::create_dir_all(scene.parent().unwrap()).unwrap();
std::fs::write(&scene, "(schema_version: 4, resources: {}, entities: {})").unwrap();
let root = root.canonicalize().unwrap();
let expected = scene.canonicalize().unwrap();
assert_eq!(scene_path_identity(&root, &scene), expected);
assert_eq!(
scene_path_identity(&root, Path::new("assets/levels/./samples/alias.scn.ron")),
expected
);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn relative_and_absolute_scene_aliases_do_not_create_a_second_tab() {
let root = std::env::temp_dir().join(format!(
"blacksite-scene-tab-alias-{}",
uuid::Uuid::new_v4()
));
let relative = PathBuf::from("assets/levels/samples/alias.scn.ron");
let absolute = root.join(&relative);
std::fs::create_dir_all(absolute.parent().unwrap()).unwrap();
std::fs::write(
&absolute,
"(schema_version: 4, resources: {}, entities: {})",
)
.unwrap();
let mut world = World::new();
world.init_resource::<SceneIo>();
world.insert_resource(crate::project_io::ProjectWorkspace {
root: root.display().to_string(),
..Default::default()
});
{
let mut io = world.resource_mut::<SceneIo>();
io.active_path = Some(relative.clone());
io.tabs[0].path = Some(relative.clone());
io.recent_paths = vec![absolute.clone(), relative.clone()];
}
let status = open_path(&mut world, absolute.clone());
assert_eq!(status, "Scene tab is already active");
let io = world.resource::<SceneIo>();
assert_eq!(io.tabs.len(), 1);
assert_eq!(io.tabs[0].path.as_ref(), Some(&relative));
assert_eq!(io.active_path.as_ref(), Some(&relative));
assert_eq!(io.recent_paths, vec![relative.clone()]);
let mut preferences = crate::project_io::UserPreferences {
recent_levels: vec![
absolute.display().to_string(),
relative.display().to_string(),
],
..Default::default()
};
remember_persisted_scene_path(&mut preferences, &root, &relative);
assert_eq!(
preferences.recent_levels,
vec![relative.display().to_string()]
);
let mut world = World::new();
world.init_resource::<SceneIo>();
world.insert_resource(crate::project_io::ProjectWorkspace {
root: root.display().to_string(),
..Default::default()
});
{
let mut io = world.resource_mut::<SceneIo>();
io.active_path = Some(absolute.clone());
io.tabs[0].path = Some(absolute.clone());
}
let status = open_path(&mut world, relative.clone());
assert_eq!(status, "Scene tab is already active");
let io = world.resource::<SceneIo>();
assert_eq!(io.tabs.len(), 1);
assert_eq!(io.tabs[0].path.as_ref(), Some(&absolute));
assert_eq!(io.active_path.as_ref(), Some(&absolute));
let mut preferences = crate::project_io::UserPreferences {
recent_levels: vec![
relative.display().to_string(),
absolute.display().to_string(),
],
..Default::default()
};
remember_persisted_scene_path(&mut preferences, &root, &absolute);
assert_eq!(
preferences.recent_levels,
vec![absolute.display().to_string()]
);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn alias_open_preserves_recovery_generation_and_camera_bookmark_keys() {
let root = std::env::temp_dir().join(format!(
"blacksite-scene-alias-state-{}",
uuid::Uuid::new_v4()
));
std::fs::create_dir_all(&root).unwrap();
let root = root.canonicalize().unwrap();
let relative = PathBuf::from("assets/levels/samples/stateful.scn.ron");
let absolute = root.join(&relative);
std::fs::create_dir_all(absolute.parent().unwrap()).unwrap();
std::fs::write(
&absolute,
"(schema_version: 4, resources: {}, entities: {})",
)
.unwrap();
let state_root = root.join("editor-state");
let first_recovery =
write_recovery_snapshot(&state_root, &root, &absolute, b"first", 5).unwrap();
let bookmark = Transform::from_xyz(7.0, 11.0, 13.0);
let bookmark_key = absolute.display().to_string();
let mut bookmarks = crate::viewport::CameraBookmarks::default();
crate::viewport::save_camera_bookmark(&mut bookmarks, &bookmark_key, bookmark);
let mut world = World::new();
world.init_resource::<SceneIo>();
world.insert_resource(crate::project_io::ProjectWorkspace {
root: root.display().to_string(),
..Default::default()
});
world.insert_resource(bookmarks);
{
let mut io = world.resource_mut::<SceneIo>();
io.active_path = Some(absolute.clone());
io.recovery_snapshot = Some(first_recovery.clone());
io.tabs[0].path = Some(absolute.clone());
io.tabs[0].recovery_snapshot = Some(first_recovery.clone());
}
let status = open_path(&mut world, relative);
assert_eq!(status, "Scene tab is already active");
let active_path = world
.resource::<SceneIo>()
.active_path
.clone()
.expect("active path must remain established");
assert_eq!(active_path, absolute);
assert_eq!(
world.resource::<SceneIo>().recovery_snapshot.as_ref(),
Some(&first_recovery)
);
let second_recovery =
write_recovery_snapshot(&state_root, &root, &active_path, b"second", 5).unwrap();
assert_eq!(first_recovery.parent(), second_recovery.parent());
let active_key = active_path.display().to_string();
assert_eq!(
crate::viewport::recall_camera_bookmark(
world.resource::<crate::viewport::CameraBookmarks>(),
&active_key,
),
Some(bookmark)
);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn outside_project_scene_keeps_its_absolute_identity() {
let root = std::env::temp_dir().join(format!(
"blacksite-scene-path-root-{}",
uuid::Uuid::new_v4()
));
let outside = std::env::temp_dir().join(format!(
"blacksite-outside-scene-{}.scn.ron",
uuid::Uuid::new_v4()
));
std::fs::create_dir_all(&root).unwrap();
std::fs::write(&outside, "(schema_version: 4, resources: {}, entities: {})").unwrap();
let root = root.canonicalize().unwrap();
let outside = outside.canonicalize().unwrap();
assert_eq!(scene_path_identity(&root, &outside), outside);
std::fs::remove_file(outside).unwrap();
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn every_manifest_sample_typed_deserializes_without_a_gpu() {
let project_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("../..")
.canonicalize()
.unwrap();
let manifest = scene::sample_pack::load_editor_sample_manifest(&project_root).unwrap();
assert!(!manifest.samples.is_empty());
let mut app = App::new();
app.add_plugins(MinimalPlugins)
.add_plugins(AssetPlugin::default())
.add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default())
.init_asset::<Mesh>()
.add_plugins(shared::SharedTypesPlugin);
for sample in manifest.samples {
let path = project_root.join(&sample.scene);
let text = std::fs::read_to_string(&path)
.unwrap_or_else(|error| panic!("could not read sample `{}`: {error}", sample.id));
let document = SceneDocument::from_ron_text(&text).unwrap_or_else(|error| {
panic!(
"sample `{}` is not a valid scene document: {error}",
sample.id
)
});
let bevy_ron = strip_schema_version(document.normalized_ron()).unwrap();
deserialize_dynamic_scene(app.world_mut(), &bevy_ron).unwrap_or_else(|error| {
panic!(
"sample `{}` failed typed deserialization: {error}",
sample.id
)
});
}
}
#[test]
fn scene_io_event_log_is_bounded_and_classifies_failures() {
let mut io = SceneIo::default();
+80
View File
@@ -6,6 +6,7 @@ use bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities;
use egui_dock::DockState;
use crate::history::{apply_command_redo, apply_command_undo, EditorHistory};
use crate::project::samples::{SampleCatalog, SampleCatalogEntry};
use crate::scene_io::{SceneIo, SceneIoRequest};
use crate::settings_ui::{open_project_settings_panel, ProjectSettingsPanel};
use crate::state::{EditorMode, PlayPaused};
@@ -19,6 +20,19 @@ use super::layout::reset_and_save_layout;
use super::widgets::menu_item;
use super::EditorTab;
#[derive(Debug, Clone, PartialEq, Eq)]
enum SampleMenuModel {
Available(Vec<SampleCatalogEntry>),
Unavailable(String),
}
fn sample_menu_model(catalog: &SampleCatalog) -> SampleMenuModel {
match catalog.unavailable_reason() {
Some(reason) => SampleMenuModel::Unavailable(reason.to_string()),
None => SampleMenuModel::Available(catalog.entries().to_vec()),
}
}
pub fn top_menu_bar(
world: &mut World,
root_ui: &mut egui::Ui,
@@ -37,6 +51,25 @@ pub fn top_menu_bar(
world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::Open);
ui.close();
}
let sample_menu = sample_menu_model(world.resource::<SampleCatalog>());
ui.menu_button("Open Sample", |ui| match sample_menu {
SampleMenuModel::Available(entries) => {
for entry in entries {
if menu_item(ui, &entry.label, None, true)
.on_hover_text(entry.hover_text())
.clicked()
{
world.resource_mut::<SceneIo>().request =
Some(SceneIoRequest::OpenSample(entry.id));
ui.close();
}
}
}
SampleMenuModel::Unavailable(reason) => {
menu_item(ui, "Sample pack unavailable", None, false)
.on_disabled_hover_text(reason);
}
});
if menu_item(ui, "Save", Some("Ctrl+S"), true).clicked() {
world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::Save);
ui.close();
@@ -287,3 +320,50 @@ pub fn top_menu_bar(
});
});
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use super::*;
fn entry(id: &str, label: &str) -> SampleCatalogEntry {
SampleCatalogEntry {
id: id.into(),
label: label.into(),
scene_path: PathBuf::from(format!("assets/levels/samples/{id}.scn.ron")),
project_relative_scene: format!("assets/levels/samples/{id}.scn.ron"),
summary: format!("{label} summary"),
checks: vec![format!("{label} check")],
}
}
#[test]
fn sample_menu_preserves_catalog_order_and_hover_details() {
let catalog = SampleCatalog::available_entries(vec![
entry("material", "Material Lab"),
entry("terrain", "Terrain Sculpt"),
]);
let SampleMenuModel::Available(rows) = sample_menu_model(&catalog) else {
panic!("valid catalog must produce actionable menu rows");
};
assert_eq!(
rows.iter().map(|row| row.id.as_str()).collect::<Vec<_>>(),
vec!["material", "terrain"]
);
assert!(rows[0].hover_text().contains("Material Lab summary"));
assert!(rows[0].hover_text().contains("Material Lab check"));
}
#[test]
fn unavailable_catalog_produces_one_disabled_explanation() {
let catalog = SampleCatalog::default();
assert_eq!(
sample_menu_model(&catalog),
SampleMenuModel::Unavailable("Sample catalog is loading".into())
);
}
}
+1
View File
@@ -9,6 +9,7 @@ mod migrate;
pub mod navigation;
mod prefab;
mod project_validation;
pub mod sample_pack;
mod upgrade;
use std::path::Path;
+233 -1
View File
@@ -13,7 +13,7 @@ use shared::{
AudioSourceDesc, BrushDesc, ColliderDesc, ColliderShapeDesc, EditorAssetRef, MaterialAsset,
MaterialDesc, MaterialInstanceAsset, MaterialOverride, ModelRef, PostProcessEffectAsset,
PostProcessVolumeDesc, PrefabInstance, PrefabRef, RendererMaterialSet, ShaderSchemaAsset,
SkinnedMeshRenderer, StaticMeshRenderer, ANIMATION_MANIFEST_SCHEMA_VERSION,
SkinnedMeshRenderer, StaticMeshRenderer, TerrainDesc, ANIMATION_MANIFEST_SCHEMA_VERSION,
AUDIO_CLIP_SUB_ASSET_ID, COMPONENT_ANIMATION_CONTROLLER_DESC, COMPONENT_SKINNED_MESH_RENDERER,
NAVIGATION_GENERATED_ARTIFACT_DIRECTORY,
};
@@ -25,6 +25,7 @@ const MATERIAL_DESC: &str = "shared::components::MaterialDesc";
const MATERIAL_OVERRIDE: &str = "shared::components::MaterialOverride";
const STATIC_MESH_RENDERER: &str = "shared::components::StaticMeshRenderer";
const BRUSH_DESC: &str = "shared::components::BrushDesc";
const TERRAIN_DESC: &str = "shared::components::TerrainDesc";
const COLLIDER_DESC: &str = "shared::components::ColliderDesc";
const POST_PROCESS_VOLUME: &str = "shared::components::PostProcessVolumeDesc";
const PREFAB_INSTANCE: &str = "shared::components::PrefabInstance";
@@ -1905,6 +1906,53 @@ fn collect_component_references(
}
}
}
TERRAIN_DESC => match ron::from_str::<TerrainDesc>(&component.ron) {
Ok(terrain) => {
if let Err(error) = terrain.validate() {
report.findings.push(ProjectValidationFinding {
severity: ValidationSeverity::Error,
code: "terrain.invalid".into(),
source_path: source_path.to_string(),
owner_actor_id: actor_id.map(str::to_string),
reference: None,
message: error,
repair: "Repair the terrain dimensions, samples, layers, and chunk settings in the Inspector."
.into(),
});
}
if let Some(material) = &terrain.base_material {
collect_terrain_material_ref(
project_root,
report,
source_path,
actor_id,
"TerrainDesc.base_material",
material,
);
}
for (index, layer) in terrain.material_layers.iter().enumerate() {
if let Some(material) = &layer.material {
collect_terrain_material_ref(
project_root,
report,
source_path,
actor_id,
&format!("TerrainDesc.material_layers[{index}].material"),
material,
);
}
}
}
Err(error) => report.findings.push(ProjectValidationFinding {
severity: ValidationSeverity::Error,
code: "terrain.malformed".into(),
source_path: source_path.to_string(),
owner_actor_id: actor_id.map(str::to_string),
reference: None,
message: format!("could not parse TerrainDesc: {error}"),
repair: "Remove and recreate the Terrain component with the current editor.".into(),
}),
},
COLLIDER_DESC => validate_collider(
project_root,
report,
@@ -2736,6 +2784,64 @@ fn collect_material(
}
}
fn collect_terrain_material_ref(
project_root: &Path,
report: &mut ProjectValidationReport,
source_path: &str,
actor_id: Option<&str>,
property: &str,
reference: &EditorAssetRef,
) {
let Some(path) = reference
.source_path
.as_deref()
.filter(|path| !path.trim().is_empty())
else {
report.findings.push(ProjectValidationFinding {
severity: ValidationSeverity::Error,
code: "terrain.material_ref_unresolved".into(),
source_path: source_path.to_string(),
owner_actor_id: actor_id.map(str::to_string),
reference: Some(property.to_string()),
message: format!("{property} has no loadable project source path"),
repair:
"Assign an existing project Material or Material Instance in the Terrain inspector."
.into(),
});
return;
};
let path_value = Path::new(path);
if path_value.is_absolute()
|| path_value == Path::new("assets")
|| !path_value.starts_with("assets")
|| !path_value
.components()
.all(|component| matches!(component, Component::Normal(_)))
{
report.findings.push(ProjectValidationFinding {
severity: ValidationSeverity::Error,
code: "terrain.material_ref_invalid".into(),
source_path: source_path.to_string(),
owner_actor_id: actor_id.map(str::to_string),
reference: Some(path.to_string()),
message: format!(
"{property} source path must be a normalized project-relative path below assets/"
),
repair: "Reassign the terrain layer from a project Material or Material Instance."
.into(),
});
return;
}
add_reference(
project_root,
report,
source_path,
actor_id,
"terrain_material",
path,
);
}
fn collect_asset_ref(
project_root: &Path,
report: &mut ProjectValidationReport,
@@ -3888,6 +3994,132 @@ mod tests {
std::fs::remove_dir_all(root).unwrap();
}
fn write_terrain_scene(root: &Path, terrain: &TerrainDesc) {
let terrain = ron::to_string(terrain).unwrap();
std::fs::write(
root.join("assets/levels/main.scn.ron"),
format!(
"(schema_version:4,resources:{{}},entities:{{1:(components:{{\"shared::components::ActorId\":(\"terrain-owner\"),\"{TERRAIN_DESC}\":{terrain},}})}})"
),
)
.unwrap();
}
#[test]
fn terrain_material_references_are_actor_owned_dependencies() {
let root = fixture_root();
let mut terrain = TerrainDesc::flat(3);
terrain.base_material = Some(
EditorAssetRef::new("base-id", "material:instance", "Base")
.with_source_path("assets/materials/base.ron"),
);
terrain.material_layers = vec![shared::TerrainMaterialLayer {
material: Some(
EditorAssetRef::new("layer-id", "material:source", "Layer")
.with_source_path("assets/materials/layer.ron"),
),
uv_scale: 4.0,
}];
write_terrain_scene(&root, &terrain);
let report = validate_project(&root);
let dependencies = report
.dependencies
.iter()
.filter(|dependency| dependency.kind == "terrain_material")
.collect::<Vec<_>>();
assert_eq!(dependencies.len(), 2, "{:?}", report.dependencies);
assert!(dependencies
.iter()
.all(|dependency| dependency.owner_actor_id.as_deref() == Some("terrain-owner")));
assert_eq!(
report
.findings
.iter()
.filter(|finding| finding.code == "asset.missing")
.count(),
2
);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn terrain_material_references_require_runtime_source_paths() {
let root = fixture_root();
let mut terrain = TerrainDesc::flat(3);
terrain.base_material = Some(
EditorAssetRef::new("empty-path-id", "material:source", "Empty")
.with_source_path(" "),
);
terrain.material_layers = vec![
shared::TerrainMaterialLayer {
material: Some(EditorAssetRef::new(
"source-less-id",
"material:source",
"Source-less",
)),
uv_scale: 4.0,
},
shared::TerrainMaterialLayer {
material: Some(
EditorAssetRef::new("missing-id", "material:source", "Missing")
.with_source_path("assets/materials/missing.ron"),
),
uv_scale: 8.0,
},
];
write_terrain_scene(&root, &terrain);
let report = validate_project(&root);
let unresolved = report
.findings
.iter()
.filter(|finding| finding.code == "terrain.material_ref_unresolved")
.collect::<Vec<_>>();
assert_eq!(unresolved.len(), 2, "{:?}", report.findings);
assert!(unresolved
.iter()
.all(|finding| finding.owner_actor_id.as_deref() == Some("terrain-owner")));
assert!(report.findings.iter().any(|finding| {
finding.code == "asset.missing"
&& finding.owner_actor_id.as_deref() == Some("terrain-owner")
&& finding.reference.as_deref() == Some("assets/materials/missing.ron")
}));
assert!(report.dependencies.iter().any(|dependency| {
dependency.kind == "terrain_material"
&& dependency.reference == "assets/materials/missing.ron"
}));
assert!(!report.dependencies.iter().any(|dependency| {
dependency.kind == "generated_manifest"
&& (dependency.reference.contains("empty-path-id")
|| dependency.reference.contains("source-less-id"))
}));
assert!(!report.is_release_ready());
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn invalid_terrain_descriptor_blocks_project_validation() {
let root = fixture_root();
let mut terrain = TerrainDesc::flat(3);
terrain.heights.pop();
write_terrain_scene(&root, &terrain);
let report = validate_project(&root);
let finding = report
.findings
.iter()
.find(|finding| finding.code == "terrain.invalid")
.expect("invalid terrain should block release validation");
assert_eq!(finding.owner_actor_id.as_deref(), Some("terrain-owner"));
assert!(finding.message.contains("requires 9 height samples"));
assert!(!report.is_release_ready());
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn project_default_level_must_be_in_the_audited_levels_tree() {
let root = fixture_root();
File diff suppressed because it is too large. Load diff