1081 lines
36 KiB
Rust
1081 lines
36 KiB
Rust
//! Docked project material catalog, usage view, and editor entry point.
|
|
|
|
use std::collections::HashMap;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use bevy::prelude::*;
|
|
use bevy_egui::egui;
|
|
use bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities;
|
|
use egui_phosphor_icons::icons;
|
|
use shared::{
|
|
BrushDesc, MaterialAsset, MaterialDesc, MaterialInstanceAsset, SkinnedMeshRenderer,
|
|
StaticMeshRenderer,
|
|
};
|
|
|
|
use crate::asset_db::{ensure_asset_record, AssetRegistry};
|
|
use crate::assets::{
|
|
draw_asset_cell_with, invalidate_on_catalog_refresh, prefetch_asset_thumbnails, AssetSelection,
|
|
AssetThumbnailCache, EditorAsset, EditorAssetKind, EditorAssets, ThumbnailCacheSnapshot,
|
|
};
|
|
use crate::project::collaboration::{publish_authored_file, FileSnapshot, FileWriteIntent};
|
|
use crate::scene_io::SceneIo;
|
|
|
|
use super::asset_browser::{create_material_instance_from_base, top_level_asset_details_panel};
|
|
use super::theme::{
|
|
panel_heading, ACCENT, BORDER, ELEVATED_BG, ERROR, SELECTION, SUCCESS, TEXT, TEXT_DIM,
|
|
TEXT_MUTED, WIDGET_BG,
|
|
};
|
|
use super::widgets::{icon_button_small, phosphor_icon, tool_button};
|
|
use super::{DockTabRequest, EditorTab};
|
|
|
|
const MATERIALS_FOLDER: &str = "assets/materials";
|
|
const DETAILS_BREAKPOINT: f32 = 760.0;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum MaterialLibraryFilter {
|
|
All,
|
|
Materials,
|
|
Instances,
|
|
Used,
|
|
Unused,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum MaterialLibraryView {
|
|
Grid,
|
|
List,
|
|
}
|
|
|
|
#[derive(Resource, Debug)]
|
|
pub struct MaterialLibraryState {
|
|
search: String,
|
|
filter: MaterialLibraryFilter,
|
|
view: MaterialLibraryView,
|
|
thumbnail_size: f32,
|
|
show_details: bool,
|
|
}
|
|
|
|
impl Default for MaterialLibraryState {
|
|
fn default() -> Self {
|
|
Self {
|
|
search: String::new(),
|
|
filter: MaterialLibraryFilter::All,
|
|
view: MaterialLibraryView::Grid,
|
|
thumbnail_size: 72.0,
|
|
show_details: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum MaterialDocumentKind {
|
|
Material,
|
|
Instance,
|
|
Invalid,
|
|
}
|
|
|
|
impl MaterialDocumentKind {
|
|
fn short_label(self) -> &'static str {
|
|
match self {
|
|
Self::Material => "MAT",
|
|
Self::Instance => "MI",
|
|
Self::Invalid => "ERR",
|
|
}
|
|
}
|
|
|
|
fn label(self) -> &'static str {
|
|
match self {
|
|
Self::Material => "Material",
|
|
Self::Instance => "Material Instance",
|
|
Self::Invalid => "Invalid Material",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct MaterialLibraryRow {
|
|
asset: EditorAsset,
|
|
selection: AssetSelection,
|
|
kind: MaterialDocumentKind,
|
|
scene_users: Vec<MaterialSceneUser>,
|
|
dependent_instances: usize,
|
|
error: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct MaterialSceneUser {
|
|
entity: Entity,
|
|
actor_label: String,
|
|
detail: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct CachedMaterialDocument {
|
|
asset: EditorAsset,
|
|
selection: AssetSelection,
|
|
kind: MaterialDocumentKind,
|
|
base_path: Option<String>,
|
|
error: Option<String>,
|
|
}
|
|
|
|
#[derive(Resource, Debug, Default)]
|
|
pub struct MaterialLibraryCatalog {
|
|
documents: Vec<CachedMaterialDocument>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct MaterialLibrarySnapshot {
|
|
search: String,
|
|
filter: MaterialLibraryFilter,
|
|
view: MaterialLibraryView,
|
|
thumbnail_size: f32,
|
|
show_details: bool,
|
|
}
|
|
|
|
pub fn material_library_ui(
|
|
world: &mut World,
|
|
ui: &mut egui::Ui,
|
|
selected_entities: &mut SelectedEntities,
|
|
) {
|
|
let selected = world.resource::<EditorAssets>().selected.clone();
|
|
let rows = material_rows(world);
|
|
let visible_rows = {
|
|
let state = world.resource::<MaterialLibraryState>();
|
|
rows.iter()
|
|
.filter(|row| row_matches(row, state))
|
|
.cloned()
|
|
.collect::<Vec<_>>()
|
|
};
|
|
let visible_assets = visible_rows
|
|
.iter()
|
|
.map(|row| row.asset.clone())
|
|
.collect::<Vec<_>>();
|
|
prefetch_asset_thumbnails(world, &visible_assets);
|
|
let cache = world.resource::<AssetThumbnailCache>().snapshot();
|
|
|
|
material_library_toolbar(world, ui, &rows, &selected);
|
|
ui.separator();
|
|
|
|
let state = {
|
|
let state = world.resource::<MaterialLibraryState>();
|
|
MaterialLibrarySnapshot {
|
|
search: state.search.clone(),
|
|
filter: state.filter,
|
|
view: state.view,
|
|
thumbnail_size: state.thumbnail_size,
|
|
show_details: state.show_details,
|
|
}
|
|
};
|
|
let selected_row = selected
|
|
.as_ref()
|
|
.and_then(|selection| rows.iter().find(|row| &row.selection == selection))
|
|
.cloned();
|
|
let wide = ui.available_width() >= DETAILS_BREAKPOINT;
|
|
|
|
if !wide && state.show_details {
|
|
if let Some(row) = selected_row.as_ref() {
|
|
egui::ScrollArea::vertical()
|
|
.id_salt("material_library_narrow_details")
|
|
.auto_shrink([false, false])
|
|
.show(ui, |ui| {
|
|
material_usage_ui(world, ui, row, selected_entities);
|
|
top_level_asset_details_panel(world, ui, selected_entities, &row.asset);
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
|
|
ui.horizontal(|ui| {
|
|
let details_width = if wide && state.show_details {
|
|
(ui.available_width() * 0.32).clamp(320.0, 430.0)
|
|
} else {
|
|
0.0
|
|
};
|
|
let catalog_width = (ui.available_width() - details_width - 10.0).max(1.0);
|
|
ui.allocate_ui_with_layout(
|
|
egui::vec2(catalog_width, ui.available_height()),
|
|
egui::Layout::top_down(egui::Align::Min),
|
|
|ui| {
|
|
material_catalog_header(ui, &visible_rows, &rows, &state);
|
|
egui::ScrollArea::vertical()
|
|
.id_salt("material_library_catalog")
|
|
.auto_shrink([false, false])
|
|
.show(ui, |ui| {
|
|
if visible_rows.is_empty() {
|
|
ui.label(
|
|
egui::RichText::new("No materials match the current filters.")
|
|
.color(TEXT_DIM),
|
|
);
|
|
} else if state.view == MaterialLibraryView::Grid {
|
|
material_grid(
|
|
world,
|
|
ui,
|
|
&visible_rows,
|
|
&selected,
|
|
&cache,
|
|
state.thumbnail_size,
|
|
selected_entities,
|
|
);
|
|
} else {
|
|
material_list(
|
|
world,
|
|
ui,
|
|
&visible_rows,
|
|
&selected,
|
|
&cache,
|
|
selected_entities,
|
|
);
|
|
}
|
|
});
|
|
},
|
|
);
|
|
|
|
if details_width > 0.0 {
|
|
ui.separator();
|
|
ui.allocate_ui_with_layout(
|
|
egui::vec2(details_width, ui.available_height()),
|
|
egui::Layout::top_down(egui::Align::Min),
|
|
|ui| {
|
|
egui::ScrollArea::vertical()
|
|
.id_salt("material_library_details")
|
|
.auto_shrink([false, false])
|
|
.show(ui, |ui| {
|
|
if let Some(row) = selected_row.as_ref() {
|
|
material_usage_ui(world, ui, row, selected_entities);
|
|
top_level_asset_details_panel(
|
|
world,
|
|
ui,
|
|
selected_entities,
|
|
&row.asset,
|
|
);
|
|
} else {
|
|
ui.label(panel_heading("Material Details"));
|
|
ui.separator();
|
|
ui.label(
|
|
egui::RichText::new("No material selected").color(TEXT_DIM),
|
|
);
|
|
}
|
|
});
|
|
},
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
fn material_library_toolbar(
|
|
world: &mut World,
|
|
ui: &mut egui::Ui,
|
|
rows: &[MaterialLibraryRow],
|
|
selected: &Option<AssetSelection>,
|
|
) {
|
|
let selected_base = selected.as_ref().and_then(|selection| {
|
|
rows.iter()
|
|
.find(|row| &row.selection == selection && row.kind == MaterialDocumentKind::Material)
|
|
.map(|row| row.asset.clone())
|
|
});
|
|
let mut create_material = false;
|
|
let mut create_instance = false;
|
|
let mut reveal_in_assets = false;
|
|
let mut refresh = false;
|
|
ui.horizontal(|ui| {
|
|
if icon_button_small(ui, icons::ARROWS_CLOCKWISE, "Refresh materials").clicked() {
|
|
refresh = true;
|
|
}
|
|
if ui
|
|
.button(format!("{} Material", icons::PLUS.as_str()))
|
|
.on_hover_text("Create Material")
|
|
.clicked()
|
|
{
|
|
create_material = true;
|
|
}
|
|
if ui
|
|
.add_enabled(
|
|
selected_base.is_some(),
|
|
egui::Button::new(format!("{} Instance", icons::COPY.as_str())),
|
|
)
|
|
.on_hover_text("Create Material Instance from selected Material")
|
|
.clicked()
|
|
{
|
|
create_instance = true;
|
|
}
|
|
if icon_button_small(ui, icons::FOLDER_OPEN, "Show in Asset Browser").clicked() {
|
|
reveal_in_assets = true;
|
|
}
|
|
|
|
ui.separator();
|
|
let mut state = world.resource_mut::<MaterialLibraryState>();
|
|
ui.label(phosphor_icon(icons::MAGNIFYING_GLASS, 14.0).color(TEXT_DIM));
|
|
ui.add(
|
|
egui::TextEdit::singleline(&mut state.search)
|
|
.hint_text("Search materials...")
|
|
.desired_width((ui.available_width() * 0.22).clamp(120.0, 220.0)),
|
|
);
|
|
ui.separator();
|
|
for (filter, label) in [
|
|
(MaterialLibraryFilter::All, "All"),
|
|
(MaterialLibraryFilter::Materials, "Materials"),
|
|
(MaterialLibraryFilter::Instances, "Instances"),
|
|
(MaterialLibraryFilter::Used, "Used"),
|
|
(MaterialLibraryFilter::Unused, "Unused"),
|
|
] {
|
|
ui.selectable_value(&mut state.filter, filter, label);
|
|
}
|
|
ui.separator();
|
|
if tool_button(
|
|
ui,
|
|
icons::GRID_FOUR,
|
|
state.view == MaterialLibraryView::Grid,
|
|
"Grid view",
|
|
)
|
|
.clicked()
|
|
{
|
|
state.view = MaterialLibraryView::Grid;
|
|
}
|
|
if tool_button(
|
|
ui,
|
|
icons::LIST,
|
|
state.view == MaterialLibraryView::List,
|
|
"List view",
|
|
)
|
|
.clicked()
|
|
{
|
|
state.view = MaterialLibraryView::List;
|
|
}
|
|
if tool_button(ui, icons::SLIDERS, state.show_details, "Material details").clicked() {
|
|
state.show_details = !state.show_details;
|
|
}
|
|
if state.view == MaterialLibraryView::Grid && ui.available_width() > 120.0 {
|
|
ui.add_sized(
|
|
[88.0, 20.0],
|
|
egui::Slider::new(&mut state.thumbnail_size, 48.0..=112.0).show_value(false),
|
|
);
|
|
}
|
|
});
|
|
|
|
if refresh {
|
|
world.resource_mut::<EditorAssets>().refresh();
|
|
invalidate_on_catalog_refresh(world);
|
|
}
|
|
if create_material {
|
|
if let Err(error) = create_material_asset(world) {
|
|
world.resource_mut::<SceneIo>().status = error;
|
|
}
|
|
}
|
|
if create_instance {
|
|
if let Some(asset) = selected_base {
|
|
if let Some(path) = asset.path.as_deref() {
|
|
create_material_instance_from_base(world, path, &asset.label);
|
|
}
|
|
}
|
|
}
|
|
if reveal_in_assets {
|
|
if let Some(asset) = selected
|
|
.as_ref()
|
|
.and_then(|selection| rows.iter().find(|row| &row.selection == selection))
|
|
{
|
|
world.resource_mut::<EditorAssets>().current_folder = asset.asset.folder_path.clone();
|
|
world.resource_mut::<DockTabRequest>().0 = Some(EditorTab::AssetBrowser);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn material_catalog_header(
|
|
ui: &mut egui::Ui,
|
|
visible: &[MaterialLibraryRow],
|
|
all: &[MaterialLibraryRow],
|
|
state: &MaterialLibrarySnapshot,
|
|
) {
|
|
ui.horizontal_wrapped(|ui| {
|
|
ui.label(panel_heading("Project Materials"));
|
|
ui.label(
|
|
egui::RichText::new(format!("{} / {}", visible.len(), all.len()))
|
|
.monospace()
|
|
.color(TEXT_DIM),
|
|
);
|
|
if !state.search.trim().is_empty() {
|
|
ui.label(egui::RichText::new(format!("\"{}\"", state.search)).color(ACCENT));
|
|
}
|
|
let filter = match state.filter {
|
|
MaterialLibraryFilter::All => None,
|
|
MaterialLibraryFilter::Materials => Some("Materials"),
|
|
MaterialLibraryFilter::Instances => Some("Instances"),
|
|
MaterialLibraryFilter::Used => Some("Used in scene"),
|
|
MaterialLibraryFilter::Unused => Some("Unused in scene"),
|
|
};
|
|
if let Some(filter) = filter {
|
|
ui.label(egui::RichText::new(filter).color(SELECTION).small());
|
|
}
|
|
});
|
|
}
|
|
|
|
fn material_grid(
|
|
world: &mut World,
|
|
ui: &mut egui::Ui,
|
|
rows: &[MaterialLibraryRow],
|
|
selected: &Option<AssetSelection>,
|
|
cache: &ThumbnailCacheSnapshot,
|
|
thumbnail_size: f32,
|
|
selected_entities: &mut SelectedEntities,
|
|
) {
|
|
let cell_width = thumbnail_size.clamp(48.0, 112.0) + 26.0;
|
|
let columns = (ui.available_width() / cell_width).floor().max(1.0) as usize;
|
|
for chunk in rows.chunks(columns) {
|
|
ui.horizontal(|ui| {
|
|
for row in chunk {
|
|
let response = draw_asset_cell_with(
|
|
ui,
|
|
&row.asset,
|
|
cache.texture_for(&row.asset),
|
|
cache.is_pending(&row.asset),
|
|
cache.is_failed(&row.asset).then_some("failed"),
|
|
selected.as_ref() == Some(&row.selection),
|
|
thumbnail_size,
|
|
);
|
|
draw_material_grid_badges(ui, &response, row);
|
|
handle_material_response(world, response, row, selected_entities);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
fn draw_material_grid_badges(ui: &egui::Ui, response: &egui::Response, row: &MaterialLibraryRow) {
|
|
let kind_color = match row.kind {
|
|
MaterialDocumentKind::Material => ACCENT,
|
|
MaterialDocumentKind::Instance => SELECTION,
|
|
MaterialDocumentKind::Invalid => ERROR,
|
|
};
|
|
let kind_rect = egui::Rect::from_min_size(
|
|
response.rect.left_top() + egui::vec2(6.0, 6.0),
|
|
egui::vec2(30.0, 17.0),
|
|
);
|
|
ui.painter().rect(
|
|
kind_rect,
|
|
3.0,
|
|
ELEVATED_BG,
|
|
egui::Stroke::new(1.0, kind_color),
|
|
egui::StrokeKind::Inside,
|
|
);
|
|
ui.painter().text(
|
|
kind_rect.center(),
|
|
egui::Align2::CENTER_CENTER,
|
|
row.kind.short_label(),
|
|
egui::FontId::monospace(9.0),
|
|
kind_color,
|
|
);
|
|
if !row.scene_users.is_empty() {
|
|
let usage_rect = egui::Rect::from_min_size(
|
|
response.rect.right_top() + egui::vec2(-35.0, 6.0),
|
|
egui::vec2(29.0, 17.0),
|
|
);
|
|
ui.painter().rect(
|
|
usage_rect,
|
|
3.0,
|
|
ELEVATED_BG,
|
|
egui::Stroke::new(1.0, SUCCESS),
|
|
egui::StrokeKind::Inside,
|
|
);
|
|
ui.painter().text(
|
|
usage_rect.center(),
|
|
egui::Align2::CENTER_CENTER,
|
|
row.scene_users.len().to_string(),
|
|
egui::FontId::monospace(9.0),
|
|
SUCCESS,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn material_list(
|
|
world: &mut World,
|
|
ui: &mut egui::Ui,
|
|
rows: &[MaterialLibraryRow],
|
|
selected: &Option<AssetSelection>,
|
|
cache: &ThumbnailCacheSnapshot,
|
|
selected_entities: &mut SelectedEntities,
|
|
) {
|
|
for row in rows {
|
|
let is_selected = selected.as_ref() == Some(&row.selection);
|
|
let height = 42.0;
|
|
let (rect, response) = ui.allocate_exact_size(
|
|
egui::vec2(ui.available_width(), height),
|
|
egui::Sense::click_and_drag(),
|
|
);
|
|
ui.painter().rect(
|
|
rect,
|
|
3.0,
|
|
if is_selected {
|
|
crate::ui::theme::SELECTION_BG_MUTED
|
|
} else if response.hovered() {
|
|
ELEVATED_BG
|
|
} else {
|
|
WIDGET_BG
|
|
},
|
|
egui::Stroke::new(1.0, if is_selected { SELECTION } else { BORDER }),
|
|
egui::StrokeKind::Inside,
|
|
);
|
|
let thumb_rect = egui::Rect::from_min_size(
|
|
rect.left_top() + egui::vec2(5.0, 5.0),
|
|
egui::vec2(32.0, 32.0),
|
|
);
|
|
if let Some(texture) = cache.texture_for(&row.asset) {
|
|
ui.painter().image(
|
|
texture,
|
|
thumb_rect,
|
|
egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)),
|
|
egui::Color32::WHITE,
|
|
);
|
|
} else {
|
|
ui.painter().text(
|
|
thumb_rect.center(),
|
|
egui::Align2::CENTER_CENTER,
|
|
icons::PALETTE.as_str(),
|
|
egui::FontId::new(20.0, egui::FontFamily::Name("phosphor-regular".into())),
|
|
if row.error.is_some() { ERROR } else { TEXT },
|
|
);
|
|
}
|
|
ui.painter().text(
|
|
egui::pos2(44.0 + rect.left(), rect.center().y - 7.0),
|
|
egui::Align2::LEFT_CENTER,
|
|
row.asset.label.as_str(),
|
|
egui::FontId::proportional(13.0),
|
|
TEXT,
|
|
);
|
|
ui.painter().text(
|
|
egui::pos2(44.0 + rect.left(), rect.center().y + 9.0),
|
|
egui::Align2::LEFT_CENTER,
|
|
row.asset.path.as_deref().unwrap_or(""),
|
|
egui::FontId::monospace(10.0),
|
|
TEXT_MUTED,
|
|
);
|
|
ui.painter().text(
|
|
rect.right_center() - egui::vec2(10.0, 0.0),
|
|
egui::Align2::RIGHT_CENTER,
|
|
format!(
|
|
"{} | {} scene | {} instances",
|
|
row.kind.label(),
|
|
row.scene_users.len(),
|
|
row.dependent_instances
|
|
),
|
|
egui::FontId::proportional(11.0),
|
|
if row.error.is_some() { ERROR } else { TEXT_DIM },
|
|
);
|
|
handle_material_response(world, response, row, selected_entities);
|
|
}
|
|
}
|
|
|
|
fn handle_material_response(
|
|
world: &mut World,
|
|
response: egui::Response,
|
|
row: &MaterialLibraryRow,
|
|
selected_entities: &mut SelectedEntities,
|
|
) {
|
|
let response = response.on_hover_ui(|ui| {
|
|
ui.strong(&row.asset.label);
|
|
ui.label(row.kind.label());
|
|
ui.monospace(row.asset.path.as_deref().unwrap_or(""));
|
|
ui.label(format!("Scene references: {}", row.scene_users.len()));
|
|
if row.dependent_instances > 0 {
|
|
ui.label(format!("Derived instances: {}", row.dependent_instances));
|
|
}
|
|
if let Some(error) = row.error.as_ref() {
|
|
ui.colored_label(ERROR, error);
|
|
}
|
|
});
|
|
if response.clicked() {
|
|
world
|
|
.resource_mut::<EditorAssets>()
|
|
.select(row.selection.clone());
|
|
}
|
|
if response.drag_started() && row.error.is_none() {
|
|
world
|
|
.resource_mut::<EditorAssets>()
|
|
.start_drag(row.selection.clone());
|
|
}
|
|
response.context_menu(|ui| {
|
|
if row.kind == MaterialDocumentKind::Material && ui.button("Create Instance").clicked() {
|
|
if let Some(path) = row.asset.path.as_deref() {
|
|
create_material_instance_from_base(world, path, &row.asset.label);
|
|
}
|
|
ui.close();
|
|
}
|
|
if !row.scene_users.is_empty() {
|
|
ui.menu_button("Scene Users", |ui| {
|
|
for user in &row.scene_users {
|
|
if ui
|
|
.button(format!("{} / {}", user.actor_label, user.detail))
|
|
.clicked()
|
|
{
|
|
select_scene_user(world, selected_entities, user.entity);
|
|
ui.close();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
if ui.button("Show in Asset Browser").clicked() {
|
|
world.resource_mut::<EditorAssets>().current_folder = row.asset.folder_path.clone();
|
|
world
|
|
.resource_mut::<EditorAssets>()
|
|
.select(row.selection.clone());
|
|
world.resource_mut::<DockTabRequest>().0 = Some(EditorTab::AssetBrowser);
|
|
ui.close();
|
|
}
|
|
});
|
|
}
|
|
|
|
fn material_rows(world: &mut World) -> Vec<MaterialLibraryRow> {
|
|
let usages = collect_scene_material_usage(world);
|
|
let documents = world.resource::<MaterialLibraryCatalog>().documents.clone();
|
|
let mut instance_dependencies = HashMap::<String, usize>::new();
|
|
for document in &documents {
|
|
if let Some(base_path) = document.base_path.as_deref() {
|
|
*instance_dependencies
|
|
.entry(base_path.to_string())
|
|
.or_default() += 1;
|
|
}
|
|
}
|
|
|
|
let mut rows = documents
|
|
.into_iter()
|
|
.map(|document| {
|
|
let normalized = normalize_path(document.asset.path.as_deref().unwrap_or_default());
|
|
MaterialLibraryRow {
|
|
selection: document.selection,
|
|
scene_users: usages.get(&normalized).cloned().unwrap_or_default(),
|
|
dependent_instances: instance_dependencies
|
|
.get(&normalized)
|
|
.copied()
|
|
.unwrap_or_default(),
|
|
asset: document.asset,
|
|
kind: document.kind,
|
|
error: document.error,
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
rows.sort_by(|left, right| {
|
|
left.asset
|
|
.label
|
|
.to_ascii_lowercase()
|
|
.cmp(&right.asset.label.to_ascii_lowercase())
|
|
.then_with(|| left.asset.path.cmp(&right.asset.path))
|
|
});
|
|
rows
|
|
}
|
|
|
|
fn row_matches(row: &MaterialLibraryRow, state: &MaterialLibraryState) -> bool {
|
|
let search = state.search.trim().to_ascii_lowercase();
|
|
let search_matches = search.is_empty()
|
|
|| row.asset.label.to_ascii_lowercase().contains(&search)
|
|
|| row
|
|
.asset
|
|
.path
|
|
.as_deref()
|
|
.is_some_and(|path| path.to_ascii_lowercase().contains(&search));
|
|
let filter_matches = match state.filter {
|
|
MaterialLibraryFilter::All => true,
|
|
MaterialLibraryFilter::Materials => row.kind == MaterialDocumentKind::Material,
|
|
MaterialLibraryFilter::Instances => row.kind == MaterialDocumentKind::Instance,
|
|
MaterialLibraryFilter::Used => !row.scene_users.is_empty(),
|
|
MaterialLibraryFilter::Unused => row.scene_users.is_empty(),
|
|
};
|
|
search_matches && filter_matches
|
|
}
|
|
|
|
fn collect_scene_material_usage(world: &mut World) -> HashMap<String, Vec<MaterialSceneUser>> {
|
|
let mut usages = HashMap::new();
|
|
let mut static_renderers = world.query::<(Entity, &StaticMeshRenderer, Option<&Name>)>();
|
|
for (entity, renderer, name) in static_renderers.iter(world) {
|
|
for slot in &renderer.materials.slots {
|
|
if let Some(path) = slot
|
|
.effective_material()
|
|
.and_then(|reference| reference.0.source_path.as_deref())
|
|
{
|
|
add_usage(
|
|
&mut usages,
|
|
path,
|
|
MaterialSceneUser {
|
|
entity,
|
|
actor_label: actor_label(entity, name),
|
|
detail: format!("Static / {}", slot.name),
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
let mut skinned_renderers = world.query::<(Entity, &SkinnedMeshRenderer, Option<&Name>)>();
|
|
for (entity, renderer, name) in skinned_renderers.iter(world) {
|
|
for slot in &renderer.materials.slots {
|
|
if let Some(path) = slot
|
|
.effective_material()
|
|
.and_then(|reference| reference.0.source_path.as_deref())
|
|
{
|
|
add_usage(
|
|
&mut usages,
|
|
path,
|
|
MaterialSceneUser {
|
|
entity,
|
|
actor_label: actor_label(entity, name),
|
|
detail: format!("Skinned / {}", slot.name),
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
let mut materials = world.query::<(Entity, &MaterialDesc, Option<&Name>)>();
|
|
for (entity, material, name) in materials.iter(world) {
|
|
if let Some(path) = material.material_asset_path.as_deref() {
|
|
add_usage(
|
|
&mut usages,
|
|
path,
|
|
MaterialSceneUser {
|
|
entity,
|
|
actor_label: actor_label(entity, name),
|
|
detail: "Surface".into(),
|
|
},
|
|
);
|
|
}
|
|
}
|
|
let mut brushes = world.query::<(Entity, &BrushDesc, Option<&Name>)>();
|
|
for (entity, brush, name) in brushes.iter(world) {
|
|
for face in &brush.faces {
|
|
if let Some(path) = face
|
|
.material
|
|
.as_ref()
|
|
.and_then(|reference| reference.source_path.as_deref())
|
|
{
|
|
add_usage(
|
|
&mut usages,
|
|
path,
|
|
MaterialSceneUser {
|
|
entity,
|
|
actor_label: actor_label(entity, name),
|
|
detail: face.id.0.clone(),
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
usages
|
|
}
|
|
|
|
fn add_usage(
|
|
usages: &mut HashMap<String, Vec<MaterialSceneUser>>,
|
|
path: &str,
|
|
user: MaterialSceneUser,
|
|
) {
|
|
usages.entry(normalize_path(path)).or_default().push(user);
|
|
}
|
|
|
|
fn actor_label(entity: Entity, name: Option<&Name>) -> String {
|
|
name.map(|name| name.as_str().to_string())
|
|
.unwrap_or_else(|| format!("Actor {entity:?}"))
|
|
}
|
|
|
|
fn normalize_path(path: &str) -> String {
|
|
path.replace('\\', "/")
|
|
}
|
|
|
|
pub(super) fn refresh_material_library_catalog(
|
|
assets: Res<EditorAssets>,
|
|
mut catalog: ResMut<MaterialLibraryCatalog>,
|
|
) {
|
|
if !assets.is_changed() && !catalog.documents.is_empty() {
|
|
return;
|
|
}
|
|
catalog.documents = assets
|
|
.assets
|
|
.iter()
|
|
.filter(|asset| matches!(asset.kind, EditorAssetKind::Material))
|
|
.cloned()
|
|
.map(|asset| {
|
|
let path = asset.path.as_deref().unwrap_or_default();
|
|
let instance = MaterialInstanceAsset::load_from_path(path).ok();
|
|
let kind = if instance.is_some() {
|
|
MaterialDocumentKind::Instance
|
|
} else if MaterialAsset::load_from_path(path).is_ok() {
|
|
MaterialDocumentKind::Material
|
|
} else {
|
|
MaterialDocumentKind::Invalid
|
|
};
|
|
let base_path = instance
|
|
.as_ref()
|
|
.and_then(|instance| instance.base.0.source_path.as_deref())
|
|
.map(normalize_path);
|
|
CachedMaterialDocument {
|
|
selection: AssetSelection::from_asset(&asset),
|
|
error: shared::load_resolved_material_from_path(path).err(),
|
|
asset,
|
|
kind,
|
|
base_path,
|
|
}
|
|
})
|
|
.collect();
|
|
}
|
|
|
|
fn material_usage_ui(
|
|
world: &mut World,
|
|
ui: &mut egui::Ui,
|
|
row: &MaterialLibraryRow,
|
|
selected_entities: &mut SelectedEntities,
|
|
) {
|
|
ui.horizontal(|ui| {
|
|
ui.label(panel_heading("Scene Usage"));
|
|
ui.label(
|
|
egui::RichText::new(row.scene_users.len().to_string())
|
|
.monospace()
|
|
.color(if row.scene_users.is_empty() {
|
|
TEXT_DIM
|
|
} else {
|
|
SUCCESS
|
|
}),
|
|
);
|
|
});
|
|
for user in &row.scene_users {
|
|
if ui
|
|
.button(format!(
|
|
"{} {} / {}",
|
|
icons::CROSSHAIR.as_str(),
|
|
user.actor_label,
|
|
user.detail
|
|
))
|
|
.clicked()
|
|
{
|
|
select_scene_user(world, selected_entities, user.entity);
|
|
}
|
|
}
|
|
ui.separator();
|
|
}
|
|
|
|
fn select_scene_user(world: &mut World, selected_entities: &mut SelectedEntities, entity: Entity) {
|
|
if world.get_entity(entity).is_err() {
|
|
return;
|
|
}
|
|
selected_entities.select_replace(entity);
|
|
world.resource_mut::<crate::selection::SelectedEntity>().0 = Some(entity);
|
|
super::selection_ops::focus_editor_camera_on_selection(world);
|
|
world.resource_mut::<DockTabRequest>().0 = Some(EditorTab::Viewport);
|
|
}
|
|
|
|
fn create_material_asset(world: &mut World) -> Result<(), String> {
|
|
let path = next_material_path(Path::new(MATERIALS_FOLDER));
|
|
let label = path
|
|
.file_stem()
|
|
.and_then(|stem| stem.to_str())
|
|
.unwrap_or("new_material")
|
|
.replace('_', " ")
|
|
.split_whitespace()
|
|
.map(|word| {
|
|
let mut chars = word.chars();
|
|
chars
|
|
.next()
|
|
.map(|first| first.to_ascii_uppercase().to_string() + chars.as_str())
|
|
.unwrap_or_default()
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(" ");
|
|
let asset = MaterialAsset {
|
|
schema_version: shared::MATERIAL_ASSET_SCHEMA_VERSION,
|
|
label: label.clone(),
|
|
shader: None,
|
|
shader_ref: None,
|
|
render_state: shared::MaterialRenderState::default(),
|
|
material: MaterialDesc::default(),
|
|
};
|
|
let text = ron::ser::to_string_pretty(&asset, ron::ser::PrettyConfig::default())
|
|
.map_err(|error| format!("could not serialize new material: {error}"))?;
|
|
publish_authored_file(
|
|
world,
|
|
&path,
|
|
text.as_bytes(),
|
|
&FileSnapshot::missing(),
|
|
FileWriteIntent::Material,
|
|
)?;
|
|
let catalog_path = normalize_path(&path.to_string_lossy());
|
|
{
|
|
let Some(mut registry) = world.get_resource_mut::<AssetRegistry>() else {
|
|
return Err(format!(
|
|
"Created {catalog_path}, but the asset registry is unavailable"
|
|
));
|
|
};
|
|
ensure_asset_record(&mut registry, catalog_path.clone(), label, "Material")?;
|
|
}
|
|
{
|
|
let mut assets = world.resource_mut::<EditorAssets>();
|
|
assets.refresh();
|
|
assets.current_folder = MATERIALS_FOLDER.into();
|
|
assets.select(AssetSelection::File(catalog_path.clone()));
|
|
}
|
|
invalidate_on_catalog_refresh(world);
|
|
world.resource_mut::<SceneIo>().status = format!("Created material {catalog_path}");
|
|
Ok(())
|
|
}
|
|
|
|
fn next_material_path(folder: &Path) -> PathBuf {
|
|
for index in 1.. {
|
|
let name = if index == 1 {
|
|
"new_material.ron".to_string()
|
|
} else {
|
|
format!("new_material_{index}.ron")
|
|
};
|
|
let candidate = folder.join(name);
|
|
if !candidate.exists() {
|
|
return candidate;
|
|
}
|
|
}
|
|
unreachable!("unbounded material filename search")
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use shared::{
|
|
ComponentInstanceId, EditorAssetRef, MaterialRef, RendererMaterialSet, RendererMaterialSlot,
|
|
};
|
|
|
|
#[test]
|
|
fn usage_counts_exact_authored_material_paths() {
|
|
let material_path = "assets/materials/steel.ron";
|
|
let mut world = World::new();
|
|
world.spawn(StaticMeshRenderer {
|
|
slots: Vec::new(),
|
|
materials: RendererMaterialSet {
|
|
slots: vec![RendererMaterialSlot {
|
|
id: ComponentInstanceId::new("slot:body"),
|
|
name: "Body".into(),
|
|
source_material: None,
|
|
material: Some(MaterialRef::new(
|
|
EditorAssetRef::new("steel", "material:source", "Steel")
|
|
.with_source_path(material_path),
|
|
)),
|
|
}],
|
|
orphaned_assignments: Vec::new(),
|
|
},
|
|
});
|
|
world.spawn(MaterialDesc {
|
|
material_asset_path: Some(material_path.into()),
|
|
..Default::default()
|
|
});
|
|
let mut brush = BrushDesc::cuboid(Vec3::ONE);
|
|
brush.faces[0].material = Some(
|
|
EditorAssetRef::new("steel", "material:source", "Steel")
|
|
.with_source_path(material_path),
|
|
);
|
|
world.spawn(brush);
|
|
|
|
let usage = collect_scene_material_usage(&mut world);
|
|
|
|
assert_eq!(usage.get(material_path).map(Vec::len), Some(3));
|
|
}
|
|
|
|
#[test]
|
|
fn filtering_distinguishes_instances_and_scene_usage() {
|
|
let base = MaterialLibraryRow {
|
|
asset: EditorAsset {
|
|
label: "Steel".into(),
|
|
path: Some("assets/materials/steel.ron".into()),
|
|
folder_path: MATERIALS_FOLDER.into(),
|
|
kind: EditorAssetKind::Material,
|
|
},
|
|
selection: AssetSelection::File("assets/materials/steel.ron".into()),
|
|
kind: MaterialDocumentKind::Material,
|
|
scene_users: vec![
|
|
MaterialSceneUser {
|
|
entity: Entity::from_bits(1),
|
|
actor_label: "Crate".into(),
|
|
detail: "Body".into(),
|
|
},
|
|
MaterialSceneUser {
|
|
entity: Entity::from_bits(2),
|
|
actor_label: "Floor".into(),
|
|
detail: "Surface".into(),
|
|
},
|
|
],
|
|
dependent_instances: 1,
|
|
error: None,
|
|
};
|
|
let mut state = MaterialLibraryState {
|
|
filter: MaterialLibraryFilter::Used,
|
|
..Default::default()
|
|
};
|
|
assert!(row_matches(&base, &state));
|
|
state.filter = MaterialLibraryFilter::Instances;
|
|
assert!(!row_matches(&base, &state));
|
|
state.search = "steel".into();
|
|
state.filter = MaterialLibraryFilter::All;
|
|
assert!(row_matches(&base, &state));
|
|
}
|
|
|
|
#[test]
|
|
fn catalog_refresh_classifies_resolved_material_instances_once_assets_change() {
|
|
let root = std::env::temp_dir().join(format!(
|
|
"blacksite-material-library-cache-{}",
|
|
uuid::Uuid::new_v4()
|
|
));
|
|
std::fs::create_dir_all(&root).unwrap();
|
|
let base_path = root.join("base.ron");
|
|
let instance_path = root.join("instance.ron");
|
|
let base = MaterialAsset {
|
|
schema_version: shared::MATERIAL_ASSET_SCHEMA_VERSION,
|
|
label: "Base".into(),
|
|
shader: None,
|
|
shader_ref: None,
|
|
render_state: Default::default(),
|
|
material: MaterialDesc::default(),
|
|
};
|
|
std::fs::write(
|
|
&base_path,
|
|
ron::ser::to_string_pretty(&base, ron::ser::PrettyConfig::default()).unwrap(),
|
|
)
|
|
.unwrap();
|
|
let instance = MaterialInstanceAsset {
|
|
schema_version: shared::MATERIAL_INSTANCE_SCHEMA_VERSION,
|
|
label: "Instance".into(),
|
|
base: MaterialRef::new(
|
|
EditorAssetRef::new("base", "material:source", "Base")
|
|
.with_source_path(base_path.to_string_lossy().into_owned()),
|
|
),
|
|
parameters: Vec::new(),
|
|
textures: Vec::new(),
|
|
};
|
|
std::fs::write(
|
|
&instance_path,
|
|
ron::ser::to_string_pretty(&instance, ron::ser::PrettyConfig::default()).unwrap(),
|
|
)
|
|
.unwrap();
|
|
let material_asset = |label: &str, path: &Path| EditorAsset {
|
|
label: label.into(),
|
|
path: Some(path.to_string_lossy().into_owned()),
|
|
folder_path: root.to_string_lossy().into_owned(),
|
|
kind: EditorAssetKind::Material,
|
|
};
|
|
let mut app = App::new();
|
|
app.insert_resource(EditorAssets {
|
|
folders: Vec::new(),
|
|
assets: vec![
|
|
material_asset("Base", &base_path),
|
|
material_asset("Instance", &instance_path),
|
|
],
|
|
current_folder: root.to_string_lossy().into_owned(),
|
|
selected: None,
|
|
dragging: None,
|
|
status: String::new(),
|
|
})
|
|
.init_resource::<MaterialLibraryCatalog>()
|
|
.add_systems(Update, refresh_material_library_catalog);
|
|
|
|
app.update();
|
|
|
|
let catalog = app.world().resource::<MaterialLibraryCatalog>();
|
|
assert_eq!(catalog.documents.len(), 2);
|
|
let cached_instance = catalog
|
|
.documents
|
|
.iter()
|
|
.find(|document| document.kind == MaterialDocumentKind::Instance)
|
|
.unwrap();
|
|
assert_eq!(
|
|
cached_instance.base_path.as_deref(),
|
|
Some(normalize_path(&base_path.to_string_lossy()).as_str())
|
|
);
|
|
assert!(cached_instance.error.is_none());
|
|
std::fs::remove_dir_all(root).unwrap();
|
|
}
|
|
}
|