d84914ef1e5a
state.rs
//! UI state (serde, so the control channel can read and drive it).
use serde::{Deserialize, Serialize};
use texturecraft_engine::core::{BakedMap, Channel, ChannelBlend, NormalFormat};
use crate::docking::Dock;
use crate::keymap::Keymap;
use crate::saved_search::SavedSearch;
use crate::shelf_panes::ShelfPanes;
use crate::shelf_view::ShelfView;
mod import_resources;
mod import_row;
mod library_location;
mod project_config;
mod resource_usage;
pub use import_resources::ImportResources;
pub use import_row::ImportRow;
pub use library_location::LibraryLocation;
pub use project_config::ProjectConfig;
pub use resource_usage::ResourceUsage;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum Mode {
#[default]
Painting,
Baking,
/// Path-traced view (F10).
Rendering,
}
/// The Alpha tab's text: what to draw and in which font (empty: the default font).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct TextUi {
pub text: String,
pub font: String,
pub style: String,
/// Installed and built-in families with their styles (`text.fonts`), read when first shown.
#[serde(skip)]
pub fonts: Vec<(String, Vec<String>)>,
}
/// Rendering mode settings.
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct RenderUi {
pub max_samples: u32,
pub bounces: u32,
pub denoise: bool,
/// Path trace on the CPU even where the GPU tracer runs.
pub cpu: bool,
}
impl Default for RenderUi {
fn default() -> Self {
// The web traces on one thread: fewer bounces keep it interactive
RenderUi { max_samples: 256, bounces: if cfg!(target_arch = "wasm32") { 3 } else { 6 }, denoise: true, cpu: false }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum ViewLayout {
/// 3D and 2D side by side.
#[default]
Split,
Only3D,
Only2D,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum PropsTab {
#[default]
Brush,
Alpha,
Material,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Windows {
pub export: bool,
pub new_project: bool,
pub about: bool,
pub shortcuts: bool,
#[serde(default)]
pub settings: bool,
/// Browser File › Export Mesh: the download format choice.
#[serde(default)]
pub export_mesh: bool,
/// File › Export Mesh: the Mesh Export Options prompt before the file choice
#[serde(skip)]
pub mesh_export_options: Option<u64>,
/// Edit > Project Configuration: what is chosen so far, applied by OK.
#[serde(skip)]
pub project_config: Option<ProjectConfig>,
/// Edit > Settings: the page and the settings edited so far, applied by OK.
#[serde(skip)]
pub settings_draft: Option<crate::settings_window::SettingsDraft>,
/// File > Import resources: the files added so far, imported by Import.
#[serde(skip)]
pub import_resources: Option<ImportResources>,
/// What waits on the unsaved-changes dialog: save, don't save or cancel.
#[serde(skip)]
pub unsaved: Option<Unsaved>,
/// Window ▸ Reset UI is waiting for its answer.
#[serde(skip)]
pub confirm_reset_ui: bool,
}
/// An action that replaces or ends the project, held while the project has unsaved changes.
#[derive(Clone, Debug, PartialEq)]
pub enum Unsaved {
Quit,
/// A menu command (Open, Close, Open sample project).
Command(String),
/// Create from the New project form that requested confirmation.
CreateProject(u64),
/// Open this project or mesh file.
#[cfg(not(target_arch = "wasm32"))]
Open(String),
/// Open a project or mesh file's bytes (picked or dropped in the browser): its name and bytes.
Load(String, std::sync::Arc<Vec<u8>>),
}
/// Edit › Settings.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Prefs {
/// Interface zoom (1 = 100%).
pub ui_scale: f32,
/// Minutes between autosaves of a modified project (0: off; desktop).
pub autosave_minutes: u32,
/// UI language code (`i18n::LANGUAGES`), or `i18n::SYSTEM_LANGUAGE` to follow the system.
pub language: String,
/// Viewport texture resolution: 0 full, 1 half, 2 quarter of each texture set's size (lighter
/// on GPU memory and uploads for 4K and 8K sets; painting and export keep full resolution).
pub viewport_texture: u8,
/// Interface brightness (the views keep their studio slate).
pub brightness: crate::theme::Brightness,
/// The colour of what is on, chosen or focused.
pub accent: crate::theme::Accent,
/// The system draws the window's title bar instead of TextureCraft (desktop; read at startup).
pub system_title_bar: bool,
/// Where autosaves, smart materials, presets, templates and layouts go (desktop; read at
/// startup). Empty or relative: `Documents/TextureCraft`.
pub data_folder: String,
/// Cores a project save leaves to the UI; Settings bounds this to the available logical CPUs
/// (desktop). At least one save worker always runs.
pub reserved_cores: u32,
/// Maximum decompressed project size accepted on open, in GiB (at least one).
pub project_open_limit_gib: u32,
/// Percent of the free RAM a project save may hold at once (desktop; 1 to 100).
pub save_ram_percent: u8,
/// Worker threads for painting, baking and export (desktop; 0: one per logical CPU). Read at
/// startup, before the first parallel job.
pub work_threads: u32,
/// 3D view orbit speed; [`DEFAULT_ROTATION_SPEED`] is the built-in speed.
pub rotation_speed: f32,
/// 3D view drag zoom speed (1 is the built-in speed) and whether it runs the other way.
pub zoom_speed: f32,
pub zoom_inverse: bool,
/// 3D view mouse wheel zoom speed (1 is the built-in speed) and whether it runs the other way.
pub wheel_speed: f32,
pub wheel_inverse: bool,
/// Bakes cast their rays on the GPU when one is available (else on the CPU).
pub gpu_raytracing: bool,
/// Library locations the user added (Settings > Libraries), after the built-in ones.
pub libraries: Vec<LibraryLocation>,
}
/// The orbit speed the built-in navigation runs at.
pub const DEFAULT_ROTATION_SPEED: f32 = 2.0;
/// The range of the camera speed sliders.
pub const CAMERA_SPEED_RANGE: std::ops::RangeInclusive<f32> = 0.1..=10.0;
impl Default for Prefs {
fn default() -> Self {
Prefs {
ui_scale: 1.0,
autosave_minutes: 10,
language: "en".into(),
viewport_texture: 0,
brightness: crate::theme::Brightness::default(),
accent: crate::theme::Accent::default(),
system_title_bar: false,
data_folder: String::new(),
reserved_cores: 1,
project_open_limit_gib: texturecraft_engine::formats::DEFAULT_PROJECT_OPEN_LIMIT_GIB,
save_ram_percent: 50,
work_threads: 0,
rotation_speed: DEFAULT_ROTATION_SPEED,
zoom_speed: 1.0,
zoom_inverse: false,
wheel_speed: 1.0,
wheel_inverse: false,
gpu_raytracing: true,
libraries: Vec::new(),
}
}
}
/// `value` as a camera speed: inside the sliders' range, the default for a value that is not a number.
fn camera_speed(value: f32, default: f32) -> f32 {
if value.is_finite() { value.clamp(*CAMERA_SPEED_RANGE.start(), *CAMERA_SPEED_RANGE.end()) } else { default }
}
impl Prefs {
/// Apply resource preferences before commands or file workers can start.
pub fn apply_resource_limits(&self) {
texturecraft_engine::formats::set_project_open_limit_gib(self.project_open_limit_gib);
#[cfg(not(target_arch = "wasm32"))]
texturecraft_engine::formats::set_save_resources(self.reserved_cores as usize, self.save_ram_percent);
texturecraft_engine::bake::set_gpu_raytracing(self.gpu_raytracing);
}
/// Size the shared worker pool to `work_threads` (0 keeps one thread per logical CPU). Only
/// the first call of a process can do this, before any parallel work: true when it did.
#[cfg(not(target_arch = "wasm32"))]
pub fn apply_work_threads(&self) -> bool {
if self.work_threads == 0 {
return false;
}
let available_threads = std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get);
let work_threads = (self.work_threads as usize).min(available_threads);
rayon::ThreadPoolBuilder::new().num_threads(work_threads).build_global().is_ok()
}
/// The 3D view's orbit per dragged point, relative to the built-in speed.
pub fn orbit_scale(&self) -> f32 {
camera_speed(self.rotation_speed, DEFAULT_ROTATION_SPEED) / DEFAULT_ROTATION_SPEED
}
/// The 3D view's drag zoom relative to the built-in speed; negative when inverted.
pub fn drag_zoom_scale(&self) -> f32 {
let speed = camera_speed(self.zoom_speed, 1.0);
if self.zoom_inverse { -speed } else { speed }
}
/// The 3D view's wheel zoom relative to the built-in speed; negative when inverted.
pub fn wheel_zoom_scale(&self) -> f32 {
let speed = camera_speed(self.wheel_speed, 1.0);
if self.wheel_inverse { -speed } else { speed }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NewProject {
pub resolution: u32,
/// The mesh file chosen with Select... (its path on the desktop, its name in the browser).
pub file: Option<String>,
/// The browser's copy of the chosen mesh file, read when Create is pressed.
#[serde(skip)]
pub file_bytes: Option<std::sync::Arc<Vec<u8>>>,
/// The active form opening, used to reject late file picker answers.
#[serde(skip)]
pub opening_id: u64,
/// The latest mesh pick requested by this form.
#[serde(skip)]
pub mesh_request_id: u64,
/// Use UV Tile workflow: Some(true) makes UV tile (UDIM) texture sets; otherwise each set paints tile 1001.
pub uv_tiles: Option<bool>,
/// Project template name (built-in or the user's).
#[serde(default = "default_template")]
pub template: String,
/// Normal map format of the project and its imported normal maps; None keeps the template's
#[serde(default)]
pub normal_format: Option<NormalFormat>,
/// Import settings > Import cameras: keep the cameras stored in the mesh file
#[serde(default = "import_cameras_default")]
pub import_cameras: bool,
/// Color management as chosen in the window (the project is always created as Legacy)
#[serde(skip)]
pub color_management: crate::project_form::ColorManagement,
/// Baked map files to import at creation, matched to sets and mesh maps by name (desktop only)
#[serde(skip)]
pub baked_maps: Vec<String>,
}
fn default_template() -> String {
texturecraft_engine::template_cmds::DEFAULT_TEMPLATE.into()
}
fn import_cameras_default() -> bool {
true
}
impl NewProject {
pub(crate) fn clear_mesh(&mut self) {
self.file = None;
self.file_bytes = None;
self.opening_id = 0;
self.mesh_request_id = 0;
}
}
impl Default for NewProject {
fn default() -> Self {
NewProject {
resolution: 1024,
file: None,
file_bytes: None,
opening_id: 0,
mesh_request_id: 0,
uv_tiles: None,
template: default_template(),
normal_format: None,
import_cameras: true,
color_management: crate::project_form::ColorManagement::Legacy,
baked_maps: Vec::new(),
}
}
}
/// The export dialog's settings (remembered between sessions).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExportUi {
pub dir: String,
pub preset: String,
/// File extension override ("" = the preset's formats).
pub format: String,
/// Bit depth override (0 = the preset's).
pub bit_depth: u8,
/// none | dilation | dilationDefault | infinite
pub padding: String,
pub dilation: u32,
/// Output size override (0 = each texture set's size).
pub size: u32,
/// "" (project), openGl or directX.
pub normal_format: String,
/// "" (by file format: sRGB, or linear for float files), or a colour space name.
#[serde(default)]
pub color_space: String,
/// Texture sets excluded from export.
pub skip: Vec<usize>,
pub tab: u8,
/// Output templates tab: the selected user preset being edited (saved whenever it is valid).
#[serde(skip)]
pub draft: Option<texturecraft_engine::formats::ExportPreset>,
/// Output templates tab: the new name while renaming the selected preset.
#[serde(skip)]
pub renaming: Option<String>,
/// Output templates tab: the question waiting for an answer (delete, or drop an unsaved edit).
#[serde(skip)]
pub ask: Option<crate::export_templates::Ask>,
}
impl Default for ExportUi {
fn default() -> Self {
ExportUi {
dir: default_export_dir(),
preset: "Document channels + Normal + AO".into(),
format: String::new(),
bit_depth: 0,
padding: "infinite".into(),
dilation: 16,
size: 0,
normal_format: String::new(),
color_space: String::new(),
skip: Vec::new(),
tab: 0,
draft: None,
renaming: None,
ask: None,
}
}
}
fn default_export_dir() -> String {
#[cfg(not(target_arch = "wasm32"))]
{
crate::user_dir("export").display().to_string()
}
#[cfg(target_arch = "wasm32")]
{
String::new()
}
}
/// The split layout starts with the 3D and 2D views at equal width
fn default_split_ratio() -> f32 {
0.5
}
/// Saved searches start with this share of the Assets panel's pane column while Filter by path is open too
pub(crate) fn default_shelf_panes_split() -> f32 {
0.45
}
fn deserialize_shelf_panes_split<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<f32, D::Error> {
let share = f32::deserialize(deserializer)?;
// A finite JSON number can overflow f32 and prevent the next settings save
Ok(if share.is_finite() { share } else { default_shelf_panes_split() })
}
/// Settings that start on, for saved states that predate them
fn default_true() -> bool {
true
}
/// The bake layout's version: saved bake docks from an older one load as `Dock::for_baking`
const BAKE_LAYOUT_VERSION: u32 = 2;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct UiState {
/// Layer menu ▸ Blending options ▸ Copy: each channel's blend mode and opacity of the copied layer.
#[serde(skip)]
pub blend_clipboard: Option<Vec<(Channel, ChannelBlend)>>,
pub mode: Mode,
pub layout: ViewLayout,
/// The split layout shows the 2D view on the left and the 3D view on the right
#[serde(default)]
pub swap_views: bool,
/// The 3D view's share of the viewport width in the split layout
#[serde(default = "default_split_ratio")]
pub split_ratio: f32,
/// The docked, tabbed and floating panels around the viewport.
#[serde(default)]
pub dock: Dock,
/// The panel open against the icon rail, if any; not saved, so the app starts with the rail closed
#[serde(skip)]
pub rail_panel: Option<crate::docking::Panel>,
#[serde(default = "Dock::for_baking")]
pub(crate) inactive_mode_dock: Dock,
#[serde(default)]
pub(crate) dock_is_baking: bool,
/// The bake layout version the bake dock was saved with; 0 before versions existed.
#[serde(default)]
pub(crate) bake_layout_version: u32,
/// The mesh map whose settings Mesh Map Settings shows; `None` follows the first enabled map.
#[serde(default)]
pub(crate) selected_baked_map: Option<BakedMap>,
/// Window ▸ Hide UI (Tab): only the viewport.
pub hide_ui: bool,
pub windows: Windows,
pub uv_zoom: f32,
pub uv_pan: [f32; 2],
/// Channel whose blending the layer rows show.
pub layer_channel: Channel,
pub shelf_filter: String,
/// The asset shelf's picked type: an index into the shelf's types, or past them for every type
#[serde(default)]
pub shelf_tab: usize,
/// The asset shelf's library folder: a library id, then folder names (empty: all libraries)
#[serde(default)]
pub shelf_path: Vec<String>,
/// The asset shelf's tile size, or its list
#[serde(default)]
pub shelf_view: ShelfView,
/// The asset shelf's open side panes
#[serde(default)]
pub shelf_panes: ShelfPanes,
/// The asset shelf's saved queries, in the order they were saved
#[serde(default)]
pub shelf_saved_searches: Vec<SavedSearch>,
/// Saved searches' share of the pane column above Filter by path, set by the splitter between them
#[serde(default = "default_shelf_panes_split", deserialize_with = "deserialize_shelf_panes_split")]
pub shelf_panes_split: f32,
pub props_tab: PropsTab,
#[serde(default)]
pub text: TextUi,
/// Layer being renamed and the edit buffer.
pub rename: Option<(u64, String)>,
pub new_project: NewProject,
/// Show the UV wireframe in the 2D view.
pub uv_wireframe: bool,
/// Show the mesh wireframe over the 3D view.
#[serde(default)]
pub wireframe_3d: bool,
/// Show the orbit, pan and zoom buttons in the corner of the 3D and 2D views (Viewport menu)
#[serde(default = "default_true")]
pub nav_buttons: bool,
#[serde(default)]
pub render: RenderUi,
#[serde(default)]
pub prefs: Prefs,
#[serde(default)]
pub export: ExportUi,
/// Recently opened or saved projects (desktop).
#[serde(default)]
pub recent: Vec<String>,
/// Custom keyboard shortcuts (item id → "Ctrl+Shift+E", "" = none) over the defaults.
#[serde(default)]
pub keymap: Keymap,
/// The brush that paints the skew correction map in the 2D view of bake mode.
#[serde(default)]
pub bake_paint_brush: crate::bake_mode::BakePaintBrush,
/// How the 3D view shows symmetry
#[serde(default)]
pub symmetry: crate::symmetry::SymmetryDisplay,
/// The brush, symmetry and other tool settings of the last session, which the next one starts with
#[serde(default)]
pub tool_settings: texturecraft_engine::ToolSettings,
/// The Baking Visualization panel's settings, under a key of their own since the reference defaults: older saved ones start over
#[serde(default, rename = "baking_visualization")]
pub bake_visualization: crate::bake_mode::BakeVisualizationToggles,
/// Panel arrangements saved under a name (Window > Layouts), in the order they were saved
#[serde(default)]
pub named_layouts: Vec<crate::named_layouts::NamedLayout>,
/// Bake settings saved under a name (Mesh Map Bakers > Presets), in the order they were saved
#[serde(default)]
pub bake_presets: Vec<crate::bake_presets::BakePreset>,
/// The name typed in the bake presets menu
#[serde(skip)]
pub bake_preset_name: String,
/// The save, replace or manage dialog of the named layouts
#[serde(skip)]
pub layout_dialog: Option<crate::named_layouts::LayoutDialog>,
/// The Log panel's shown channel tab
#[serde(default)]
pub log_channel: crate::log_panel::LogChannel,
}
impl UiState {
/// Replace an outdated or unreadable saved bake dock by the bake layout, then give the mode its dock
pub(crate) fn sync_mode_dock(&mut self) {
self.reset_outdated_bake_dock();
let baking = self.mode == Mode::Baking;
if baking != self.dock_is_baking {
std::mem::swap(&mut self.dock, &mut self.inactive_mode_dock);
self.dock_is_baking = baking;
}
}
/// Replace a bake dock saved with an older bake layout, or one that could not be read, by the bake default
fn reset_outdated_bake_dock(&mut self) {
let bake_dock = if self.dock_is_baking { &mut self.dock } else { &mut self.inactive_mode_dock };
if self.bake_layout_version >= BAKE_LAYOUT_VERSION && !bake_dock.replaced_unreadable() {
return;
}
*bake_dock = Dock::for_baking();
self.bake_layout_version = BAKE_LAYOUT_VERSION;
}
/// Put the panels, tabs and floating panels of both modes back to their defaults; the view split,
/// zoom, wireframes, symmetry display, mode and every setting stay as they are
pub fn reset_panel_layout(&mut self) {
let (painting, baking) = (Dock::default(), Dock::for_baking());
(self.dock, self.inactive_mode_dock) = if self.dock_is_baking { (baking, painting) } else { (painting, baking) };
self.bake_layout_version = BAKE_LAYOUT_VERSION;
self.rail_panel = None;
}
/// Take `layout`'s panels, windows and view settings, keeping this state's dialogs, settings, files and shelf query
pub fn adopt_layout(&mut self, layout: UiState) {
let keep = std::mem::replace(self, layout);
self.new_project = keep.new_project;
if !self.windows.new_project {
self.new_project.clear_mesh();
// Keep a failed import queued when the form was already closed
if keep.windows.new_project {
self.new_project.baked_maps = Vec::new();
}
}
self.export = keep.export;
self.recent = keep.recent;
self.prefs = keep.prefs;
self.nav_buttons = keep.nav_buttons;
self.keymap = keep.keymap;
self.tool_settings = keep.tool_settings;
self.named_layouts = keep.named_layouts;
self.bake_presets = keep.bake_presets;
self.layout_dialog = None;
self.rename = None;
// The shelf's search, type and folder are one query, and saved searches are the user's own
self.shelf_filter = keep.shelf_filter;
self.shelf_tab = keep.shelf_tab;
self.shelf_path = keep.shelf_path;
self.shelf_saved_searches = keep.shelf_saved_searches;
}
}
impl Default for UiState {
fn default() -> Self {
UiState {
mode: Mode::Painting,
layout: ViewLayout::Split,
swap_views: false,
split_ratio: default_split_ratio(),
dock: Dock::default(),
rail_panel: None,
inactive_mode_dock: Dock::for_baking(),
dock_is_baking: false,
bake_layout_version: BAKE_LAYOUT_VERSION,
selected_baked_map: None,
hide_ui: false,
windows: Windows::default(),
uv_zoom: 1.0,
uv_pan: [0.0, 0.0],
layer_channel: Channel::BaseColor,
blend_clipboard: None,
shelf_filter: String::new(),
shelf_tab: 0,
shelf_path: Vec::new(),
shelf_view: ShelfView::default(),
shelf_panes: ShelfPanes::default(),
shelf_saved_searches: Vec::new(),
shelf_panes_split: default_shelf_panes_split(),
props_tab: PropsTab::Brush,
text: TextUi::default(),
rename: None,
new_project: NewProject::default(),
uv_wireframe: true,
wireframe_3d: false,
nav_buttons: true,
render: RenderUi::default(),
prefs: Prefs::default(),
export: ExportUi::default(),
recent: Vec::new(),
keymap: Keymap::new(),
bake_paint_brush: crate::bake_mode::BakePaintBrush::default(),
symmetry: crate::symmetry::SymmetryDisplay::default(),
tool_settings: Default::default(),
bake_visualization: crate::bake_mode::BakeVisualizationToggles::default(),
named_layouts: Vec::new(),
bake_presets: Vec::new(),
bake_preset_name: String::new(),
layout_dialog: None,
log_channel: crate::log_panel::LogChannel::default(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn camera_speeds_scale_the_built_in_navigation_and_inverse_flips_it() {
let mut prefs = Prefs::default();
assert_eq!((prefs.orbit_scale(), prefs.drag_zoom_scale(), prefs.wheel_zoom_scale()), (1.0, 1.0, 1.0), "the defaults keep the built-in speeds");
prefs.rotation_speed = 4.0;
prefs.zoom_speed = 0.5;
prefs.zoom_inverse = true;
prefs.wheel_inverse = true;
assert_eq!((prefs.orbit_scale(), prefs.drag_zoom_scale(), prefs.wheel_zoom_scale()), (2.0, -0.5, -1.0));
// Values from an edited settings file stay usable
prefs.rotation_speed = f32::NAN;
prefs.wheel_speed = 1e9;
assert_eq!(prefs.orbit_scale(), 1.0);
assert_eq!(prefs.wheel_zoom_scale(), -*CAMERA_SPEED_RANGE.end());
}
#[test]
fn settings_saved_before_the_new_options_load_their_defaults() {
let prefs: Prefs = serde_json::from_str(r#"{"autosave_minutes": 5}"#).unwrap();
assert_eq!(prefs.autosave_minutes, 5);
assert_eq!((prefs.rotation_speed, prefs.zoom_speed, prefs.wheel_speed), (2.0, 1.0, 1.0));
assert!(prefs.gpu_raytracing && !prefs.zoom_inverse && !prefs.wheel_inverse);
assert_eq!(prefs.work_threads, 0);
assert!(prefs.libraries.is_empty());
}
#[test]
fn the_first_run_follows_the_system_language() {
let mut session = texturecraft_engine::Session::closed().unwrap();
assert_eq!(crate::start_ui(None, &mut session).prefs.language, crate::i18n::SYSTEM_LANGUAGE);
}
#[test]
fn adopting_a_layout_keeps_recent_files_export_settings_and_shortcuts() {
let mut ui = UiState { recent: vec!["a.tcraft".into()], ..UiState::default() };
ui.export.preset = "Mine".into();
ui.keymap.insert("file.save".into(), "F5".into());
let mut layout = UiState::default();
layout.dock.close(crate::docking::Panel::Assets);
ui.adopt_layout(layout);
assert!(!ui.dock.is_open(crate::docking::Panel::Assets));
assert_eq!(ui.recent, vec!["a.tcraft".to_string()]);
assert_eq!(ui.export.preset, "Mine");
assert_eq!(ui.keymap.get("file.save").map(String::as_str), Some("F5"));
}
#[test]
fn resetting_the_panel_layout_restores_both_docks_and_keeps_the_rest() {
for baking in [false, true] {
let mode = if baking { Mode::Baking } else { Mode::Painting };
let mut ui = UiState { mode, ..UiState::default() };
ui.sync_mode_dock();
ui.dock.close(crate::docking::Panel::Log);
ui.inactive_mode_dock.close(crate::docking::Panel::Log);
ui.layout = ViewLayout::Only3D;
ui.uv_zoom = 3.0;
ui.wireframe_3d = true;
ui.recent = vec!["a.tcraft".into()];
ui.reset_panel_layout();
let mut fresh = UiState { mode, ..UiState::default() };
fresh.sync_mode_dock();
assert_eq!((&ui.dock, &ui.inactive_mode_dock), (&fresh.dock, &fresh.inactive_mode_dock), "baking: {baking}");
assert_eq!((ui.layout, ui.uv_zoom, ui.wireframe_3d, ui.mode), (ViewLayout::Only3D, 3.0, true, mode));
assert_eq!(ui.recent, vec!["a.tcraft".to_string()]);
}
}
#[test]
fn adopting_a_layout_keeps_the_shelf_query_and_saved_searches() {
let saved = crate::saved_search::SavedSearch { name: "rust".into(), filter: "rust".into(), tab: 2, path: vec!["starter".into()] };
let mut ui = UiState { shelf_filter: "rust".into(), shelf_tab: 2, shelf_path: vec!["starter".into()], ..UiState::default() };
ui.shelf_saved_searches.push(saved.clone());
ui.adopt_layout(UiState::default());
assert_eq!((ui.shelf_filter.as_str(), ui.shelf_tab, ui.shelf_path.as_slice()), ("rust", 2, ["starter".to_string()].as_slice()));
assert_eq!(ui.shelf_saved_searches, [saved]);
}
#[test]
fn the_data_folder_is_an_absolute_choice_or_documents_texturecraft() {
let default = crate::data_folder("");
assert!(default.ends_with(std::path::Path::new("Documents").join("TextureCraft")));
assert_eq!(crate::data_folder("relative/dir"), default, "a relative path is not a choice");
let chosen = std::env::temp_dir().join("tc-data");
assert_eq!(crate::data_folder(&format!(" {} ", chosen.display())), chosen);
assert_eq!(Prefs::default().data_folder, "", "the default is no choice");
}
#[test]
fn a_bake_dock_saved_before_the_bake_layout_version_loads_the_current_bake_layout() {
let old_bake_dock = serde_json::json!({"version": 2, "layout": {"root": {"Split": {"axis": "Horizontal", "size": {"FixedFirst": 320.0},
"first": {"Tabs": {"panels": ["TextureSetList", "BakeSettings", "BakeMaps"], "active": 0}},
"second": {"Tabs": {"panels": ["Viewport"], "active": 0}}}}, "floating": []}});
for dock_is_baking in [false, true] {
let mut painting_dock = Dock::default();
painting_dock.close(crate::docking::Panel::Assets);
let (bake_field, painting_field) = if dock_is_baking { ("dock", "inactive_mode_dock") } else { ("inactive_mode_dock", "dock") };
let mut saved = serde_json::to_value(UiState::default()).unwrap();
let fields = saved.as_object_mut().unwrap();
fields.remove("bake_layout_version");
fields.insert("dock_is_baking".into(), serde_json::json!(dock_is_baking));
fields.insert("mode".into(), serde_json::to_value(if dock_is_baking { Mode::Baking } else { Mode::Painting }).unwrap());
fields.insert(bake_field.into(), old_bake_dock.clone());
fields.insert(painting_field.into(), serde_json::to_value(&painting_dock).unwrap());
let mut ui: UiState = serde_json::from_value(saved).unwrap();
let loaded_bake_dock = if dock_is_baking { &ui.dock } else { &ui.inactive_mode_dock };
assert!(!loaded_bake_dock.is_open(crate::docking::Panel::MeshMapBakers), "the old layout loads without the bakers list");
ui.sync_mode_dock();
let (bake_dock, painting) = if dock_is_baking { (&ui.dock, &ui.inactive_mode_dock) } else { (&ui.inactive_mode_dock, &ui.dock) };
assert_eq!(*bake_dock, Dock::for_baking());
assert_eq!(*painting, painting_dock, "the painting layout is kept");
let mut reloaded: UiState = serde_json::from_value(serde_json::to_value(&ui).unwrap()).unwrap();
reloaded.sync_mode_dock();
assert_eq!(reloaded, ui, "a current layout is not reset again");
}
}
#[test]
fn the_bake_layout_survives_a_restart_whichever_mode_was_open() {
for mode in [Mode::Painting, Mode::Baking] {
let mut ui = UiState { mode, ..UiState::default() };
ui.sync_mode_dock();
let mut restarted = crate::ui_state_store::tests::restart(&ui);
restarted.sync_mode_dock();
let bake_dock = if mode == Mode::Baking { &restarted.dock } else { &restarted.inactive_mode_dock };
assert_eq!(*bake_dock, Dock::for_baking(), "{mode:?}");
assert!(bake_dock.is_open(crate::docking::Panel::MeshMapBakers), "{mode:?}");
}
}
#[test]
fn older_saved_state_without_a_dock_loads_the_default_layout() {
let mut v = serde_json::to_value(UiState::default()).unwrap();
let obj = v.as_object_mut().unwrap();
obj.remove("dock");
obj.remove("keymap");
obj.insert("show_shelf".into(), serde_json::json!(false));
let ui: UiState = serde_json::from_value(v).unwrap();
assert_eq!(ui.dock, Dock::default());
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.