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

+416 -116
View File
@@ -29,16 +29,18 @@ use crate::asset_db::{
find_asset_by_path, find_asset_mut_by_path, save_registry, update_import_settings,
ImportSettings, MaterialImportPolicy, ModelHierarchyMode, ModelPlacementMode,
};
use crate::assets::animation::load_animation_manifest;
use crate::assets::operators::{
apply_material_operator, apply_texture_operator, place_asset_operator, place_subasset_operator,
apply_material_operator, apply_texture_operator, assign_animation_clip_operator,
place_asset_operator, place_subasset_operator,
};
use crate::assets::static_mesh::{
load_static_mesh_manifest, material_id_from_label, part_id_from_label,
refresh_static_mesh_artifact,
};
use crate::assets::{
asset_cache_key, draw_asset_cell_with, invalidate_on_catalog_refresh, kind_icon,
prefetch_folder_thumbnails, AssetThumbnailCache, ThumbnailCacheSnapshot, ThumbnailStudio,
prefetch_folder_thumbnails, refresh_model_artifacts, AssetThumbnailCache,
ThumbnailCacheSnapshot, ThumbnailStudio,
};
use crate::ui::helpers::asset_label;
use crate::ui::theme::{panel_heading, ACCENT, BORDER, ELEVATED_BG, TEXT, TEXT_DIM, WIDGET_BG};
@@ -81,6 +83,7 @@ struct EmbeddedAsset {
thumbnail_key: String,
mesh_label: Option<String>,
material_label: Option<String>,
requires_scene_instance: bool,
}
fn fit_width(ui: &egui::Ui, min: f32, max: f32) -> f32 {
@@ -343,115 +346,188 @@ fn embedded_assets_for_asset(world: &World, asset: &EditorAsset) -> Vec<Embedded
else {
return Vec::new();
};
let Some(manifest_path) = record.import_settings.static_mesh_manifest_path.as_deref() else {
return Vec::new();
};
let Ok(manifest) = load_static_mesh_manifest(manifest_path) else {
return Vec::new();
};
let mut embedded = Vec::new();
for part in &manifest.parts {
let mesh_id = part_effective_id(part);
let material_label = part.material_label.clone();
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: mesh_id,
let static_manifest = record
.import_settings
.static_mesh_manifest_path
.as_deref()
.and_then(|path| load_static_mesh_manifest(path).ok());
let skinned_primitives = crate::assets::gltf_skinned_primitive_labels(parent_path.as_str());
if let Some(manifest) = static_manifest.as_ref() {
for part in &manifest.parts {
let mesh_id = part_effective_id(part);
let material_label = part.material_label.clone();
let requires_scene_instance = skinned_primitives.contains(&part.mesh_label);
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: mesh_id,
label: part.name.clone(),
kind: AssetSubAssetKind::Mesh,
source_path: None,
},
label: part.name.clone(),
kind: AssetSubAssetKind::Mesh,
source_path: None,
},
label: part.name.clone(),
kind: AssetSubAssetKind::Mesh,
detail: part
.source_mesh
.clone()
.unwrap_or_else(|| part.mesh_label.clone()),
texture_path: None,
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::Mesh,
&part_effective_id(part),
),
mesh_label: Some(part.mesh_label.clone()),
material_label,
});
}
let mut material_ids = HashSet::new();
for part in &manifest.parts {
let Some(material_id) = part_effective_material_id(part) else {
continue;
};
if !material_ids.insert(material_id.clone()) {
continue;
detail: if requires_scene_instance {
"Skinned | place model or animation clip".to_string()
} else {
part.source_mesh
.clone()
.unwrap_or_else(|| part.mesh_label.clone())
},
texture_path: None,
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::Mesh,
&part_effective_id(part),
),
mesh_label: Some(part.mesh_label.clone()),
material_label,
requires_scene_instance,
});
}
let label = if part.material_slot_name.trim().is_empty() {
part.material_label
.clone()
.unwrap_or_else(|| "Source Material".to_string())
} else {
part.material_slot_name.clone()
};
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: material_id,
label: label.clone(),
let mut material_ids = HashSet::new();
for part in &manifest.parts {
let Some(material_id) = part_effective_material_id(part) else {
continue;
};
if !material_ids.insert(material_id.clone()) {
continue;
}
let label = if part.material_slot_name.trim().is_empty() {
part.material_label
.clone()
.unwrap_or_else(|| "Source Material".to_string())
} else {
part.material_slot_name.clone()
};
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: material_id,
label: label.clone(),
kind: AssetSubAssetKind::Material,
source_path: None,
},
label,
kind: AssetSubAssetKind::Material,
source_path: None,
},
label,
kind: AssetSubAssetKind::Material,
detail: "Embedded source material".to_string(),
texture_path: None,
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::Material,
&part_effective_material_id(part).unwrap_or_else(|| {
material_id_from_label(
part.material_label
.as_deref()
.unwrap_or(&part.material_slot_name),
)
}),
),
mesh_label: None,
material_label: part.material_label.clone(),
});
detail: "Embedded source material".to_string(),
texture_path: None,
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::Material,
&part_effective_material_id(part).unwrap_or_else(|| {
material_id_from_label(
part.material_label
.as_deref()
.unwrap_or(&part.material_slot_name),
)
}),
),
mesh_label: None,
material_label: part.material_label.clone(),
requires_scene_instance: false,
});
}
let mut texture_paths = HashSet::new();
for dependency in &manifest.source.dependencies {
if !is_texture_path(dependency) || !texture_paths.insert(dependency.clone()) {
continue;
}
let label = Path::new(dependency)
.file_stem()
.and_then(|stem| stem.to_str())
.unwrap_or(dependency)
.to_string();
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: format!("texture:{}", stable_subasset_slug(dependency)),
label: label.clone(),
kind: AssetSubAssetKind::Texture,
source_path: Some(dependency.clone()),
},
label,
kind: AssetSubAssetKind::Texture,
detail: dependency.clone(),
texture_path: Some(dependency.clone()),
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::Texture,
&stable_subasset_slug(dependency),
),
mesh_label: None,
material_label: None,
requires_scene_instance: false,
});
}
}
let mut texture_paths = HashSet::new();
for dependency in &manifest.source.dependencies {
if !is_texture_path(dependency) || !texture_paths.insert(dependency.clone()) {
continue;
let animation_manifest = record
.import_settings
.animation_manifest_path
.as_deref()
.and_then(|path| load_animation_manifest(path).ok());
if let Some(manifest) = animation_manifest {
for skeleton in manifest.skeletons {
let signature = skeleton.signature.0;
let signature_short = signature.get(..8).unwrap_or(&signature);
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: skeleton.id.clone(),
label: skeleton.label.clone(),
kind: AssetSubAssetKind::Skeleton,
source_path: Some(parent_path.clone()),
},
label: skeleton.label,
kind: AssetSubAssetKind::Skeleton,
detail: format!(
"{} joints | rig {}",
skeleton.joint_paths.len(),
signature_short
),
texture_path: None,
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::Skeleton,
&skeleton.id,
),
mesh_label: None,
material_label: None,
requires_scene_instance: false,
});
}
for clip in manifest.clips {
let event_suffix = if clip.events.is_empty() {
String::new()
} else {
format!(" | {} events", clip.events.len())
};
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: clip.id.clone(),
label: clip.label.clone(),
kind: AssetSubAssetKind::AnimationClip,
source_path: Some(parent_path.clone()),
},
label: clip.label,
kind: AssetSubAssetKind::AnimationClip,
detail: format!("{:.2}s{event_suffix}", clip.duration_seconds),
texture_path: None,
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::AnimationClip,
&clip.id,
),
mesh_label: None,
material_label: None,
requires_scene_instance: false,
});
}
let label = Path::new(dependency)
.file_stem()
.and_then(|stem| stem.to_str())
.unwrap_or(dependency)
.to_string();
embedded.push(EmbeddedAsset {
selection: AssetSelection::SubAsset {
parent_path: parent_path.clone(),
sub_asset_id: format!("texture:{}", stable_subasset_slug(dependency)),
label: label.clone(),
kind: AssetSubAssetKind::Texture,
source_path: Some(dependency.clone()),
},
label,
kind: AssetSubAssetKind::Texture,
detail: dependency.clone(),
texture_path: Some(dependency.clone()),
thumbnail_key: subasset_thumbnail_key(
parent_path,
AssetSubAssetKind::Texture,
&stable_subasset_slug(dependency),
),
mesh_label: None,
material_label: None,
});
}
embedded
@@ -566,6 +642,7 @@ fn asset_toolbar(world: &mut World, ui: &mut egui::Ui) {
AssetKindFilter::Material,
"Materials",
);
ui.selectable_value(&mut state.kind_filter, AssetKindFilter::Audio, "Audio");
ui.selectable_value(&mut state.kind_filter, AssetKindFilter::Level, "Levels");
ui.selectable_value(&mut state.kind_filter, AssetKindFilter::Prefab, "Prefabs");
ui.selectable_value(
@@ -712,6 +789,9 @@ fn breadcrumb(world: &mut World, ui: &mut egui::Ui, current_folder: &str) {
fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &SelectedEntities) {
let selection = world.resource::<EditorAssets>().selected.clone();
let selected_embedded = selection
.as_ref()
.and_then(|selection| embedded_asset_for_selection(world, selection));
if let Some(AssetSelection::SubAsset { label, kind, .. }) = selection.clone() {
ui.add(
egui::Label::new(format!(
@@ -723,7 +803,14 @@ fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &Se
);
ui.horizontal_wrapped(|ui| match kind {
AssetSubAssetKind::Mesh => {
if ui.button("Place At Origin").clicked() {
if selected_embedded
.as_ref()
.is_some_and(|embedded| embedded.requires_scene_instance)
{
ui.small(
egui::RichText::new("Place the model or an animation clip").color(TEXT_DIM),
);
} else if ui.button("Place At Origin").clicked() {
if let Some(selection) = selection.as_ref() {
place_subasset_operator(world, selection.clone(), Vec3::ZERO);
}
@@ -739,6 +826,30 @@ fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &Se
AssetSubAssetKind::Material => {
ui.small(egui::RichText::new("Embedded source material").color(TEXT_DIM));
}
AssetSubAssetKind::Skeleton => {
ui.small(egui::RichText::new("Inspect-only rig metadata").color(TEXT_DIM));
}
AssetSubAssetKind::AnimationClip => {
let animated_actor = selected_entities
.as_slice()
.iter()
.copied()
.find(|entity| world.get::<shared::ModelRef>(*entity).is_some());
let action = if animated_actor.is_some() {
"Assign To Selected Actor"
} else {
"Create Animated Actor"
};
if ui.button(action).clicked() {
if let Some(selection) = selection.as_ref() {
if let Some(entity) = animated_actor {
assign_animation_clip_operator(world, selection.clone(), entity);
} else {
place_subasset_operator(world, selection.clone(), Vec3::ZERO);
}
}
}
}
});
} else if let Some(asset) = world.resource::<EditorAssets>().selected_asset().cloned() {
ui.add(egui::Label::new(format!("Selected: {}", asset_label(&asset))).truncate());
@@ -753,12 +864,15 @@ fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &Se
EditorAssetKind::Primitive(_)
| EditorAssetKind::Light(_)
| EditorAssetKind::Model
| EditorAssetKind::AudioClip
| EditorAssetKind::Prefab
| EditorAssetKind::Level
) && ui.button("Place At Origin").clicked()
{
place_asset_operator(world, asset.clone(), Vec3::ZERO);
}
if matches!(asset.kind, EditorAssetKind::Level) && ui.button("Open Scene").clicked() {
open_level_asset(world, &asset);
}
});
} else {
ui.label(egui::RichText::new("No asset selected").color(TEXT_DIM));
@@ -1143,6 +1257,7 @@ fn prefetch_embedded_thumbnails(
parent_path.clone(),
mesh_label,
embedded_asset.material_label.clone(),
embedded_asset.requires_scene_instance,
&mut studio,
);
}
@@ -1167,6 +1282,7 @@ fn prefetch_embedded_thumbnails(
&asset_server,
);
}
AssetSubAssetKind::Skeleton | AssetSubAssetKind::AnimationClip => {}
}
}
});
@@ -1201,6 +1317,13 @@ fn draw_embedded_asset_cell(
let thumb_size = thumbnail_size.clamp(44.0, 64.0);
let cell_size = egui::vec2(104.0, thumb_size + 50.0);
let (rect, response) = ui.allocate_exact_size(cell_size, egui::Sense::click_and_drag());
let response = if embedded.requires_scene_instance {
response.on_hover_text(
"Skinned primitives require their model hierarchy. Place the model or an animation clip instead.",
)
} else {
response
};
let fill = if selected {
crate::ui::theme::SELECTION_BG_MUTED
} else if response.hovered() {
@@ -1277,7 +1400,10 @@ fn draw_embedded_asset_cell(
.resource_mut::<EditorAssets>()
.select(embedded.selection.clone());
}
if response.drag_started() {
if response.drag_started()
&& embedded.kind != AssetSubAssetKind::Skeleton
&& !embedded.requires_scene_instance
{
world
.resource_mut::<EditorAssets>()
.start_drag(embedded.selection.clone());
@@ -1294,7 +1420,10 @@ fn compact_subasset_label(embedded: &EmbeddedAsset) -> String {
.split_once(" / ")
.map(|(head, _)| head)
.unwrap_or(&embedded.label),
AssetSubAssetKind::Material | AssetSubAssetKind::Texture => embedded.label.as_str(),
AssetSubAssetKind::Material
| AssetSubAssetKind::Texture
| AssetSubAssetKind::Skeleton
| AssetSubAssetKind::AnimationClip => embedded.label.as_str(),
};
compact_text(base, 16)
}
@@ -1339,6 +1468,8 @@ fn subasset_icon(kind: AssetSubAssetKind) -> Icon {
AssetSubAssetKind::Mesh => icons::CUBE,
AssetSubAssetKind::Material => icons::PALETTE,
AssetSubAssetKind::Texture => icons::IMAGE,
AssetSubAssetKind::Skeleton => icons::BONE,
AssetSubAssetKind::AnimationClip => icons::FILM_STRIP,
}
}
@@ -1347,6 +1478,8 @@ fn subasset_kind_label(kind: AssetSubAssetKind) -> &'static str {
AssetSubAssetKind::Mesh => "Mesh",
AssetSubAssetKind::Material => "Material",
AssetSubAssetKind::Texture => "Texture",
AssetSubAssetKind::Skeleton => "Skeleton",
AssetSubAssetKind::AnimationClip => "Animation Clip",
}
}
@@ -1741,6 +1874,39 @@ fn top_level_asset_details_panel(
ui.label(panel_heading("Material"));
material_asset_editor(world, ui, asset, path);
}
if matches!(asset.kind, EditorAssetKind::AudioClip) {
detail_row(ui, "Format", audio_format_label(path));
let previewing = world
.resource::<crate::play::audio_preview::AudioPreviewState>()
.clip_path
.as_deref()
== Some(path);
ui.horizontal_wrapped(|ui| {
if ui
.add_enabled(
!previewing,
egui::Button::new(format!("{} Audition", icons::PLAY.as_str())),
)
.clicked()
{
if let Err(error) =
crate::play::audio_preview::audition_audio_asset(world, asset)
{
world.resource_mut::<SceneIo>().status =
format!("Audio audition failed: {error}");
}
}
if ui
.add_enabled(
previewing,
egui::Button::new(format!("{} Stop", icons::STOP.as_str())),
)
.clicked()
{
crate::play::audio_preview::stop_audio_preview(world);
}
});
}
}
ui.separator();
@@ -1804,7 +1970,14 @@ fn subasset_details_panel(
ui.separator();
match embedded.kind {
AssetSubAssetKind::Mesh => {
if ui.button("Place At Origin").clicked() {
if embedded.requires_scene_instance {
ui.small(
egui::RichText::new(
"This skinned primitive needs its source hierarchy. Place the model or an animation clip instead.",
)
.color(TEXT_DIM),
);
} else if ui.button("Place At Origin").clicked() {
place_subasset_operator(world, selection.clone(), Vec3::ZERO);
}
}
@@ -1825,6 +1998,31 @@ fn subasset_details_panel(
.color(TEXT_DIM),
);
}
AssetSubAssetKind::Skeleton => {
ui.small(
egui::RichText::new("Skeleton metadata is generated from the model source.")
.color(TEXT_DIM),
);
}
AssetSubAssetKind::AnimationClip => {
let animated_actor = selected_entities
.as_slice()
.iter()
.copied()
.find(|entity| world.get::<shared::ModelRef>(*entity).is_some());
let action = if animated_actor.is_some() {
"Assign To Selected Actor"
} else {
"Create Animated Actor"
};
if ui.button(action).clicked() {
if let Some(entity) = animated_actor {
assign_animation_clip_operator(world, selection.clone(), entity);
} else {
place_subasset_operator(world, selection.clone(), Vec3::ZERO);
}
}
}
}
if ui.button("Select Parent Asset").clicked() {
world
@@ -1852,12 +2050,15 @@ fn asset_action_buttons(
EditorAssetKind::Primitive(_)
| EditorAssetKind::Light(_)
| EditorAssetKind::Model
| EditorAssetKind::AudioClip
| EditorAssetKind::Prefab
| EditorAssetKind::Level
) && ui.button("Place At Origin").clicked()
{
place_asset_operator(world, asset.clone(), Vec3::ZERO);
}
if matches!(asset.kind, EditorAssetKind::Level) && ui.button("Open Scene").clicked() {
open_level_asset(world, asset);
}
if matches!(asset.kind, EditorAssetKind::Model)
&& has_embedded_assets(world, asset)
&& ui.button("Toggle Contents").clicked()
@@ -1875,6 +2076,13 @@ fn asset_action_buttons(
});
}
fn open_level_asset(world: &mut World, asset: &EditorAsset) {
let Some(path) = asset.path.as_deref() else {
return;
};
world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::OpenPath(PathBuf::from(path)));
}
fn import_settings_editor(
world: &mut World,
ui: &mut egui::Ui,
@@ -1989,8 +2197,8 @@ fn apply_import_settings(
update_import_settings(&mut registry, path, settings);
if matches!(asset.kind, EditorAssetKind::Model) {
if let Some(record) = find_asset_mut_by_path(&mut registry, path) {
if let Err(error) = refresh_static_mesh_artifact(record) {
status = format!("Static mesh refresh failed for {}: {error}", asset.label);
if let Err(error) = refresh_model_artifacts(record) {
status = format!("Model artifact refresh failed for {}: {error}", asset.label);
warn!("{status}");
}
}
@@ -2705,6 +2913,7 @@ fn asset_matches_kind_filter(asset: &EditorAsset, filter: AssetKindFilter) -> bo
AssetKindFilter::Model => matches!(asset.kind, EditorAssetKind::Model),
AssetKindFilter::Texture => matches!(asset.kind, EditorAssetKind::Texture),
AssetKindFilter::Material => matches!(asset.kind, EditorAssetKind::Material),
AssetKindFilter::Audio => matches!(asset.kind, EditorAssetKind::AudioClip),
AssetKindFilter::Level => matches!(asset.kind, EditorAssetKind::Level),
AssetKindFilter::Prefab => matches!(asset.kind, EditorAssetKind::Prefab),
AssetKindFilter::Builtin => asset.path.is_none(),
@@ -2717,6 +2926,7 @@ fn kind_filter_label(filter: AssetKindFilter) -> &'static str {
AssetKindFilter::Model => "Models",
AssetKindFilter::Texture => "Textures",
AssetKindFilter::Material => "Materials",
AssetKindFilter::Audio => "Audio",
AssetKindFilter::Level => "Levels",
AssetKindFilter::Prefab => "Prefabs",
AssetKindFilter::Builtin => "Built-ins",
@@ -2739,6 +2949,7 @@ fn kind_label(kind: &EditorAssetKind) -> &'static str {
EditorAssetKind::Model => "Model",
EditorAssetKind::Texture => "Texture",
EditorAssetKind::Material => "Material",
EditorAssetKind::AudioClip => "Audio Clip",
EditorAssetKind::Level => "Level",
EditorAssetKind::Prefab => "Prefab",
EditorAssetKind::PostProcessVolume => "Post Process Volume",
@@ -2752,6 +2963,22 @@ fn file_size(path: &str) -> Option<u64> {
fs::metadata(path).ok().map(|metadata| metadata.len())
}
fn audio_format_label(path: &str) -> &'static str {
match Path::new(path)
.extension()
.and_then(|extension| extension.to_str())
.map(str::to_ascii_lowercase)
.as_deref()
{
Some("ogg" | "oga") => "Ogg audio",
Some("spx") => "Speex",
Some("wav") => "WAV",
Some("mp3") => "MP3",
Some("flac") => "FLAC",
_ => "Unknown",
}
}
fn modified_time(path: &str) -> Option<SystemTime> {
fs::metadata(path)
.ok()
@@ -2813,13 +3040,17 @@ fn asset_context_menu(
EditorAssetKind::Primitive(_)
| EditorAssetKind::Light(_)
| EditorAssetKind::Model
| EditorAssetKind::AudioClip
| EditorAssetKind::Prefab
| EditorAssetKind::Level
) && ui.button("Place at Origin").clicked()
{
place_asset_operator(world, asset.clone(), Vec3::ZERO);
ui.close();
}
if matches!(asset.kind, EditorAssetKind::Level) && ui.button("Open Scene").clicked() {
open_level_asset(world, asset);
ui.close();
}
if matches!(asset.kind, EditorAssetKind::Model) && has_embedded_assets(world, asset) {
let expanded = asset.path.as_deref().is_some_and(|path| {
world
@@ -2888,7 +3119,12 @@ fn subasset_context_menu(
}
match embedded.kind {
AssetSubAssetKind::Mesh => {
if ui.button("Place at Origin").clicked() {
if embedded.requires_scene_instance {
ui.label(
egui::RichText::new("Skinned mesh: place parent model or animation clip")
.color(TEXT_DIM),
);
} else if ui.button("Place at Origin").clicked() {
place_subasset_operator(world, embedded.selection.clone(), Vec3::ZERO);
ui.close();
}
@@ -2906,8 +3142,35 @@ fn subasset_context_menu(
AssetSubAssetKind::Material => {
ui.label(egui::RichText::new("Embedded source material").color(TEXT_DIM));
}
AssetSubAssetKind::Skeleton => {
ui.label(egui::RichText::new("Inspect-only rig metadata").color(TEXT_DIM));
}
AssetSubAssetKind::AnimationClip => {
let animated_actor = selected_entities
.as_slice()
.iter()
.copied()
.find(|entity| world.get::<shared::ModelRef>(*entity).is_some());
let action = if animated_actor.is_some() {
"Assign To Selected Actor"
} else {
"Create Animated Actor"
};
if ui.button(action).clicked() {
if let Some(entity) = animated_actor {
assign_animation_clip_operator(world, embedded.selection.clone(), entity);
} else {
place_subasset_operator(world, embedded.selection.clone(), Vec3::ZERO);
}
ui.close();
}
}
}
if ui.button("Regenerate Thumbnail").clicked() {
if matches!(
embedded.kind,
AssetSubAssetKind::Mesh | AssetSubAssetKind::Material | AssetSubAssetKind::Texture
) && ui.button("Regenerate Thumbnail").clicked()
{
regenerate_subasset_thumbnail(world, embedded);
ui.close();
}
@@ -2969,6 +3232,7 @@ fn regenerate_subasset_thumbnail(world: &mut World, embedded: &EmbeddedAsset) {
parent_path.clone(),
mesh_label,
embedded.material_label.clone(),
embedded.requires_scene_instance,
&mut studio,
);
});
@@ -2991,6 +3255,7 @@ fn regenerate_subasset_thumbnail(world: &mut World, embedded: &EmbeddedAsset) {
cache.request_texture(key.clone(), texture_path, &asset_server);
}
}
AssetSubAssetKind::Skeleton | AssetSubAssetKind::AnimationClip => {}
}
});
world.resource_mut::<SceneIo>().status =
@@ -3004,7 +3269,7 @@ fn reimport_asset(world: &mut World, asset: &EditorAsset) {
let mut status = format!("Reimported {}", asset.label);
if let Some(mut registry) = world.get_resource_mut::<crate::asset_db::AssetRegistry>() {
if let Some(record) = find_asset_mut_by_path(&mut registry, path) {
if let Err(error) = refresh_static_mesh_artifact(record) {
if let Err(error) = refresh_model_artifacts(record) {
status = format!("Reimport failed for {}: {error}", asset.label);
warn!("{status}");
}
@@ -3038,6 +3303,9 @@ fn build_delete_request(world: &World, asset: &EditorAsset) -> Option<AssetDelet
if let Some(manifest) = record.import_settings.static_mesh_manifest_path {
files.push(manifest);
}
if let Some(manifest) = record.import_settings.animation_manifest_path {
files.push(manifest);
}
if !record.dependencies.is_empty() {
warnings.push(format!(
"{} imported dependencies will be kept because they may be shared.",
@@ -3190,3 +3458,35 @@ fn dedup_strings(values: &mut Vec<String>) {
let mut seen = HashSet::new();
values.retain(|value| seen.insert(value.clone()));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn audio_filter_matches_only_audio_clips() {
let audio = EditorAsset {
label: "Impact".into(),
path: Some("assets/audio/impact.ogg".into()),
folder_path: "assets/audio".into(),
kind: EditorAssetKind::AudioClip,
};
let texture = EditorAsset {
kind: EditorAssetKind::Texture,
..audio.clone()
};
assert!(asset_matches_kind_filter(&audio, AssetKindFilter::Audio));
assert!(!asset_matches_kind_filter(&texture, AssetKindFilter::Audio));
assert_eq!(kind_filter_label(AssetKindFilter::Audio), "Audio");
}
#[test]
fn audio_details_label_supported_formats() {
assert_eq!(audio_format_label("assets/audio/music.oga"), "Ogg audio");
assert_eq!(audio_format_label("assets/audio/voice.spx"), "Speex");
assert_eq!(audio_format_label("assets/audio/source.WAV"), "WAV");
assert_eq!(audio_format_label("assets/audio/source.mp3"), "MP3");
assert_eq!(audio_format_label("assets/audio/source.flac"), "FLAC");
}
}
@@ -28,6 +28,7 @@ pub(crate) enum AssetKindFilter {
Model,
Texture,
Material,
Audio,
Level,
Prefab,
Builtin,