mirror of
https://github.com/storytold/materialcraft.git
synced 2026-11-19 22:10:53 +01:00
Auto: Protect recovery copies and honor committed UI state
Apply preview size only after confirmation, and keep canceled preview values out of parameter capture. Resolve reserved graph names in fresh packages. Publish recovery archives atomically under a folder lock and prune complete copies with bounded memory.
This commit is contained in:
1 parent
25ed4f7e2d
commit
dea0b0f6e2
8 files changed
+359
-34
No files matched your search
@@ -95,7 +95,9 @@ fn new_graph(session: &mut Session, parameters: &J) -> Result<J> {
|
||||
|
||||
crate::folder_path::require_graph_folder(folder)?;
|
||||
let base = crate::folder_path::name(&base)?;
|
||||
let name = target.map_or_else(|| base.to_owned(), |package| crate::folder_path::unique(package, folder, base));
|
||||
let mut new_package = None;
|
||||
let destination = target.unwrap_or_else(|| new_package.insert(Package::new("Untitled package")));
|
||||
let name = crate::folder_path::unique(destination, folder, base);
|
||||
|
||||
let mut graph = if kind == materialcraft_core::GraphKind::Function {
|
||||
let mut graph = materialcraft_core::Graph::new(&name);
|
||||
@@ -112,8 +114,8 @@ fn new_graph(session: &mut Session, parameters: &J) -> Result<J> {
|
||||
// Validate the graph before changing the active package
|
||||
if let Some(document) = target_document {
|
||||
session.activate_document(document)?;
|
||||
} else if in_new_package || !session.has_package() {
|
||||
session.open_package(Package::new("Untitled package"), None)?;
|
||||
} else if let Some(package) = new_package {
|
||||
session.open_package(package, None)?;
|
||||
}
|
||||
|
||||
session.edit("New graph", |session| {
|
||||
|
||||
@@ -205,3 +205,27 @@ fn a_refused_graph_leaves_the_active_package_unchanged() {
|
||||
assert_eq!(session.document_id, destination);
|
||||
assert_eq!(session.graph().unwrap().name, "New graph");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_new_package_resolves_reserved_graph_names() {
|
||||
for new_package in [true, false] {
|
||||
let mut session = Session::new(Package::new("Existing"));
|
||||
let original = session.document_id;
|
||||
if !new_package {
|
||||
execute(&mut session, "package.close", &json!({})).unwrap();
|
||||
assert!(session.open_packages().is_empty());
|
||||
}
|
||||
|
||||
let mut parameters = json!({"template": "empty", "name": "Resources"});
|
||||
if new_package {
|
||||
parameters["newPackage"] = json!(true);
|
||||
}
|
||||
let reply = execute(&mut session, "file.new", ¶meters).unwrap();
|
||||
|
||||
assert_eq!(reply["name"], "Resources_1", "newPackage: {new_package}");
|
||||
assert_eq!(session.graph().unwrap().name, "Resources_1");
|
||||
assert!(session.pkg.folder_paths().contains("Resources"));
|
||||
assert_ne!(session.document_id, original);
|
||||
assert_eq!(session.open_packages().len(), if new_package { 2 } else { 1 });
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,9 @@
|
||||
//! Write numbered recovery copies and retain the newest copies for each document
|
||||
|
||||
use std::io::{self, ErrorKind};
|
||||
use std::collections::BTreeSet;
|
||||
use std::ffi::OsString;
|
||||
use std::fs::{File, OpenOptions};
|
||||
use std::io::{self, ErrorKind, Read, Seek, SeekFrom};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use craft_atomic::{NewFilePermissions, WriteOptions};
|
||||
@@ -9,7 +12,7 @@ use materialcraft_engine::formats::project::ProjectFiles;
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
const EXTENSION: &str = ".mcraft";
|
||||
const MAX_WRITE_ATTEMPTS: usize = 8;
|
||||
const LOCK_FILE: &str = ".recovery.lock";
|
||||
|
||||
/// Saved documents share history by normalized path; untitled documents use workspace-local IDs
|
||||
pub(crate) fn folder(root: &Path, path: Option<&str>, workspace: u64, document: u64) -> PathBuf {
|
||||
@@ -20,17 +23,25 @@ pub(crate) fn folder(root: &Path, path: Option<&str>, workspace: u64, document:
|
||||
root.join(key)
|
||||
}
|
||||
|
||||
fn copies(folder: &Path) -> io::Result<impl Iterator<Item = (u64, std::fs::DirEntry)>> {
|
||||
fn copies(folder: &Path) -> io::Result<impl Iterator<Item = io::Result<(u64, OsString)>>> {
|
||||
Ok(std::fs::read_dir(folder)?.filter_map(|entry| {
|
||||
let entry = entry.ok()?;
|
||||
let entry = match entry {
|
||||
Ok(entry) => entry,
|
||||
Err(error) => return Some(Err(error)),
|
||||
};
|
||||
|
||||
let filename = entry.file_name();
|
||||
let number = filename.to_str()?.strip_suffix(EXTENSION)?.parse().ok()?;
|
||||
entry.file_type().ok()?.is_file().then_some((number, entry))
|
||||
match entry.file_type() {
|
||||
Ok(kind) if kind.is_file() => Some(Ok((number, filename))),
|
||||
Ok(_) => None,
|
||||
Err(error) => Some(Err(error)),
|
||||
}
|
||||
}))
|
||||
}
|
||||
|
||||
fn next_path(folder: &Path) -> io::Result<PathBuf> {
|
||||
let mut version = copies(folder)?.map(|(number, _)| number).max().unwrap_or(0);
|
||||
let mut version = copies(folder)?.try_fold(0, |latest, copy| copy.map(|(number, _)| latest.max(number)))?;
|
||||
loop {
|
||||
version = version.checked_add(1).ok_or_else(|| io::Error::other("autosave versions exhausted"))?;
|
||||
let path = folder.join(format!("{version}{EXTENSION}"));
|
||||
@@ -44,39 +55,135 @@ fn next_path(folder: &Path) -> io::Result<PathBuf> {
|
||||
}
|
||||
}
|
||||
|
||||
fn prune(folder: &Path, keep: u32) -> io::Result<()> {
|
||||
let mut copies: Vec<_> = copies(folder)?.collect();
|
||||
copies.sort_unstable_by_key(|(number, _)| *number);
|
||||
let surplus = copies.len().saturating_sub(keep.max(1) as usize);
|
||||
fn has_recovery_footer(path: &Path) -> io::Result<bool> {
|
||||
// The recovery writer emits uncommented ZIP32 and ZIP64 end records
|
||||
const ZIP_FOOTER_BYTES: usize = 22;
|
||||
const ZIP64_FOOTER_BYTES: usize = 56;
|
||||
const ZIP64_LOCATOR_BYTES: usize = 20;
|
||||
let mut footer = [0; ZIP_FOOTER_BYTES];
|
||||
let mut file = File::open(path)?;
|
||||
if file.metadata()?.len() < ZIP_FOOTER_BYTES as u64 {
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
for (_, entry) in copies.into_iter().take(surplus) {
|
||||
match std::fs::remove_file(entry.path()) {
|
||||
Err(error) if error.kind() == ErrorKind::NotFound => {}
|
||||
result => result?,
|
||||
let footer_offset = file.seek(SeekFrom::End(-(ZIP_FOOTER_BYTES as i64)))?;
|
||||
file.read_exact(&mut footer)?;
|
||||
if !footer.starts_with(b"PK\x05\x06") || !footer.ends_with(&[0, 0]) {
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
let directory_size = u64::from(u32::from_le_bytes(footer[12..16].try_into().unwrap_or_default()));
|
||||
let directory_offset = u64::from(u32::from_le_bytes(footer[16..20].try_into().unwrap_or_default()));
|
||||
if directory_matches(&mut file, directory_offset, directory_size, footer_offset)? {
|
||||
return Ok(true);
|
||||
}
|
||||
|
||||
let Some(zip64_offset) = footer_offset.checked_sub((ZIP64_FOOTER_BYTES + ZIP64_LOCATOR_BYTES) as u64) else {
|
||||
return Ok(false);
|
||||
};
|
||||
|
||||
let mut zip64_footer = [0; ZIP64_FOOTER_BYTES];
|
||||
let mut locator = [0; ZIP64_LOCATOR_BYTES];
|
||||
file.seek(SeekFrom::Start(zip64_offset))?;
|
||||
file.read_exact(&mut zip64_footer)?;
|
||||
file.read_exact(&mut locator)?;
|
||||
if !zip64_footer.starts_with(b"PK\x06\x06") || !locator.starts_with(b"PK\x06\x07") || locator[8..16] != zip64_offset.to_le_bytes() {
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
let directory_size = u64::from_le_bytes(zip64_footer[40..48].try_into().unwrap_or_default());
|
||||
let directory_offset = u64::from_le_bytes(zip64_footer[48..56].try_into().unwrap_or_default());
|
||||
directory_matches(&mut file, directory_offset, directory_size, zip64_offset)
|
||||
}
|
||||
|
||||
fn directory_matches(file: &mut File, offset: u64, size: u64, end: u64) -> io::Result<bool> {
|
||||
// A nested ZIP in a torn copy can have a footer without pointing at the outer directory
|
||||
let mut signature = [0; 4];
|
||||
if size < signature.len() as u64 || offset.checked_add(size) != Some(end) {
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
file.seek(SeekFrom::Start(offset))?;
|
||||
file.read_exact(&mut signature)?;
|
||||
Ok(&signature == b"PK\x01\x02")
|
||||
}
|
||||
|
||||
fn prune(folder: &Path, keep: u32, mut remove: impl FnMut(&Path) -> io::Result<()>) -> io::Result<()> {
|
||||
let keep = keep.clamp(1, crate::state::Prefs::MAX_AUTOSAVE_VERSIONS) as usize;
|
||||
let mut newest = BTreeSet::new();
|
||||
|
||||
// Retain only the newest candidates before deleting anything
|
||||
for copy in copies(folder)? {
|
||||
let copy = copy?;
|
||||
if newest.len() == keep && newest.first().is_some_and(|oldest| © < oldest) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if has_recovery_footer(&folder.join(©.1))? {
|
||||
newest.insert(copy);
|
||||
if newest.len() > keep {
|
||||
newest.pop_first();
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
|
||||
if newest.len() < keep {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let Some(oldest) = newest.into_iter().next() else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
// A second scan lets even an oversized folder be pruned with bounded storage
|
||||
let mut first_error = None;
|
||||
for copy in copies(folder)? {
|
||||
let result = copy.and_then(|copy| {
|
||||
if copy < oldest {
|
||||
let path = folder.join(copy.1);
|
||||
if has_recovery_footer(&path)? {
|
||||
return remove(&path);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
});
|
||||
if let Err(error) = result
|
||||
&& error.kind() != ErrorKind::NotFound
|
||||
{
|
||||
first_error.get_or_insert(error);
|
||||
}
|
||||
}
|
||||
|
||||
first_error.map_or(Ok(()), Err)
|
||||
}
|
||||
|
||||
pub(crate) fn save(folder: &Path, package: &Package, keep: u32) -> io::Result<()> {
|
||||
std::fs::create_dir_all(folder)?;
|
||||
let files = ProjectFiles::build(package, "autosave.mcraft", true).map_err(io::Error::other)?;
|
||||
let options = WriteOptions::default().with_new_file_permissions(NewFilePermissions::Private);
|
||||
save_with(folder, keep, |file| files.write_zip(file).map(|_| ()).map_err(io::Error::other))
|
||||
}
|
||||
|
||||
for _ in 0..MAX_WRITE_ATTEMPTS {
|
||||
let path = next_path(folder)?;
|
||||
match options.write_new_with(&path, |file| files.write_zip(file).map(|_| ()).map_err(io::Error::other)) {
|
||||
Ok(()) => return prune(folder, keep),
|
||||
Err(error) if error.kind() == ErrorKind::AlreadyExists => continue,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
Err(io::Error::other("autosave version could not be reserved"))
|
||||
fn save_with(folder: &Path, keep: u32, write: impl FnOnce(&mut File) -> io::Result<()>) -> io::Result<()> {
|
||||
std::fs::create_dir_all(folder)?;
|
||||
|
||||
// Keep the lock file in place so concurrent processes lock the same file
|
||||
let lock = OpenOptions::new().read(true).write(true).create(true).truncate(false).open(folder.join(LOCK_FILE))?;
|
||||
lock.lock()?;
|
||||
|
||||
let path = next_path(folder)?;
|
||||
|
||||
// Publish by rename so the numbered file is never visible during copying
|
||||
let options = WriteOptions::default().with_new_file_permissions(NewFilePermissions::Private);
|
||||
options.atomic_write_with(&path, write)?;
|
||||
prune(folder, keep, |path| std::fs::remove_file(path))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::io::Write;
|
||||
use std::process::Command;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
#[test]
|
||||
fn retention_keeps_distinct_packages_and_ignores_directories() {
|
||||
@@ -138,12 +245,121 @@ mod tests {
|
||||
});
|
||||
|
||||
let mut names = Vec::new();
|
||||
for (_, entry) in copies(folder).unwrap() {
|
||||
let archive = std::fs::read(entry.path()).unwrap();
|
||||
for copy in copies(folder).unwrap() {
|
||||
let (_, filename) = copy.unwrap();
|
||||
let archive = std::fs::read(folder.join(filename)).unwrap();
|
||||
names.push(materialcraft_engine::formats::project::read(&archive, "autosave.mcraft").unwrap().pkg.graphs[0].name.clone());
|
||||
}
|
||||
|
||||
names.sort_unstable();
|
||||
assert_eq!(names, ["Graph 0", "Graph 1", "Graph 2", "Graph 3"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_truncated_legacy_copy_does_not_displace_a_complete_version() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let package = Package::new("Wood");
|
||||
save(root.path(), &package, 2).unwrap();
|
||||
let first = root.path().join("1.mcraft");
|
||||
let archive = std::fs::read(&first).unwrap();
|
||||
let incomplete = root.path().join("2.mcraft");
|
||||
std::fs::write(&incomplete, &archive[..archive.len() / 2]).unwrap();
|
||||
let embedded = root.path().join("3.mcraft");
|
||||
std::fs::write(&embedded, [&archive[..archive.len() / 2], &archive].concat()).unwrap();
|
||||
|
||||
save(root.path(), &package, 2).unwrap();
|
||||
|
||||
assert_eq!(std::fs::read(first).unwrap(), archive);
|
||||
assert!(incomplete.is_file());
|
||||
assert!(embedded.is_file());
|
||||
let latest = std::fs::read(root.path().join("4.mcraft")).unwrap();
|
||||
assert!(materialcraft_engine::formats::project::read(&latest, "autosave.mcraft").is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zip64_end_records_are_accepted() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let path = root.path().join("1.mcraft");
|
||||
let mut writer = zip::ZipWriter::new(File::create(&path).unwrap());
|
||||
writer.set_zip64_comment(Some(""));
|
||||
writer.start_file("package.sbs", zip::write::SimpleFileOptions::default()).unwrap();
|
||||
writer.finish().unwrap();
|
||||
|
||||
assert!(has_recovery_footer(&path).unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pruning_continues_after_a_deletion_error() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let package = Package::new("Wood");
|
||||
for _ in 0..4 {
|
||||
save(root.path(), &package, 4).unwrap();
|
||||
}
|
||||
|
||||
let error = prune(root.path(), 1, |path| {
|
||||
if path.ends_with("1.mcraft") {
|
||||
return Err(io::Error::new(ErrorKind::PermissionDenied, "injected deletion denial"));
|
||||
}
|
||||
|
||||
std::fs::remove_file(path)
|
||||
})
|
||||
.unwrap_err();
|
||||
|
||||
assert_eq!(error.kind(), ErrorKind::PermissionDenied);
|
||||
assert!(root.path().join("1.mcraft").is_file());
|
||||
assert!(!root.path().join("2.mcraft").exists());
|
||||
assert!(!root.path().join("3.mcraft").exists());
|
||||
assert!(root.path().join("4.mcraft").is_file());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overlapping_processes_keep_one_complete_copy_when_a_write_fails() {
|
||||
const CHILD_FOLDER: &str = "MATERIALCRAFT_AUTOSAVE_TEST_CHILD_FOLDER";
|
||||
const LOCK_CHECKED: &str = "lock-checked";
|
||||
const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
if let Some(folder) = std::env::var_os(CHILD_FOLDER) {
|
||||
let folder = PathBuf::from(folder);
|
||||
let lock = OpenOptions::new().read(true).write(true).open(folder.join(LOCK_FILE)).unwrap();
|
||||
assert!(matches!(lock.try_lock(), Err(std::fs::TryLockError::WouldBlock)));
|
||||
std::fs::write(folder.join(LOCK_CHECKED), []).unwrap();
|
||||
save(&folder, &Package::new("New"), 1).unwrap();
|
||||
return;
|
||||
}
|
||||
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let folder = root.path();
|
||||
save(folder, &Package::new("Original"), 1).unwrap();
|
||||
let first = folder.join("1.mcraft");
|
||||
let second = folder.join("2.mcraft");
|
||||
let mut child = None;
|
||||
|
||||
let result = save_with(folder, 1, |file| {
|
||||
file.write_all(b"partial archive")?;
|
||||
let process = child.insert(
|
||||
Command::new(std::env::current_exe()?)
|
||||
.args(["--exact", "autosave_versions::tests::overlapping_processes_keep_one_complete_copy_when_a_write_fails"])
|
||||
.env(CHILD_FOLDER, folder)
|
||||
.spawn()?,
|
||||
);
|
||||
let deadline = Instant::now() + HANDSHAKE_TIMEOUT;
|
||||
while !folder.join(LOCK_CHECKED).exists() {
|
||||
if process.try_wait()?.is_some() || Instant::now() >= deadline {
|
||||
return Err(io::Error::other("overlapping writer did not confirm lock contention"));
|
||||
}
|
||||
|
||||
std::thread::sleep(Duration::from_millis(5));
|
||||
}
|
||||
|
||||
assert!(first.is_file());
|
||||
assert!(!second.exists());
|
||||
Err(io::Error::new(ErrorKind::WriteZero, "injected interrupted write"))
|
||||
});
|
||||
|
||||
let child_status = child.unwrap().wait().unwrap();
|
||||
assert_eq!(result.unwrap_err().kind(), ErrorKind::WriteZero);
|
||||
assert!(child_status.success());
|
||||
assert!(!first.exists());
|
||||
let archive = std::fs::read(second).unwrap();
|
||||
assert_eq!(materialcraft_engine::formats::project::read(&archive, "autosave.mcraft").unwrap().pkg.name, "New");
|
||||
}
|
||||
}
|
||||
@@ -65,6 +65,8 @@ pub struct Cooker {
|
||||
pub suspended: bool,
|
||||
/// Tools ▸ Cancel rendering stopped the running cook: it does not start again until the next edit
|
||||
stopped_by_user: bool,
|
||||
/// The retained preview cannot supply parameter values at this epoch
|
||||
cancelled_preview_epoch: Option<u64>,
|
||||
}
|
||||
|
||||
impl Cooker {
|
||||
@@ -81,6 +83,10 @@ impl Cooker {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn preview_ready(app: &MaterialCraftApp) -> bool {
|
||||
!app.session.dirty && !app.cooker.busy() && app.cooker.cancelled_preview_epoch != Some(app.session.cook_epoch)
|
||||
}
|
||||
|
||||
/// Tools ▸ Cancel rendering: stop the running cook; the next edit cooks again
|
||||
pub fn cancel(app: &mut MaterialCraftApp) {
|
||||
if !app.cooker.busy() {
|
||||
@@ -89,6 +95,7 @@ pub fn cancel(app: &mut MaterialCraftApp) {
|
||||
|
||||
app.cooker.stop();
|
||||
app.cooker.stopped_by_user = true;
|
||||
app.cooker.cancelled_preview_epoch = Some(app.session.cook_epoch);
|
||||
app.session.dirty = false;
|
||||
}
|
||||
|
||||
@@ -124,8 +131,9 @@ pub fn drive(app: &mut MaterialCraftApp, ctx: &egui::Context) {
|
||||
}
|
||||
}
|
||||
Ok(c) => {
|
||||
if !app.cooker.suspended && !app.session.dirty && app.cooker.epoch == app.session.cook_epoch {
|
||||
if !app.cooker.suspended && !app.session.dirty && app.cooker.epoch == app.session.cook_epoch && c.graph == app.session.graph {
|
||||
app.session.accept_preview(c);
|
||||
app.cooker.cancelled_preview_epoch = None;
|
||||
}
|
||||
}
|
||||
Err(msg) if !app.cooker.suspended && !app.session.dirty && app.cooker.epoch == app.session.cook_epoch => report_failure(app, msg),
|
||||
|
||||
@@ -68,3 +68,51 @@ fn cancelling_without_a_worker_keeps_pending_work() {
|
||||
|
||||
assert!(app.session.dirty);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelled_preview_is_unavailable_for_parameter_capture_until_recooked() {
|
||||
use materialcraft_engine::core::{FunctionGraph, NodeId, Value};
|
||||
use serde_json::json;
|
||||
|
||||
let mut app = MaterialCraftApp::headless(materialcraft_engine::new_session(), crate::UiState::default());
|
||||
app.session.preview_size = Some(64);
|
||||
let owner = NodeId(app.run("graph.node.add", json!({"def": "blur"})).unwrap()["id"].as_u64().unwrap());
|
||||
let set_intensity = |app: &mut MaterialCraftApp, value| {
|
||||
let function = FunctionGraph::constant(Value::Float(value));
|
||||
app.run("graph.node.function", json!({"id": owner, "param": "intensity", "function": function})).unwrap();
|
||||
};
|
||||
let intensity = |app: &MaterialCraftApp| app.session.cooked.nodes[&owner].parameters["intensity"].clone();
|
||||
let ctx = egui::Context::default();
|
||||
set_intensity(&mut app, 0.2);
|
||||
app.session.cook();
|
||||
assert!(preview_ready(&app));
|
||||
assert_eq!(intensity(&app), Value::Float(0.2));
|
||||
|
||||
set_intensity(&mut app, 0.8);
|
||||
let (sender, receiver) = mpsc::channel();
|
||||
app.cooker.rx = Some(receiver);
|
||||
app.cooker.epoch = app.session.cook_epoch;
|
||||
app.session.dirty = false;
|
||||
cancel(&mut app);
|
||||
drop(sender);
|
||||
drive(&mut app, &ctx);
|
||||
|
||||
assert_eq!(intensity(&app), Value::Float(0.2));
|
||||
assert!(!app.session.dirty && !app.cooker.busy());
|
||||
assert!(!preview_ready(&app), "the retained value must not be offered for capture");
|
||||
|
||||
drive(&mut app, &ctx);
|
||||
assert!(!app.cooker.busy());
|
||||
app.session.dirty = true;
|
||||
drive(&mut app, &ctx);
|
||||
for _ in 0..2000 {
|
||||
if !app.cooker.busy() {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(5));
|
||||
drive(&mut app, &ctx);
|
||||
}
|
||||
|
||||
assert!(preview_ready(&app));
|
||||
assert_eq!(intensity(&app), Value::Float(0.8));
|
||||
}
|
||||
@@ -186,7 +186,10 @@ impl MaterialCraftApp {
|
||||
self.session.default_view3d = default_view;
|
||||
}
|
||||
|
||||
let preview_size = if self.ui.prefs.preview_size == 0 { None } else { Some(self.ui.prefs.preview_size.clamp(64, 8192)) };
|
||||
let preview_size = match self.ui.committed_prefs().preview_size {
|
||||
0 => None,
|
||||
size => Some(size.clamp(64, 8192)),
|
||||
};
|
||||
if self.session.preview_size != preview_size {
|
||||
let _ = materialcraft_engine::execute(&mut self.session, "view.previewSize", &serde_json::json!({"size": preview_size.unwrap_or(0)}));
|
||||
}
|
||||
|
||||
@@ -25,7 +25,7 @@ pub(super) fn show(
|
||||
.filter(|identifier| app.session.graph().is_ok_and(|graph| graph.exposed.iter().any(|input| input.id == *identifier)))
|
||||
.or_else(|| base.is_none().then(|| node.bindings.get(&descriptor.id).map(String::as_str)).flatten());
|
||||
let driven = function.is_some() || bound.is_some();
|
||||
let evaluated = (!app.session.dirty && !app.cooker.busy())
|
||||
let evaluated = crate::cook::preview_ready(app)
|
||||
.then(|| app.session.cooked.nodes.get(&node.id))
|
||||
.flatten()
|
||||
.filter(|result| result.error.is_none())
|
||||
|
||||
@@ -86,6 +86,30 @@ fn draft_limits_preserve_recents_and_undo_until_applied() {
|
||||
assert_eq!(harness.state().ui.recent, ["third.sbs"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn draft_preview_size_reaches_the_session_only_on_apply_or_ok() {
|
||||
let mut harness = harness();
|
||||
let initial = harness.state().session.preview_size;
|
||||
open(&mut harness);
|
||||
harness.state_mut().ui.prefs.preview_size = 64;
|
||||
harness.run_steps(2);
|
||||
|
||||
assert_eq!(harness.state().session.preview_size, initial);
|
||||
click(&mut harness, Role::Button, "Cancel");
|
||||
assert_eq!(harness.state().session.preview_size, initial);
|
||||
|
||||
open(&mut harness);
|
||||
harness.state_mut().ui.prefs.preview_size = 1;
|
||||
click(&mut harness, Role::Button, "Apply");
|
||||
assert_eq!(harness.state().session.preview_size, Some(64));
|
||||
|
||||
harness.state_mut().ui.prefs.preview_size = 0;
|
||||
harness.run_steps(2);
|
||||
assert_eq!(harness.state().session.preview_size, Some(64));
|
||||
click(&mut harness, Role::Button, "OK");
|
||||
assert_eq!(harness.state().session.preview_size, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_shortcut_is_captured_refused_when_taken_and_adds_its_node_over_the_graph() {
|
||||
let mut harness = harness();
|
||||
|
||||
Reference in new issue
Block a user