From bdce595fb3a60e38c43ae2f2ae33f68b7a18c47e Mon Sep 17 00:00:00 2001 From: Nathan Dane Date: Sun, 1 Nov 2026 18:30:11 +0000 Subject: [PATCH] Render results: retained renders, Live and render compare, render all shots (#6281) (#7375) * Render results: keep up to eight completed renders and select or discard them * Render results: Live and render compare with a divider, and render all shots * fix: use comparison theme tint and reveal reset test targets * fix: restore Unicode expectations in render workspace tests --- Cargo.lock | 1 + assets/locales/pending/render-results.json | 162 ++++++ crates/engine/src/cmd/render.rs | 12 +- crates/engine/src/cmd/render/job_tests.rs | 15 +- crates/engine/src/cmd/render/jobs.rs | 63 ++- crates/engine/src/cmd/render_ui.rs | 503 +++++++++++++++++- crates/engine/src/render_jobs.rs | 265 ++++++++- crates/engine/src/schema/render_ui.rs | 67 ++- crates/render/Cargo.toml | 1 + crates/render/src/job/host.rs | 11 + crates/render/src/job/host_tests.rs | 19 + crates/ui-egui/src/documents.rs | 17 + crates/ui-egui/src/lib.rs | 5 +- crates/ui-egui/src/render_ui/mod.rs | 9 + crates/ui-egui/src/render_workspace.rs | 197 ++++++- .../ui-egui/src/render_workspace_compare.rs | 291 ++++++++++ .../ui-egui/src/render_workspace_inspector.rs | 23 + crates/ui-egui/src/render_workspace_ribbon.rs | 35 +- crates/ui-egui/src/render_workspace_shots.rs | 4 + crates/ui-egui/src/render_workspace_tests.rs | 382 ++++++++++++- crates/ui-egui/src/ui_kit/compare.rs | 55 ++ crates/ui-egui/src/ui_kit/gallery.rs | 9 + crates/ui-egui/src/ui_kit/mod.rs | 2 + .../ui-egui/src/ui_kit/test_support_tests.rs | 23 + docs/render-workspace.md | 35 +- docs/ui-kit.md | 1 + 26 files changed, 2110 insertions(+), 97 deletions(-) create mode 100644 assets/locales/pending/render-results.json create mode 100644 crates/ui-egui/src/render_workspace_compare.rs create mode 100644 crates/ui-egui/src/ui_kit/compare.rs diff --git a/Cargo.lock b/Cargo.lock index 2a1f185ca..c98f5fa9b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4399,6 +4399,7 @@ dependencies = [ "serde_json", "sha2 0.10.9", "solidcraft-geom", + "web-time", "weezl", ] diff --git a/assets/locales/pending/render-results.json b/assets/locales/pending/render-results.json new file mode 100644 index 000000000..4bbd18232 --- /dev/null +++ b/assets/locales/pending/render-results.json @@ -0,0 +1,162 @@ +{ + "en": { + "cmd.render.compare.divider": "Move Render Comparison Divider", + "cmd.render.result.discard": "Discard Render Result", + "cmd.render.result.select": "Select Render Result", + "render.batch_all_shots": "All shots ({count})", + "render.batch_empty": "Save a shot before rendering all shots.", + "render.batch_limit": "Render all shots is limited to 32 shots.", + "render.batch_status": "{running} running · {waiting} waiting", + "render.compare_divider": "Comparison divider", + "render.compare_live": "Live", + "render.compare_live_preview": "Live preview", + "render.compare_render": "Render {number}", + "render.compare_side": "Render {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds} s · {renderer} · captured at revision {revision}", + "render.compare_swap": "Swap", + "render.results_choose": "Retained results", + "render.results_label": "Render {number} · {shot} · {seconds} s", + "render.results_stale_label": "{result} [stale]", + "render.results_unnamed": "Image" + }, + "de": { + "cmd.render.compare.divider": "Render-Vergleichstrenner verschieben", + "cmd.render.result.discard": "Renderergebnis verwerfen", + "cmd.render.result.select": "Renderergebnis auswählen", + "render.batch_all_shots": "Alle Ansichten ({count})", + "render.batch_empty": "Vor dem Rendern aller Ansichten eine Ansicht speichern.", + "render.batch_limit": "Es können höchstens 32 Ansichten gerendert werden.", + "render.batch_status": "{running} läuft · {waiting} warten", + "render.compare_divider": "Vergleichstrenner", + "render.compare_live": "Live", + "render.compare_live_preview": "Live-Vorschau", + "render.compare_render": "Render {number}", + "render.compare_side": "Render {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds} s · {renderer} · aufgenommen bei Revision {revision}", + "render.compare_swap": "Tauschen", + "render.results_choose": "Behaltene Ergebnisse", + "render.results_label": "Render {number} · {shot} · {seconds} s", + "render.results_stale_label": "{result} [veraltet]", + "render.results_unnamed": "Bild" + }, + "ja": { + "cmd.render.compare.divider": "レンダー比較の境界を移動", + "cmd.render.result.discard": "レンダリング結果を破棄", + "cmd.render.result.select": "レンダリング結果を選択", + "render.batch_all_shots": "すべてのショット ({count})", + "render.batch_empty": "すべてのショットをレンダリングする前にショットを保存してください。", + "render.batch_limit": "一度にレンダリングできるショットは32個までです。", + "render.batch_status": "{running} 実行中 · {waiting} 待機中", + "render.compare_divider": "比較の境界", + "render.compare_live": "ライブ", + "render.compare_live_preview": "ライブプレビュー", + "render.compare_render": "レンダー {number}", + "render.compare_side": "レンダー {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds} 秒 · {renderer} · リビジョン {revision} で取得", + "render.compare_swap": "入れ替え", + "render.results_choose": "保持した結果", + "render.results_label": "レンダー {number} · {shot} · {seconds} 秒", + "render.results_stale_label": "{result} [更新前]", + "render.results_unnamed": "画像" + }, + "ko": { + "cmd.render.compare.divider": "렌더 비교 구분선 이동", + "cmd.render.result.discard": "렌더 결과 버리기", + "cmd.render.result.select": "렌더 결과 선택", + "render.batch_all_shots": "모든 샷 ({count})", + "render.batch_empty": "모든 샷을 렌더링하기 전에 샷을 저장하세요.", + "render.batch_limit": "한 번에 최대 32개의 샷을 렌더링할 수 있습니다.", + "render.batch_status": "{running}개 실행 중 · {waiting}개 대기 중", + "render.compare_divider": "비교 구분선", + "render.compare_live": "라이브", + "render.compare_live_preview": "라이브 미리보기", + "render.compare_render": "렌더 {number}", + "render.compare_side": "렌더 {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds}초 · {renderer} · 리비전 {revision}에서 캡처", + "render.compare_swap": "맞바꾸기", + "render.results_choose": "보관된 결과", + "render.results_label": "렌더 {number} · {shot} · {seconds}초", + "render.results_stale_label": "{result} [이전 버전]", + "render.results_unnamed": "이미지" + }, + "zh": { + "cmd.render.compare.divider": "移动渲染比较分隔线", + "cmd.render.result.discard": "丢弃渲染结果", + "cmd.render.result.select": "选择渲染结果", + "render.batch_all_shots": "所有镜头 ({count})", + "render.batch_empty": "渲染所有镜头前请先保存镜头。", + "render.batch_limit": "一次最多渲染32个镜头。", + "render.batch_status": "{running} 个运行中 · {waiting} 个等待中", + "render.compare_divider": "比较分隔线", + "render.compare_live": "实时", + "render.compare_live_preview": "实时预览", + "render.compare_render": "渲染 {number}", + "render.compare_side": "渲染 {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds} 秒 · {renderer} · 捕获于修订版 {revision}", + "render.compare_swap": "交换", + "render.results_choose": "保留的结果", + "render.results_label": "渲染 {number} · {shot} · {seconds} 秒", + "render.results_stale_label": "{result} [已过期]", + "render.results_unnamed": "图像" + }, + "ar": { + "cmd.render.compare.divider": "تحريك فاصل مقارنة التصيير", + "cmd.render.result.discard": "تجاهل نتيجة التصيير", + "cmd.render.result.select": "تحديد نتيجة التصيير", + "render.batch_all_shots": "كل اللقطات ({count})", + "render.batch_empty": "احفظ لقطة قبل تصيير كل اللقطات.", + "render.batch_limit": "تصيير كل اللقطات محدود بـ 32 لقطة.", + "render.batch_status": "{running} قيد التشغيل · {waiting} في الانتظار", + "render.compare_divider": "فاصل المقارنة", + "render.compare_live": "حي", + "render.compare_live_preview": "معاينة حية", + "render.compare_render": "التصيير {number}", + "render.compare_side": "التصيير {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds} ث · {renderer} · التُقطت عند المراجعة {revision}", + "render.compare_swap": "تبديل", + "render.results_choose": "النتائج المحتفظ بها", + "render.results_label": "التصيير {number} · {shot} · {seconds} ث", + "render.results_stale_label": "{result} [قديم]", + "render.results_unnamed": "صورة" + }, + "he": { + "cmd.render.compare.divider": "הזז את מחיצת ההשוואה של הרינדור", + "cmd.render.result.discard": "השלך תוצאת רינדור", + "cmd.render.result.select": "בחר תוצאת רינדור", + "render.batch_all_shots": "כל הצילומים ({count})", + "render.batch_empty": "שמור צילום לפני רינדור כל הצילומים.", + "render.batch_limit": "רינדור כל הצילומים מוגבל ל-32 צילומים.", + "render.batch_status": "{running} רצים · {waiting} ממתינים", + "render.compare_divider": "מחיצת השוואה", + "render.compare_live": "חי", + "render.compare_live_preview": "תצוגה חיה", + "render.compare_render": "רינדור {number}", + "render.compare_side": "רינדור {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds} שנ׳ · {renderer} · נקלט בגרסה {revision}", + "render.compare_swap": "החלף", + "render.results_choose": "תוצאות שנשמרו", + "render.results_label": "רינדור {number} · {shot} · {seconds} שנ׳", + "render.results_stale_label": "{result} [ישן]", + "render.results_unnamed": "תמונה" + }, + "vi": { + "cmd.render.compare.divider": "Di chuyển vạch so sánh kết xuất", + "cmd.render.result.discard": "Bỏ kết quả kết xuất", + "cmd.render.result.select": "Chọn kết quả kết xuất", + "render.batch_all_shots": "Mọi cảnh chụp ({count})", + "render.batch_empty": "Hãy lưu một cảnh chụp trước khi kết xuất mọi cảnh chụp.", + "render.batch_limit": "Kết xuất mọi cảnh chụp giới hạn ở 32 cảnh chụp.", + "render.batch_status": "{running} đang chạy · {waiting} đang chờ", + "render.compare_divider": "Vạch so sánh", + "render.compare_live": "Trực tiếp", + "render.compare_live_preview": "Xem trước trực tiếp", + "render.compare_render": "Kết xuất {number}", + "render.compare_side": "Kết xuất {number} · {shot}", + "render.compare_summary": "{shot} · {width} × {height} · PNG · {seconds} giây · {renderer} · ghi tại bản sửa {revision}", + "render.compare_swap": "Hoán đổi", + "render.results_choose": "Kết quả được giữ lại", + "render.results_label": "Kết xuất {number} · {shot} · {seconds} giây", + "render.results_stale_label": "{result} [cũ]", + "render.results_unnamed": "Ảnh" + } +} diff --git a/crates/engine/src/cmd/render.rs b/crates/engine/src/cmd/render.rs index de8a6f697..64001d6c0 100644 --- a/crates/engine/src/cmd/render.rs +++ b/crates/engine/src/cmd/render.rs @@ -68,7 +68,7 @@ pub static COMMANDS: &[CommandSpec] = &[ CommandSpec::new("render.optics.unbind","Remove Optical Binding",optical_bindings::unbind).icon("appearance").doc_only() .params("name: saved setup; target: exact saved definition/feature/component/occurrence_path; expected_revision. Removes only that optical assignment in one undo without a device or file access."), CommandSpec::new("render.result.regrade", "Regrade Linear Master", jobs::regrade).icon("render_image").noundo().doc_only() - .params("job: exact completed JobId; presentation: {exposure_ev?,tone_map?,finishing?,backdrop?,background?,transparent_background?}. Queues cancellable nondestructive PNG presentation from that retained native FLOAT32 master, not from PNG. Captured geometry/camera/lighting and source EXR remain unchanged; no path tracing, denoising, external EXR import or automatic file writes. Returns a distinct job with source identity and original-master digest. Existing frame retention and export rules still apply."), + .params("job?: exact completed JobId (default selected result); presentation: {exposure_ev?,tone_map?,finishing?,backdrop?,background?,transparent_background?}. Queues cancellable nondestructive PNG presentation from that retained native FLOAT32 master, not from PNG. Captured geometry/camera/lighting and source EXR remain unchanged; no path tracing, denoising, external EXR import or automatic file writes. Returns a distinct job with source identity and original-master digest. Existing frame retention and export rules still apply."), CommandSpec::new("render.camera.set", "Set Render Camera", set_camera).icon("camera").noundo().doc_only() .params("camera: complete Render Camera snapshot (target, yaw, pitch, distance, fov; roll defaults to 0 and up to z). Validates the same finite mm/radian bounds as saved render intent, preserves explicit roll/up and changes only transient view state. No model evaluation, setup save, renderer, dirty flag or undo step. Design view.apply retains its separate up-axis policy."), CommandSpec::new("render.camera.get", "Inspect Render Camera", get_camera).icon("camera").noundo() @@ -102,7 +102,7 @@ CommandSpec::new("render.library.surface.bind", "Save Surface Binding", surface_ CommandSpec::new("render.library.surface.unbind", "Remove Surface Binding", surface_bindings::unbind).icon("appearance").doc_only() .params("name: setup, target: saved definition/feature/component/occurrence_path, set?: setup patch. Removes only that explicit binding in one undo; no device or current geometry required."), CommandSpec::new("render.result.pin", "Retain Displayed Render Result", jobs::pin).icon("inspect").noundo().doc_only() - .params("job: completed JobId, or null to release the displayed-result pin. Retains at most one completed result independently of a newer completion; preserves exact export bytes and original host memory accounting. No design/undo change; preview or foreign jobs refuse."), + .params("job?: completed JobId (default selected result), or null to clear selection. Selects within the eight retained completed results; oldest is evicted first. Preserves exact export bytes and original host memory accounting. No design/undo change; preview or foreign jobs refuse."), CommandSpec::new("render.library.targets", "Find Render Library Targets", library::targets).icon("list").noundo() .params("query?: exact-name substring; offset?:0; limit?:128 (1..128). Returns a bounded page of captured body ordinals/names, revision and scene bounds. Settles the model through ordinary command handling; never returns a large mesh payload."), CommandSpec::new("render.library.list", "Browse Render Library", library::list).icon("list").noundo().doc_only() @@ -128,13 +128,13 @@ CommandSpec::new("render.preflight", "Check Render Request", jobs::preflight).ic CommandSpec::new("render.start", "Render Image", jobs::start).key("R").noundo().doc_only().at("RENDER", "IMAGE").icon("render_image") .params("Same request as render.preflight. Captures an immutable product scene and queues a bounded image job. Returns its session-scoped job identity, captured scene_generation and progress. Does not change the design. See docs/render-jobs.md"), CommandSpec::new("render.status", "Render Progress", jobs::status).icon("list").noundo().doc_only() - .params("job: {session, serial, generation}. Non-blocking progress, error, optional CPU preview metadata {frame_sequence,samples_per_pixel,frame}, and completed frame metadata, optional sampling allocation/work counts and retained-master presentation provenance; no image bytes and no rendering in this call. Preview is separate from the exportable final image."), + .params("job?: {session, serial, generation}. Non-blocking progress, errors and captured frame metadata with queue:{running,waiting,job,shot,error}. Without job returns queue only. Advances an explicitly started render.batch through render.start as jobs finish; never pumps render work. Preview is separate from the exportable final image."), CommandSpec::new("render.cancel", "Cancel Render", jobs::cancel).icon("delete").noundo().doc_only() - .params("job: {session, serial, generation}. Requests cooperative cancellation; completed jobs remain completed. Late cancelled frames cannot be published."), + .params("job?: {session, serial, generation}, default the active render.batch job. Requests cooperative cancellation and drops its waiting shots; completed jobs remain completed. Late cancelled frames cannot be published."), CommandSpec::new("render.result.copy", "Copy Render Image", jobs::copy).icon("copy").noundo().doc_only() - .params("job: completed JobId. Validates the retained PNG for app clipboard copying (max 4096 per side, 4194304 pixels); headless returns frame metadata only. Never copies a provisional image or starts a job."), + .params("job?: completed JobId (default selected result). Validates the retained PNG for app clipboard copying (max 4096 per side, 4194304 pixels); headless returns frame metadata only. Never copies a provisional image or starts a job."), CommandSpec::new("render.export", "Export Render Image", jobs::export).icon("export").noundo().doc_only() - .params("job: {session, serial, generation}, path: destination matching format?: png (default) or exr, overwrite?: false. EXR requires an opt-in raw linear master retained by that completed GPU job; never converts PNG pixels. Exports a retained completed image atomically; an existing destination is preserved on failure. See docs/render-jobs.md"), + .params("job?: {session, serial, generation} (default selected result), path: destination matching format?: png (default) or exr, overwrite?: false. EXR requires an opt-in raw linear master retained by that completed GPU job; never converts PNG pixels. Exports a retained completed image atomically; an existing destination is preserved on failure. See docs/render-jobs.md"), CommandSpec::new("render.backends", "Render Backends", backends).icon("list") .noundo() .doc_only() diff --git a/crates/engine/src/cmd/render/job_tests.rs b/crates/engine/src/cmd/render/job_tests.rs index 02ee106a0..f15ddeff3 100644 --- a/crates/engine/src/cmd/render/job_tests.rs +++ b/crates/engine/src/cmd/render/job_tests.rs @@ -1052,6 +1052,14 @@ fn completed_png_content_identity_matches_status_and_exact_retained_export() { finish(&host); let newer = s.execute("render.status", &json!({"job":replacement})).unwrap(); assert_ne!(newer["frame"]["png_sha256"], metadata["png_sha256"]); + let still_retained = dir.join("still-retained.png"); + s.execute("render.export", &json!({"job":id,"path":still_retained})).unwrap(); + assert_eq!(std::fs::read(still_retained).unwrap(), bytes); + for _ in 0..7 { + let next = start(&mut s); + finish(&host); + s.execute("render.status", &json!({"job":next})).unwrap(); + } let evicted = dir.join("evicted.png"); assert!(s.execute("render.export", &json!({"job":id,"path":evicted})).is_err()); assert!(!evicted.exists()); @@ -1281,7 +1289,12 @@ fn output_viewer_copy_validates_completed_job_without_mutation_or_pixel_payloads assert_eq!(copied["frame"]["job"], json!(job)); assert_eq!(copied["frame"]["width"], 16); assert!(copied.get("png").is_none()); - for params in [json!({}), json!(null), json!({"job":job,"extra":true}), json!({"job":{"session":0,"serial":0,"generation":0}})] { + for params in [json!({}), json!(null)] { + assert_eq!(s.execute("render.result.copy", ¶ms).unwrap(), copied, "an omitted job uses the selected result"); + } + for params in + [json!({"job":1e300}), json!({"job":"selected"}), json!({"job":job,"extra":true}), json!({"job":{"session":0,"serial":0,"generation":0}})] + { assert!(s.execute("render.result.copy", ¶ms).is_err()); } assert!(Arc::ptr_eq(&document, &s.doc)); diff --git a/crates/engine/src/cmd/render/jobs.rs b/crates/engine/src/cmd/render/jobs.rs index b0b0b29de..86d4161db 100644 --- a/crates/engine/src/cmd/render/jobs.rs +++ b/crates/engine/src/cmd/render/jobs.rs @@ -675,7 +675,12 @@ pub(super) fn start(s: &mut Session, params: &Value) -> Result { p.scene, p.request, p.replace, - crate::render_jobs::Execution { executor: p.executor, options: p.options, environment: p.environment }, + crate::render_jobs::Execution { + executor: p.executor, + options: p.options, + environment: p.environment, + shot: params.get("setup").and_then(Value::as_str).map(str::to_owned), + }, ) .map_err(job_error)?; let mut status = json!(status); @@ -688,24 +693,32 @@ pub(super) fn start(s: &mut Session, params: &Value) -> Result { #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Regrade { - job: JobId, + job: Option, presentation: solidcraft_render::job::presentation::Presentation, } pub(super) fn regrade(s: &mut Session, params: &Value) -> Result { let input: Regrade = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.regrade", e.to_string()))?; input.presentation.validate().map_err(job_error)?; - Ok(json!(s.render_jobs.regrade(input.job, input.presentation).map_err(job_error)?)) + let job = result_source(s, input.job, "render.result.regrade")?; + Ok(json!(s.render_jobs.regrade(job, input.presentation).map_err(job_error)?)) } -#[derive(Deserialize)] -#[serde(deny_unknown_fields)] -struct Job { - job: JobId, +fn result_source(s: &mut Session, job: Option, command: &str) -> Result { + s.render_jobs.collect().map_err(job_error)?; + job.or_else(|| s.render_selected_result()).ok_or_else(|| bad(command, "no completed result is selected")) } pub(super) fn status(s: &mut Session, params: &Value) -> Result { - let input: Job = serde_json::from_value(params.clone()).map_err(|e| bad("render.status", e.to_string()))?; - Ok(json!(s.render_jobs.status(input.job).map_err(job_error)?)) + let input: ResultJob = serde_json::from_value(params.clone()).map_err(|e| bad("render.status", e.to_string()))?; + s.advance_render_batch()?; + let Some(job) = input.job else { + return Ok(json!({"queue":s.render_queue_state()})); + }; + let mut reply = json!(s.render_jobs.status(job).map_err(job_error)?); + if let Some(object) = reply.as_object_mut() { + object.insert("queue".into(), json!(s.render_queue_state())); + } + Ok(reply) } #[derive(Deserialize)] @@ -714,18 +727,23 @@ struct Pin { job: Option, } pub(super) fn pin(s: &mut Session, params: &Value) -> Result { - if params.get("job").is_none() { - return Err(bad("render.result.pin", "job or explicit null is required")); - } let input: Pin = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.pin", e.to_string()))?; - Ok(json!({"frame":s.render_jobs.pin(input.job).map_err(job_error)?})) + let job = if params.get("job").is_some_and(Value::is_null) { None } else { Some(result_source(s, input.job, "render.result.pin")?) }; + Ok(json!({"frame":s.render_jobs.pin(job).map_err(job_error)?})) +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct ResultJob { + job: Option, } pub(super) fn copy(s: &mut Session, params: &Value) -> Result { - let input: Job = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.copy", e.to_string()))?; + let input: ResultJob = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.copy", e.to_string()))?; + let job = result_source(s, input.job, "render.result.copy")?; let frame = s .render_jobs - .handle(input.job) + .handle(job) .map_err(job_error)? .frame() .map_err(job_error)? @@ -738,12 +756,14 @@ pub(super) fn copy(s: &mut Session, params: &Value) -> Result { } pub(super) fn cancel(s: &mut Session, params: &Value) -> Result { - let input: Job = serde_json::from_value(params.clone()).map_err(|e| bad("render.cancel", e.to_string()))?; - let status = s.render_jobs.status(input.job).map_err(job_error)?; + let input: ResultJob = serde_json::from_value(params.clone()).map_err(|e| bad("render.cancel", e.to_string()))?; + let job = input.job.or(s.render_queue_state().job).ok_or_else(|| bad("render.cancel", "job is required without an active shot queue"))?; + let status = s.render_jobs.status(job).map_err(job_error)?; + s.cancel_render_batch(job); if status.progress.phase.terminal() { return Ok(json!(status)); } - Ok(json!(s.render_jobs.handle(input.job).map_err(job_error)?.cancel().map_err(job_error)?)) + Ok(json!(s.render_jobs.handle(job).map_err(job_error)?.cancel().map_err(job_error)?)) } #[derive(Clone, Copy, Debug, Default, PartialEq, Deserialize)] @@ -766,7 +786,7 @@ impl ExportFormat { struct Export { #[serde(default)] format: ExportFormat, - job: JobId, + job: Option, path: String, #[serde(default)] overwrite: bool, @@ -784,7 +804,8 @@ pub(super) fn export(s: &mut Session, params: &Value) -> Result { // Atomic native writers are also used for the app's own files and do not // apply a request's path scope. Check the caller's destination explicitly. solidcraft_io::vfs::check(&input.path).map_err(|e| bad("render.export", e.to_string()))?; - let frame = s.render_jobs.frame(input.job).map_err(job_error)?; + let job = result_source(s, input.job, "render.export")?; + let frame = s.render_jobs.frame(job).map_err(job_error)?; let bytes = match input.format { ExportFormat::Png => frame.png(), ExportFormat::Exr => frame @@ -797,7 +818,7 @@ pub(super) fn export(s: &mut Session, params: &Value) -> Result { if input.overwrite { solidcraft_io::write_atomic(path, bytes, false) } else { solidcraft_io::safe_write::create_atomic(path, bytes) }; result.map_err(|e| bad("render.export", format!("could not export completed {}: {e}", input.format.extension())))?; Ok( - json!({"job":input.job,"path":input.path,"bytes":bytes.len(),"format":input.format.extension(),"encoding":if input.format==ExportFormat::Exr {"scene_linear_srgb_d65"} else {"srgb"},"alpha":if input.format==ExportFormat::Exr {"coverage_premultiplied"} else {"straight"},"frame":frame.info,"linear_master":frame.linear_master_info(),"presentation":frame.presentation()}), + json!({"job":job,"path":input.path,"bytes":bytes.len(),"format":input.format.extension(),"encoding":if input.format==ExportFormat::Exr {"scene_linear_srgb_d65"} else {"srgb"},"alpha":if input.format==ExportFormat::Exr {"coverage_premultiplied"} else {"straight"},"frame":frame.info,"linear_master":frame.linear_master_info(),"presentation":frame.presentation()}), ) } diff --git a/crates/engine/src/cmd/render_ui.rs b/crates/engine/src/cmd/render_ui.rs index d6f4f28d2..261ee48d1 100644 --- a/crates/engine/src/cmd/render_ui.rs +++ b/crates/engine/src/cmd/render_ui.rs @@ -1,7 +1,10 @@ -//! Planned Render interactions, with explicit non-mutating refusals. +//! Transient Render view requests and explicit refusals for planned interactions. use super::CommandSpec; use crate::schema::render_lights::{MuteParams, SoloParams}; -use crate::schema::{TypedContract, output_schema_for, render_ui::CheckReport}; +use crate::schema::{ + TypedContract, output_schema_for, + render_ui::{BatchParams, BatchResult, CheckReport, CompareDivider, CompareParams, CompareSide, ResultIndex}, +}; use crate::{Result, Session, params::bad}; use serde::Deserialize; use serde_json::{Value, json}; @@ -33,19 +36,10 @@ fn mute(_: &mut crate::Session, params: &serde_json::Value) -> crate::Result { - CommandSpec::new($id, $label, |_, _| Err(crate::EngineError::Other(concat!("not supported yet: ", $reason).into()))) - .enabled(|_| Err(concat!("not supported yet: ", $reason).into())) - .planned("5493") - .noundo() - .doc_only() - .at($tab, $panel) - .icon($icon) - .params("No supported parameters. Always refuses without changing the design or history.") - }; -} +const RESULT_INDEX: TypedContract = TypedContract::new(); +const COMPARE: TypedContract = TypedContract::new(); +const DIVIDER: TypedContract = TypedContract::new(); +const BATCH: TypedContract = TypedContract::new(); const CHECK_REPORT: TypedContract = TypedContract::new(); @@ -57,6 +51,16 @@ pub static COMMANDS: &[CommandSpec] = &[ .noundo() .doc_only() .params("text: nonempty report, at most 65536 bytes. Validated clipboard request; headless echo only, never renders or edits a design."), + CommandSpec::new("render.result.select", "Select Render Result", crate::checked!("render.result.select", select_result)) + .icon("render_image").noundo().doc_only() + .enabled(results_ready) + .contract(&RESULT_INDEX).output(output_schema_for::) + .params("index: integer 0..7, oldest first; must be retained. Selects a completed result as transient per-document view state; echoes index."), + CommandSpec::new("render.result.discard", "Discard Render Result", crate::checked!("render.result.discard", discard_result)) + .icon("delete").noundo().doc_only() + .enabled(results_ready) + .contract(&RESULT_INDEX).output(output_schema_for::) + .params("index: integer 0..7, oldest first; must be retained. Drops only that transient result, selecting the newest remaining result if necessary; echoes index."), CommandSpec::new("render.output.size", "Set Render Output Size", output_size) .icon("settings") .noundo() @@ -88,8 +92,20 @@ pub static COMMANDS: &[CommandSpec] = &[ .noundo().doc_only().icon("render_scene").at("RENDER SCENE","LIGHTS") .contract(&MUTE).output(crate::schema::output_schema_for::) .params("id: kind:slot light address; mute:bool. Validates and echoes per-document UI view state, applied to live preview and captured render copies only. Never changes saved settings or history."), - waiting!("render.compare", "Compare Images", "RENDER", "RESULT", "compare", "retained image comparison"), - waiting!("render.batch", "Render All Shots", "RENDER", "BATCH", "render_image", "the saved-shot render queue"), + CommandSpec::new("render.compare", "Compare Images", crate::checked!("render.compare", compare)) + .icon("compare").noundo().doc_only().at("RENDER", "RESULT") + .enabled(results_ready) + .contract(&COMPARE).output(output_schema_for::) + .params("left, right: live or retained result index 0..7 (oldest first), distinct and retained; OR off:true. Validated per-document comparison view request; headless echo, no rendering or design/history change."), + CommandSpec::new("render.compare.divider", "Move Render Comparison Divider", crate::checked!("render.compare.divider", divider)) + .icon("compare").noundo().doc_only() + .contract(&DIVIDER).output(output_schema_for::) + .params("position: finite number, clamped to 0.05..0.95. Transient comparison divider request; headless echo only."), + CommandSpec::new("render.batch", "Render All Shots", crate::checked!("render.batch", batch)) + .icon("render_image").noundo().doc_only().at("RENDER", "BATCH") + .enabled(|s| s.render_batch_ready()) + .contract(&BATCH).output(output_schema_for::) + .params("request?: render.start parameters, shared across all saved shots except camera. Default: first saved setup in name order. Captures up to 32 shot cameras and queues sequentially through render.start; returns {queued:n}. Refuses active renders, no shots or stale geometry. render.status (also with {}) and the UI tick advance the queue; Cancel on the active job drops waiting shots. No design/history/revision change."), ]; fn copy_check(_: &mut Session, params: &Value) -> Result { @@ -100,6 +116,110 @@ fn copy_check(_: &mut Session, params: &Value) -> Result { Ok(json!({"text":report.text})) } +fn compare(s: &mut Session, params: &Value) -> Result { + let input: CompareParams = serde_json::from_value(params.clone()).map_err(|e| bad("render.compare", e.to_string()))?; + match input { + CompareParams::Off(off) if off.off => { + s.render_jobs.set_comparison(None); + Ok(json!({"off":true})) + } + CompareParams::Pair(pair) => { + if pair.left == pair.right { + return Err(bad("render.compare", "comparison sides must differ")); + } + let results = s.render_retained_results()?; + for side in [pair.left, pair.right] { + if let CompareSide::Result(index) = side + && (index > 7 || results.get(index as usize).is_none()) + { + return Err(bad("render.compare", "retained result index is out of bounds")); + } + } + let resolve = |side| match side { + CompareSide::Live(_) => None, + CompareSide::Result(index) => results.get(index as usize).map(|result| result.frame.job), + }; + s.render_jobs.set_comparison(Some([resolve(pair.left), resolve(pair.right)])); + Ok(json!({"left":pair.left,"right":pair.right})) + } + _ => Err(bad("render.compare", "off must be true")), + } +} + +fn divider(_: &mut Session, params: &Value) -> Result { + let input: CompareDivider = serde_json::from_value(params.clone()).map_err(|e| bad("render.compare.divider", e.to_string()))?; + if !input.position.is_finite() { + return Err(bad("render.compare.divider", "position must be finite")); + } + Ok(json!({"position":input.position.clamp(0.05,0.95)})) +} + +fn batch(s: &mut Session, params: &Value) -> Result { + let input: BatchParams = serde_json::from_value(params.clone()).map_err(|e| bad("render.batch", e.to_string()))?; + s.render_batch_ready().map_err(|reason| bad("render.batch", reason))?; + if s.model.is_stale() { + return Err(bad("render.batch", "finish the modelling gesture before rendering shots")); + } + for name in s.doc.render.setups.keys() { + solidcraft_doc::render_settings::RenderSettings::validate_name(name).map_err(|error| bad("render.batch", error.to_string()))?; + } + let common = if let Some(request) = input.request { + Value::Object(request.into_iter().collect()) + } else { + let setup = s.doc.render.setups.values().next().ok_or_else(|| bad("render.batch", "no saved shots"))?; + json!({"settings":setup}) + }; + let mut request = common.as_object().cloned().ok_or_else(|| bad("render.batch", "request must be an object"))?; + let settings = if let Some(name) = request.get("setup") { + let name = name.as_str().ok_or_else(|| bad("render.batch", "setup must be a saved name"))?; + if request.contains_key("settings") { + return Err(bad("render.batch", "choose either setup or settings")); + } + s.doc.render.setups.get(name).cloned().ok_or_else(|| bad("render.batch", "unknown saved setup"))? + } else if let Some(settings) = request.get("settings") { + serde_json::from_value(settings.clone()).map_err(|e| bad("render.batch", e.to_string()))? + } else { + s.doc.render.setups.values().next().cloned().ok_or_else(|| bad("render.batch", "no saved shots"))? + }; + request.remove("setup"); + // A batch never replaces an active job; malformed replace values must still refuse. + if request.get("replace").is_some_and(|value| value != &json!(false)) { + return Err(bad("render.batch", "replace must be false or omitted")); + } + request.insert("settings".into(), json!(settings)); + let request = std::sync::Arc::new(Value::Object(request)); + let shots = s + .doc + .render + .setups + .iter() + .map(|(name, shot)| crate::render_jobs::BatchShot { name: name.clone(), camera: shot.camera, request: request.clone() }) + .collect(); + let queued = s.start_render_batch(shots)?; + Ok(json!({"queued":queued})) +} + +fn results_ready(s: &Session) -> std::result::Result<(), String> { + if s.render_jobs.has_results() { Ok(()) } else { Err("no completed render results are retained".into()) } +} + +fn indexed_result(s: &mut Session, params: &Value, command: &str, discard: bool) -> Result { + let input: ResultIndex = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?; + if input.index > 7 { + return Err(bad(command, "index must be in 0..7")); + } + s.render_jobs.result_index(input.index as usize, discard).map_err(crate::render_jobs::job_error)?; + Ok(json!({"index":input.index})) +} + +fn select_result(s: &mut Session, params: &Value) -> Result { + indexed_result(s, params, "render.result.select", false) +} + +fn discard_result(s: &mut Session, params: &Value) -> Result { + indexed_result(s, params, "render.result.discard", true) +} + #[cfg(test)] #[test] fn render_lights_remaining_planned_commands_refuse_without_mutation() { @@ -149,17 +269,21 @@ fn output_size(_: &mut Session, params: &Value) -> Result { struct ResultView { view: String, } -fn result_view(_: &mut Session, params: &Value) -> Result { +fn result_view(s: &mut Session, params: &Value) -> Result { let input: ResultView = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.view", e.to_string()))?; if !matches!(input.view.as_str(), "model" | "image" | "fit" | "actual") { return Err(bad("render.result.view", "view must be model, image, fit or actual")); } + if input.view == "model" { + s.render_jobs.set_comparison(None); + } Ok(json!({"view":input.view})) } -fn close_result(_: &mut Session, params: &Value) -> Result { +fn close_result(s: &mut Session, params: &Value) -> Result { if !params.as_object().is_some_and(|p| p.is_empty()) { return Err(bad("render.result.close", "expected no parameters")); } + s.render_jobs.set_comparison(None); Ok(json!({"view":"model"})) } @@ -210,3 +334,344 @@ fn output_sections_copy_report_validates_without_design_history_or_job_changes() assert!(std::sync::Arc::ptr_eq(&doc, &s.doc)); assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); } + +#[cfg(test)] +fn complete_result(s: &mut Session, shot: &str) -> solidcraft_render::job::JobId { + let reply = s.execute("render.start", &json!({"setup":shot})).unwrap(); + let job = serde_json::from_value(reply["job"].clone()).unwrap(); + let host = s.render_job_host().unwrap().clone(); + for _ in 0..1000 { + host.pump(4096).unwrap(); + if s.execute("render.status", &json!({"job":job})).unwrap()["progress"]["phase"] == "completed" { + return job; + } + } + panic!("bounded result fixture did not complete"); +} + +#[cfg(test)] +#[test] +fn retained_results_cap_order_metadata_and_selection_never_edit_a_design() { + let mut s = Session::default(); + s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap(); + s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":16,"height":8}})).unwrap(); + s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":32}})).unwrap(); + s.execute("edit.undo", &json!({})).unwrap(); + assert_eq!(s.redo.len(), 1, "view commands must preserve an available redo step"); + let document = s.doc.clone(); + let before = (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty()); + let jobs: Vec<_> = (0..10).map(|_| complete_result(&mut s, "Hero")).collect(); + let results = s.render_retained_results().unwrap(); + assert_eq!(results.len(), 8); + assert_eq!(results.iter().map(|result| result.frame.job).collect::>(), jobs[2..]); + for result in &results { + assert_eq!(result.shot.as_deref(), Some("Hero")); + assert_eq!((result.frame.width, result.frame.height), (16, 8)); + assert!(result.seconds.is_finite() && result.seconds >= 0.0); + assert_eq!(result.frame.scene_generation, s.revision); + assert!(!result.stale); + } + assert!(s.render_job_handle(jobs[0]).is_err()); + assert!(s.render_job_handle(jobs[1]).is_err()); + assert_eq!(s.render_selected_result(), Some(jobs[9])); + assert_eq!(s.execute("render.result.select", &json!({"index":0})).unwrap(), json!({"index":0})); + assert_eq!(s.render_selected_result(), Some(jobs[2])); + assert_eq!(s.execute("render.result.copy", &json!({})).unwrap()["frame"]["job"], json!(jobs[2])); + assert_eq!(s.execute("render.result.pin", &json!({})).unwrap()["frame"]["job"], json!(jobs[2])); + s.execute("render.result.discard", &json!({"index":0})).unwrap(); + assert_eq!(s.render_selected_result(), Some(jobs[9])); + assert!(s.render_job_handle(jobs[2]).is_err()); + s.execute("render.result.select", &json!({"index":2})).unwrap(); + s.execute("render.result.discard", &json!({"index":0})).unwrap(); + assert_eq!(s.render_selected_result(), Some(jobs[5]), "discarding an earlier row preserves the selected identity"); + while !s.render_retained_results().unwrap().is_empty() { + s.execute("render.result.discard", &json!({"index":0})).unwrap(); + } + assert!(s.render_selected_result().is_none()); + assert!(s.execute("render.result.copy", &json!({})).is_err()); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty())); +} + +#[cfg(test)] +#[test] +fn retained_result_requests_refuse_hostile_and_missing_indices_atomically() { + let mut s = Session::default(); + s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap(); + s.execute("render.settings.set", &json!({"name":"Front","set":{"width":8,"height":8}})).unwrap(); + let job = complete_result(&mut s, "Front"); + let document = s.doc.clone(); + let before = (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty()); + let retained = s.render_job_host().unwrap().admitted_bytes(); + for mode in [crate::schema::ParamCheck::Off, crate::schema::ParamCheck::Strict] { + s.param_check = mode; + for command in ["render.result.select", "render.result.discard"] { + let spec = super::find_command(command).unwrap(); + assert!(spec.contract.is_some() && spec.output.is_some()); + for request in [ + json!(null), + json!([]), + json!({}), + json!({"index":-1}), + json!({"index":0.5}), + json!({"index":1e300}), + json!({"index":u64::MAX}), + json!({"index":"0"}), + json!({"index":null}), + json!({"index":true}), + json!({"index":1}), + json!({"index":8}), + json!({"index":0,"extra":true}), + ] { + assert!(s.execute(command, &request).is_err(), "{command}: {request}"); + assert_eq!(s.render_retained_results().unwrap().len(), 1); + assert_eq!(s.render_selected_result(), Some(job)); + assert_eq!(s.render_job_host().unwrap().admitted_bytes(), retained); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty())); + } + } + } + s.execute("render.settings.set", &json!({"name":"Front","set":{"width":16}})).unwrap(); + assert!(s.render_retained_results().unwrap()[0].stale); + s.execute("edit.undo", &json!({})).unwrap(); + assert!(s.render_retained_results().unwrap()[0].stale, "undo does not recapture pixels"); + assert_eq!(s.render_retained_results().unwrap()[0].frame.scene_generation, before.2); + let mut other = Session::default(); + assert!(other.render_retained_results().unwrap().is_empty()); + assert!(other.execute("render.result.select", &json!({"index":0})).is_err()); + assert!(other.render_job_handle(job).is_err()); +} + +#[cfg(test)] +#[test] +fn render_results_compare_validates_both_sides_and_clamps_only_finite_dividers_without_mutation() { + let mut s = Session::default(); + s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap(); + s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":8,"height":8}})).unwrap(); + complete_result(&mut s, "Hero"); + complete_result(&mut s, "Hero"); + s.execute("render.settings.set", &json!({"name":"Hero","set":{"width":16}})).unwrap(); + s.execute("edit.undo", &json!({})).unwrap(); + let document = s.doc.clone(); + let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()); + let selected = s.selection.clone(); + for mode in [crate::schema::ParamCheck::Off, crate::schema::ParamCheck::Strict] { + s.param_check = mode; + for request in [json!({"left":"live","right":0}), json!({"left":1,"right":0}), json!({"left":0,"right":"live"}), json!({"off":true})] { + assert_eq!(s.execute("render.compare", &request).unwrap(), request); + } + for request in [ + json!({}), + json!([]), + json!({"off":false}), + json!({"off":true,"left":0}), + json!({"left":"live","right":"live"}), + json!({"left":0,"right":0}), + json!({"left":"unknown","right":0}), + json!({"left":"live","right":2}), + json!({"left":8,"right":0}), + json!({"left":-1,"right":0}), + json!({"left":0.5,"right":0}), + json!({"left":1e300,"right":"live"}), + json!({"left":null,"right":0}), + json!({"left":"0","right":1}), + json!({"left":true,"right":0}), + json!({"left":"live","right":0,"extra":true}), + ] { + assert!(s.execute("render.compare", &request).is_err(), "{request}"); + } + for (position, expected) in [(-1e300, 0.05), (0.0, 0.05), (0.25, 0.25), (1.0, 0.95), (1e300, 0.95)] { + assert_eq!(s.execute("render.compare.divider", &json!({"position":position})).unwrap(), json!({"position":expected})); + } + for request in [json!({}), json!({"position":null}), json!({"position":"NaN"}), json!({"position":true}), json!({"position":0.5,"extra":1})] { + assert!(s.execute("render.compare.divider", &request).is_err()); + } + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); + assert_eq!(s.selection, selected); + assert_eq!(s.render_retained_results().unwrap().len(), 2); + } + let mut empty = Session::default(); + assert!(empty.execute("render.compare", &json!({"left":"live","right":0})).is_err()); + assert!(empty.execute("render.compare", &json!({"off":true})).is_err()); + for id in ["render.compare", "render.compare.divider", "render.batch"] { + let command = super::find_command(id).unwrap(); + assert!(command.contract.is_some() && command.output.is_some() && command.planned.is_none()); + assert!(!command.undoable && !command.reads_model); + } +} + +#[cfg(test)] +fn batch_fixture(count: usize) -> Session { + let mut s = Session::default(); + s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap(); + for index in 0..count { + let camera = solidcraft_render::Camera { yaw: index as f64 * 0.2, roll: index as f64 * 0.01, ..Default::default() }; + s.execute("render.settings.set", &json!({"name":format!("Shot {index:02}"),"set":{"camera":camera,"width":8+index,"height":8}})).unwrap(); + } + s +} + +#[cfg(test)] +#[test] +fn render_results_batch_is_sequential_uses_snapshot_cameras_and_one_setup_without_design_or_history_changes() { + let mut s = batch_fixture(3); + s.execute("render.settings.set", &json!({"name":"Shot 00","set":{"width":64}})).unwrap(); + s.execute("edit.undo", &json!({})).unwrap(); + let document = s.doc.clone(); + let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()); + let cameras: Vec<_> = s.doc.render.setups.values().map(|setup| setup.camera).collect(); + s.param_check = crate::schema::ParamCheck::Strict; + assert_eq!( + s.execute("render.batch", &json!({"request":{"settings":{"width":12,"height":10,"background":[7,8,9]}}})).unwrap(), + json!({"queued":3}) + ); + assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (1, 2)); + assert!(s.execute("render.batch", &json!({})).is_err()); + let host = s.render_job_host().unwrap().clone(); + let mut jobs = Vec::new(); + for (index, camera) in cameras.iter().enumerate() { + let queue = s.render_queue_state(); + assert_eq!((queue.running, queue.waiting), (1, 2 - index)); + let job = queue.job.unwrap(); + let status = s.render_job_handle(job).unwrap().status().unwrap(); + assert_eq!(status.request.camera, *camera); + assert_eq!((status.request.width, status.request.height, status.request.background), (12, 10, [7, 8, 9])); + assert_eq!(queue.shot, Some(format!("Shot {index:02}"))); + jobs.push(job); + for _ in 0..100 { + if !host.pump(4096).unwrap() { + break; + } + } + let reply = s.execute("render.status", &json!({"job":job})).unwrap(); + assert_eq!(reply["progress"]["phase"], "completed"); + } + assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (0, 0)); + assert!(s.render_queue_state().job.is_none()); + let results = s.render_retained_results().unwrap(); + assert_eq!(results.iter().map(|result| result.frame.job).collect::>(), jobs); + assert_eq!(results.iter().map(|result| result.shot.clone().unwrap()).collect::>(), ["Shot 00", "Shot 01", "Shot 02"]); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); +} + +#[cfg(test)] +#[test] +fn render_results_batch_caps_at_32_and_cancel_discards_every_waiting_shot() { + let mut s = batch_fixture(32); + let document = s.doc.clone(); + let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()); + assert_eq!(s.execute("render.batch", &json!({})).unwrap(), json!({"queued":32})); + let queue = s.render_queue_state(); + assert_eq!((queue.running, queue.waiting), (1, 31)); + let job = queue.job.unwrap(); + assert!(s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).is_err()); + s.execute("render.cancel", &json!({})).unwrap(); + assert_eq!(s.render_queue_state().waiting, 0); + assert!(s.render_queue_state().job.is_none()); + s.render_job_host().unwrap().pump(4096).unwrap(); + assert!(s.render_job_handle(job).unwrap().frame().unwrap().is_none()); + for _ in 0..3 { + assert_eq!(s.execute("render.status", &json!({})).unwrap()["queue"]["waiting"], 0); + } + assert!(s.render_retained_results().unwrap().is_empty()); + let next = s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap(); + assert_eq!(next["job"]["serial"], 2, "Cancel must not start any waiting shot"); + s.execute("render.cancel", &json!({"job":next["job"]})).unwrap(); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); + std::sync::Arc::make_mut(&mut std::sync::Arc::make_mut(&mut s.doc).render).setups.insert("Over limit".into(), Default::default()); + assert!(s.execute("render.batch", &json!({})).unwrap_err().to_string().contains("32")); + assert_eq!(s.render_queue_state().waiting, 0); +} + +#[cfg(test)] +#[test] +fn render_results_batch_refuses_missing_shots_busy_hostile_and_failed_requests_without_queuing() { + let mut empty = batch_fixture(0); + assert!(empty.execute("render.batch", &json!({})).is_err()); + let mut s = batch_fixture(2); + let document = s.doc.clone(); + let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()); + for request in [ + json!([]), + json!({"request":1e300}), + json!({"request":[]}), + json!({"request":{"bogus":true}}), + json!({"request":{"replace":true}}), + json!({"request":{"settings":{"width":0}}}), + json!({"extra":true}), + ] { + assert!(s.execute("render.batch", &request).is_err(), "{request}"); + assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (0, 0)); + assert!(s.render_queue_state().job.is_none()); + } + let job = s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap()["job"].clone(); + assert!(s.execute("render.batch", &json!({})).is_err()); + assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (1, 0)); + s.execute("render.cancel", &json!({"job":job})).unwrap(); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); + s.set_render_job_host(None).unwrap(); + assert!(s.execute("render.batch", &json!({})).is_err()); + assert_eq!((s.render_queue_state().running, s.render_queue_state().waiting), (0, 0)); + assert!(s.render_queue_state().error.is_some()); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); +} + +#[cfg(test)] +#[test] +fn render_results_batch_cameras_and_common_setup_are_captured_before_later_shot_edits() { + let mut s = batch_fixture(2); + let original = s.doc.render.setups.get("Shot 01").unwrap().camera; + s.execute("render.batch", &json!({"request":{"setup":"Shot 00"}})).unwrap(); + let first = s.render_queue_state().job.unwrap(); + let changed = solidcraft_render::Camera { yaw: 2.0, ..Default::default() }; + s.execute("render.settings.set", &json!({"name":"Shot 01","set":{"camera":changed}})).unwrap(); + s.execute("render.settings.set", &json!({"name":"Shot 00","set":{"width":64}})).unwrap(); + let document = s.doc.clone(); + let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations); + let host = s.render_job_host().unwrap().clone(); + for _ in 0..100 { + if !host.pump(4096).unwrap() { + break; + } + } + let reply = s.execute("render.status", &json!({})).unwrap(); + let next: solidcraft_render::job::JobId = serde_json::from_value(reply["queue"]["job"].clone()).unwrap(); + assert_ne!(next, first); + let request = s.render_job_handle(next).unwrap().status().unwrap().request; + assert_eq!(request.camera, original); + assert_eq!(request.width, 8); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations)); + s.execute("render.cancel", &json!({"job":next})).unwrap(); +} + +#[cfg(test)] +#[test] +fn render_results_compare_keeps_copy_on_the_visible_result_until_a_source_is_evicted() { + let mut s = batch_fixture(1); + let first = complete_result(&mut s, "Shot 00"); + complete_result(&mut s, "Shot 00"); + s.execute("render.compare", &json!({"left":"live","right":0})).unwrap(); + assert_eq!(s.render_comparison(), Some([None, Some(first)])); + assert_eq!(s.render_selected_result(), Some(first)); + let document = s.doc.clone(); + let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations); + let mut newest = first; + for index in 0..7 { + newest = complete_result(&mut s, "Shot 00"); + if index < 6 { + assert_eq!(s.execute("render.result.copy", &json!({})).unwrap()["frame"]["job"], json!(first)); + assert_eq!(s.render_comparison(), Some([None, Some(first)])); + } + } + assert!(s.render_comparison().is_none()); + assert_eq!(s.render_selected_result(), Some(newest)); + assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations)); +} diff --git a/crates/engine/src/render_jobs.rs b/crates/engine/src/render_jobs.rs index 7ea415311..b7d0d801a 100644 --- a/crates/engine/src/render_jobs.rs +++ b/crates/engine/src/render_jobs.rs @@ -36,6 +36,41 @@ pub(crate) struct Execution { pub executor: solidcraft_render::ExecutorId, pub options: solidcraft_render::job::JobOptions, pub environment: Option, + pub shot: Option, +} + +struct LiveJob { + handle: JobHandle, + shot: Option, +} + +/// Transient completed-image metadata. Neither pixels nor selection enter a design or undo. +#[derive(Clone, Debug, serde::Serialize)] +pub struct RetainedResult { + pub frame: solidcraft_render::job::FrameInfo, + pub shot: Option, + pub seconds: f64, + pub stale: bool, +} + +struct Completed { + handle: JobHandle, + info: RetainedResult, +} + +pub(crate) struct BatchShot { + pub name: String, + pub camera: solidcraft_render::Camera, + pub request: Arc, +} + +#[derive(Clone, Debug, serde::Serialize)] +pub struct RenderQueueState { + pub running: usize, + pub waiting: usize, + pub job: Option, + pub shot: Option, + pub error: Option, } pub(crate) struct Jobs { @@ -45,12 +80,14 @@ pub(crate) struct Jobs { pub(crate) host: Option, pub(crate) descriptor: Option, pub(crate) additional: Vec<(CpuHost, ExecutorDescriptor)>, - live: Vec, + live: Vec, history: VecDeque, - last_good: Option, - /// One explicitly displayed completed result, independent of a newer completion. - /// The existing frame Arc keeps its original host reservation accounted for. - pinned: Option, + completed: VecDeque, + selected: Option, + waiting: VecDeque, + batch_job: Option, + batch_error: Option, + comparison: Option<[Option; 2]>, } impl Default for Jobs { @@ -64,8 +101,12 @@ impl Default for Jobs { additional: Vec::new(), live: Vec::new(), history: VecDeque::new(), - last_good: None, - pinned: None, + completed: VecDeque::new(), + selected: None, + waiting: VecDeque::new(), + batch_job: None, + batch_error: None, + comparison: None, } } } @@ -73,12 +114,26 @@ impl Default for Jobs { impl Drop for Jobs { fn drop(&mut self) { for job in &self.live { - let _ = job.cancel(); + let _ = job.handle.cancel(); } } } impl Jobs { + pub(crate) fn set_comparison(&mut self, sides: Option<[Option; 2]>) { + self.comparison = sides; + if let Some([left, right]) = sides { + self.selected = right.or(left); + } + } + + fn valid_comparison(&self) -> Option<[Option; 2]> { + self.comparison.filter(|sides| sides.iter().flatten().all(|job| self.completed.iter().any(|result| result.handle.id() == *job))) + } + pub(crate) fn has_results(&self) -> bool { + !self.completed.is_empty() || self.live.iter().any(|job| job.handle.frame().ok().flatten().is_some()) + } + pub(crate) fn host_for(&self, executor: &solidcraft_render::ExecutorId) -> Option<&CpuHost> { if executor.as_str() == "cpu-raytrace" { return self @@ -103,14 +158,26 @@ impl Jobs { pub(crate) fn collect(&mut self) -> Result<(), JobError> { let mut i = 0; while i < self.live.len() { - let status = self.live.get(i).ok_or_else(|| JobError::new(ErrorCode::Internal, "missing live job"))?.status()?; + let status = self.live.get(i).ok_or_else(|| JobError::new(ErrorCode::Internal, "missing live job"))?.handle.status()?; if !status.progress.phase.terminal() { i += 1; continue; } - let handle = self.live.remove(i); - if status.progress.phase == Phase::Completed && self.last_good.as_ref().is_none_or(|old| old.id().serial < handle.id().serial) { - self.last_good = Some(handle); + let job = self.live.remove(i); + if let Some(frame) = status.frame.as_ref().filter(|_| status.progress.phase == Phase::Completed) { + let seconds = job.handle.completed_duration()?.map_or(0.0, |duration| duration.as_secs_f64()); + let completed_id = job.handle.id(); + self.completed.push_back(Completed { + handle: job.handle, + info: RetainedResult { frame: frame.clone(), shot: job.shot, seconds, stale: false }, + }); + while self.completed.len() > 8 { + self.completed.pop_front(); + } + if self.valid_comparison().is_none() { + self.comparison = None; + self.selected = Some(completed_id); + } } self.history.push_back(status); while self.history.len() > 4 { @@ -128,12 +195,19 @@ impl Jobs { replace: bool, execution: Execution, ) -> Result { - let Execution { executor, options, environment } = execution; + let Execution { executor, options, environment, shot } = execution; + if self.batch_job.is_some() { + if !replace { + return Err(JobError::new(ErrorCode::QueueFull, "cancel the shot queue before starting another render")); + } + self.waiting.clear(); + self.batch_job = None; + } self.collect()?; let host = self.host_for(&executor).ok_or_else(|| JobError::new(ErrorCode::HostUnavailable, "resolved image host is not installed"))?.clone(); if replace { for job in self.live.drain(..) { - let mut status = job.cancel()?; + let mut status = job.handle.cancel()?; // Replaced handles are deliberately abandoned: keep a cancellation tombstone, // not a permanently "cancelling" snapshot. The token already prevents any // publication; the host can finish releasing its buffers asynchronously. @@ -165,7 +239,7 @@ impl Jobs { let status = handle.status()?; self.serial = serial; self.generation = generation; - self.live.push(handle); + self.live.push(LiveJob { handle, shot }); Ok(status) } @@ -174,6 +248,9 @@ impl Jobs { source_id: JobId, presentation: solidcraft_render::job::presentation::Presentation, ) -> Result { + if self.batch_job.is_some() { + return Err(JobError::new(ErrorCode::QueueFull, "cancel the shot queue before regrading")); + } self.collect()?; let source = self.handle(source_id)?; let frame = source.frame()?.ok_or_else(|| JobError::new(ErrorCode::NotCompleted, "regrade requires a completed frame"))?; @@ -194,7 +271,8 @@ impl Jobs { let status = handle.status()?; self.serial = serial; self.generation = generation; - self.live.push(handle); + let shot = self.completed.iter().find(|result| result.handle.id() == source_id).and_then(|result| result.info.shot.clone()); + self.live.push(LiveJob { handle, shot }); Ok(status) } @@ -209,8 +287,8 @@ impl Jobs { self.check_owner(id)?; self.live .iter() - .chain(self.last_good.iter()) - .chain(self.pinned.iter()) + .map(|job| &job.handle) + .chain(self.completed.iter().map(|result| &result.handle)) .find(|j| j.id() == id) .cloned() .ok_or_else(|| JobError::new(ErrorCode::UnknownJob, "render job is no longer retained")) @@ -226,17 +304,35 @@ impl Jobs { } pub(crate) fn pin(&mut self, id: Option) -> Result, JobError> { + self.collect()?; let Some(id) = id else { - self.pinned = None; + self.selected = None; + self.comparison = None; return Ok(None); }; let handle = self.handle(id)?; let frame = handle.frame()?.ok_or_else(|| JobError::new(ErrorCode::NotCompleted, "only a completed result can be pinned"))?; let info = frame.info.clone(); - self.pinned = Some(handle); + self.comparison = None; + self.selected = Some(id); Ok(Some(info)) } + pub(crate) fn result_index(&mut self, index: usize, discard: bool) -> Result<(), JobError> { + self.collect()?; + let id = self.completed.get(index).ok_or_else(|| JobError::new(ErrorCode::UnknownJob, "retained result index is out of bounds"))?.handle.id(); + if discard { + self.completed.remove(index); + if self.selected == Some(id) { + self.selected = self.completed.back().map(|result| result.handle.id()); + } + } else { + self.comparison = None; + self.selected = Some(id); + } + Ok(()) + } + pub(crate) fn frame(&mut self, id: JobId) -> Result, JobError> { self.collect()?; self.handle(id)?.frame()?.ok_or_else(|| JobError::new(ErrorCode::NotCompleted, "render has no completed image")) @@ -244,6 +340,126 @@ impl Jobs { } impl crate::Session { + pub fn render_comparison(&self) -> Option<[Option; 2]> { + self.render_jobs.valid_comparison() + } + + pub fn render_queue_state(&self) -> RenderQueueState { + let active = self.render_jobs.batch_job.and_then(|id| self.render_jobs.live.iter().find(|job| job.handle.id() == id)); + RenderQueueState { + running: self.render_jobs.live.iter().filter(|job| job.handle.status().is_ok_and(|status| !status.progress.phase.terminal())).count(), + waiting: self.render_jobs.waiting.len(), + job: self.render_jobs.batch_job, + shot: active.and_then(|job| job.shot.clone()), + error: self.render_jobs.batch_error.clone(), + } + } + + pub fn render_batch_ready(&self) -> std::result::Result<(), String> { + if self.doc.render.setups.is_empty() { + return Err("no saved shots to render".into()); + } + if self.doc.render.setups.len() > 32 { + return Err("render all shots is limited to 32 shots".into()); + } + if self.render_jobs.batch_job.is_some() || self.render_queue_state().running != 0 { + return Err("a render or shot queue is already active".into()); + } + Ok(()) + } + + pub(crate) fn start_render_batch(&mut self, shots: VecDeque) -> crate::Result { + self.render_batch_ready().map_err(crate::EngineError::Other)?; + if shots.is_empty() || shots.len() > 32 { + return Err(crate::EngineError::Other("shot queue must contain 1..32 shots".into())); + } + let queued = shots.len(); + self.render_jobs.waiting = shots; + self.render_jobs.batch_error = None; + self.start_next_batch_shot()?; + Ok(queued) + } + + fn start_next_batch_shot(&mut self) -> crate::Result<()> { + let Some(shot) = self.render_jobs.waiting.pop_front() else { return Ok(()) }; + let result: crate::Result<()> = (|| { + let mut params = (*shot.request).clone(); + let settings = params + .get_mut("settings") + .and_then(serde_json::Value::as_object_mut) + .ok_or_else(|| crate::EngineError::Other("queued render settings are missing".into()))?; + settings.insert("camera".into(), serde_json::json!(shot.camera)); + let reply = self.execute("render.start", ¶ms)?; + let job: JobId = serde_json::from_value(reply.get("job").cloned().unwrap_or_default()) + .map_err(|error| crate::EngineError::Other(format!("invalid queued render identity: {error}")))?; + self.label_render_job(job, &shot.name)?; + self.render_jobs.batch_job = Some(job); + Ok(()) + })(); + if let Err(error) = &result { + self.render_jobs.waiting.clear(); + self.render_jobs.batch_error = Some(error.to_string()); + } + result + } + + /// Non-blocking queue scheduling. The existing host still owns all render work. + pub fn advance_render_batch(&mut self) -> crate::Result<()> { + let Some(job) = self.render_jobs.batch_job else { return Ok(()) }; + let status = self.render_jobs.status(job).map_err(job_error)?; + if !status.progress.phase.terminal() { + return Ok(()); + } + self.render_jobs.batch_job = None; + if status.progress.phase != Phase::Completed { + self.render_jobs.waiting.clear(); + self.render_jobs.batch_error = status.error.map(|error| error.to_string()); + return Ok(()); + } + self.start_next_batch_shot() + } + + pub(crate) fn cancel_render_batch(&mut self, job: JobId) { + if self.render_jobs.batch_job == Some(job) { + self.render_jobs.waiting.clear(); + self.render_jobs.batch_job = None; + } + } + + /// Capture the UI draft's label alongside an unnamed active request, never in the design. + pub fn label_render_job(&mut self, id: JobId, shot: &str) -> crate::Result<()> { + solidcraft_doc::render_settings::RenderSettings::validate_name(shot).map_err(|error| crate::EngineError::Other(error.to_string()))?; + let job = self + .render_jobs + .live + .iter_mut() + .find(|job| job.handle.id() == id) + .ok_or_else(|| job_error(JobError::new(ErrorCode::UnknownJob, "render job is no longer active")))?; + if job.shot.is_none() { + job.shot = Some(shot.to_owned()); + } + Ok(()) + } + + /// Oldest first, capped at eight. Staleness follows the current design revision. + pub fn render_retained_results(&mut self) -> crate::Result> { + self.render_jobs.collect().map_err(job_error)?; + Ok(self + .render_jobs + .completed + .iter() + .map(|result| { + let mut info = result.info.clone(); + info.stale = info.frame.scene_generation != self.revision; + info + }) + .collect()) + } + + pub fn render_selected_result(&self) -> Option { + self.render_jobs.selected + } + /// A host is installed by the application, never by document data or a command. pub fn set_render_job_host(&mut self, host: Option) -> crate::Result<()> { if self.render_jobs.host.as_ref().zip(host.as_ref()).is_some_and(|(a, b)| a.same_host(b)) { @@ -350,7 +566,7 @@ mod displayed_result_tests { panic!("bounded result fixture did not finish") } #[test] - fn explicit_display_pin_preserves_the_old_exact_frame_without_unbounded_history() { + fn explicit_display_pin_selects_exact_bytes_within_bounded_retention() { let mut s = crate::Session::default(); let host = CpuHost::cooperative(); s.set_render_job_host(Some(host.clone())).unwrap(); @@ -368,10 +584,11 @@ mod displayed_result_tests { let foreign = JobId { session: old.session + 1, ..old }; assert!(s.execute("render.result.pin", &json!({"job":foreign})).is_err()); assert_eq!(host.admitted_bytes(), retained); - assert!(s.execute("render.result.pin", &json!({})).is_err()); + assert_eq!(s.execute("render.result.pin", &json!({})).unwrap()["frame"]["job"], json!(s.render_selected_result())); s.execute("render.result.pin", &json!({"job":null})).unwrap(); - assert!(s.render_job_handle(old).is_err()); - assert!(host.admitted_bytes() < retained); + assert!(s.render_selected_result().is_none()); + assert!(s.render_job_handle(old).is_ok(), "clearing selection does not discard retained results"); + assert_eq!(host.admitted_bytes(), retained); assert_eq!(s.doc.to_json(), before); assert_eq!(s.undo.len(), undo); let reply = s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap(); diff --git a/crates/engine/src/schema/render_ui.rs b/crates/engine/src/schema/render_ui.rs index eef51c954..be7551493 100644 --- a/crates/engine/src/schema/render_ui.rs +++ b/crates/engine/src/schema/render_ui.rs @@ -1,4 +1,4 @@ -//! Clipboard requests for the Render workspace; headless calls only echo validated text. +//! Contracts for transient Render workspace clipboard and retained-result requests. use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -9,3 +9,68 @@ pub struct CheckReport { #[schemars(length(min = 1, max = 65536))] pub text: String, } + +/// Select or discard a retained result without editing a design. +#[derive(Debug, Deserialize, Serialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct ResultIndex { + /// Zero-based index, oldest first. The result must still be retained. + #[schemars(range(min = 0, max = 7))] + pub index: u32, +} + +#[derive(Clone, Copy, Debug, Deserialize, Serialize, JsonSchema, PartialEq, Eq)] +#[serde(rename_all = "snake_case")] +pub enum LiveSide { + Live, +} + +/// A live product view or a retained result's zero-based index (oldest first). +#[derive(Clone, Copy, Debug, Deserialize, Serialize, JsonSchema, PartialEq, Eq)] +#[serde(untagged)] +pub enum CompareSide { + Live(LiveSide), + Result(#[schemars(range(min = 0, max = 7))] u32), +} + +#[derive(Debug, Deserialize, Serialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct ComparePair { + pub left: CompareSide, + pub right: CompareSide, +} + +#[derive(Debug, Deserialize, Serialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct CompareOff { + /// Must be true. Leave comparison without changing retained results. + pub off: bool, +} + +#[derive(Debug, Deserialize, Serialize, JsonSchema)] +#[serde(untagged)] +pub enum CompareParams { + Off(CompareOff), + Pair(ComparePair), +} + +#[derive(Debug, Deserialize, Serialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct CompareDivider { + /// Finite fraction of the canvas width, clamped to 0.05..0.95. + pub position: f64, +} + +#[derive(Debug, Deserialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct BatchParams { + /// Optional render.start request. Its setup is shared, with each saved shot's camera. + /// Without a request, use the first saved shot's setup (name order). + pub request: Option>, +} + +#[derive(Debug, Serialize, JsonSchema)] +pub struct BatchResult { + /// Total accepted shots, including the first active job. At most 32. + pub queued: u32, +} diff --git a/crates/render/Cargo.toml b/crates/render/Cargo.toml index 56a544cd9..68de22ec8 100644 --- a/crates/render/Cargo.toml +++ b/crates/render/Cargo.toml @@ -19,6 +19,7 @@ image = { workspace = true, features = ["jpeg"] } moxcms = { workspace = true } png = { workspace = true } sha2 = { workspace = true } +web-time = { workspace = true } weezl = { workspace = true } [dev-dependencies] diff --git a/crates/render/src/job/host.rs b/crates/render/src/job/host.rs index 8c06a153f..c8ee940df 100644 --- a/crates/render/src/job/host.rs +++ b/crates/render/src/job/host.rs @@ -362,6 +362,7 @@ pub struct JobStatus { } struct Data { + completed_duration: Option, punctual_diagnostics: Option, sampling: Option, progress: Progress, @@ -370,6 +371,7 @@ struct Data { preview: Option>, } struct Record { + started: web_time::Instant, presentation: Option>, textures: Option, options: JobOptions, @@ -399,6 +401,10 @@ impl JobHandle { pub fn id(&self) -> JobId { self.0.id } + /// Submission-to-publication time, captured once by the host, independent of UI polling. + pub fn completed_duration(&self) -> Result> { + self.0.data.lock().map(|data| data.completed_duration).map_err(|_| JobError::new(ErrorCode::Internal, "render duration lock poisoned")) + } pub fn status(&self) -> Result { let data = self.0.data.lock().map_err(|_| JobError::new(ErrorCode::Internal, "render status lock poisoned"))?; Ok(JobStatus { @@ -861,6 +867,7 @@ impl Running { })); data.preview = None; data.progress = Progress { phase: Phase::Completed, done: 1, total: 1 }; + data.completed_duration = Some(self.handle.0.started.elapsed()); self.handle.0.notify(); Ok(false) } @@ -1318,6 +1325,7 @@ impl ImageHost { (request, None) }; let handle = JobHandle(Arc::new(Record { + started: web_time::Instant::now(), presentation: None, textures, options, @@ -1329,6 +1337,7 @@ impl ImageHost { resolved, cancel: CancelToken::default(), data: Mutex::new(Data { + completed_duration: None, punctual_diagnostics: None, sampling: None, progress: Progress { phase: Phase::Queued, done: 0, total: 1 }, @@ -1435,6 +1444,7 @@ impl ImageHost { let metadata = self.0.shared.budget.reserve(metadata_bytes)?; let origin = Arc::new(RetainedPresentation { info: origin, _reservation: metadata }); let handle = JobHandle(Arc::new(Record { + started: web_time::Instant::now(), presentation: Some(origin), textures: None, options, @@ -1446,6 +1456,7 @@ impl ImageHost { resolved, cancel: CancelToken::default(), data: Mutex::new(Data { + completed_duration: None, punctual_diagnostics: None, sampling: None, progress: Progress { phase: Phase::Queued, done: 0, total: 1 }, diff --git a/crates/render/src/job/host_tests.rs b/crates/render/src/job/host_tests.rs index 62afa6298..e18a5cd6b 100644 --- a/crates/render/src/job/host_tests.rs +++ b/crates/render/src/job/host_tests.rs @@ -348,6 +348,25 @@ fn native_job_finishes_without_any_poll_or_ui_pump() { assert_eq!(frame.info.png_bytes, frame.png().len() as u64); assert_eq!(frame.info.png_sha256, format!("{:x}", Sha256::digest(frame.png()))); assert_eq!(status.frame.unwrap().png_sha256, frame.info.png_sha256); + let duration = job.completed_duration().unwrap().unwrap(); + assert_eq!(job.completed_duration().unwrap(), Some(duration), "completed duration is independent of status polling"); +} + +#[test] +fn completed_duration_is_captured_at_publication_and_never_for_cancelled_work() { + let host = CpuHost::cooperative(); + let job = host.submit(id(1, 1), 12, empty(), request()).unwrap(); + assert!(job.completed_duration().unwrap().is_none()); + drain(&host); + let duration = job.completed_duration().unwrap().unwrap(); + assert!(duration.as_secs_f64().is_finite()); + job.status().unwrap(); + host.pump(1).unwrap(); + assert_eq!(job.completed_duration().unwrap(), Some(duration)); + let cancelled = host.submit(id(1, 2), 12, empty(), request()).unwrap(); + cancelled.cancel().unwrap(); + drain(&host); + assert!(cancelled.completed_duration().unwrap().is_none()); } /// Isolate the existing integrator-to-host completion boundary with a real PNG diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rs index 22562c4d2..a17a7efda 100644 --- a/crates/ui-egui/src/documents.rs +++ b/crates/ui-egui/src/documents.rs @@ -15,6 +15,23 @@ use crate::SolveApp; use crate::theme::Tokens; use crate::ui_kit; +/// Continue transient shot queues without adopting their document or view into the active tab. +pub(crate) fn advance_render_batches(app: &mut SolveApp, ctx: &egui::Context) { + let mut error = None; + for slot in app.docs.slots.iter_mut().flatten() { + if let Err(failure) = slot.session.advance_render_batch() { + error = Some(failure.to_string()); + } + let queue = slot.session.render_queue_state(); + if queue.running != 0 || queue.waiting != 0 { + ctx.request_repaint_after(std::time::Duration::from_millis(100)); + } + } + if let Some(error) = error { + app.set_status(error, true); + } +} + /// Most designs open at once. pub const MAX_OPEN: usize = 32; diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index e38f7ea7a..58674104c 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -3009,7 +3009,10 @@ impl SolveApp { (i.pointer.middle_down() || i.pointer.secondary_down()) && i.pointer.press_origin().is_some_and(|p| full.contains(p) && !shell::covered(self, p)) }); - let blocked = !continuing_navigation && ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| shell::covered(self, p)); + // A captured comparison divider also keeps its primary drag across floating cards. + let continuing_comparison = render_workspace::comparison_drag_captured(self) && ui.input(|i| i.pointer.primary_down()); + let blocked = + !continuing_navigation && !continuing_comparison && ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| shell::covered(self, p)); let mut viewport_ui = ui.new_child(egui::UiBuilder::new().max_rect(full).id_salt("floating_viewport")); if blocked { // Disabled only to shield the scene from input under a card or menu; it must diff --git a/crates/ui-egui/src/render_ui/mod.rs b/crates/ui-egui/src/render_ui/mod.rs index 4b6b9d4c1..b3c2dd007 100644 --- a/crates/ui-egui/src/render_ui/mod.rs +++ b/crates/ui-egui/src/render_ui/mod.rs @@ -198,6 +198,15 @@ pub(crate) fn overlays(app: &mut SolveApp, ui: &mut egui::Ui) { crate::render_workspace::assign::selection_bar(app, ui, free); crate::render_workspace::assign::replacement_dialog(app, ui.ctx()); crate::navigation_bar_view::show(app, ui, viewport); + crate::shell::register_panel(app, "render:compare-controls", None, None); + if !crate::render_workspace::result_active(app) && app.session.render_selected_result().is_some() { + let free = if crate::render_workspace::job_busy(app) { Container::below_navigation_row(free) } else { free }; + let card = + Container::navigation_card(ui.ctx(), egui::Id::new("sc_render_compare_controls"), free.center_top(), egui::Align2::CENTER_TOP, |ui| { + crate::render_workspace::comparison_controls(app, ui) + }); + crate::shell::register_panel(app, "render:compare-controls", Some(card.response.rect), None); + } if !focused(app) { shots_pill(app, ui, free); } diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs index 8c2c7aae3..7a786a094 100644 --- a/crates/ui-egui/src/render_workspace.rs +++ b/crates/ui-egui/src/render_workspace.rs @@ -25,6 +25,9 @@ const MAX_GEOMETRY_BYTES: usize = #[path = "render_workspace_ribbon.rs"] mod ribbon; +#[path = "render_workspace_compare.rs"] +mod compare; + #[path = "render_workspace_cpu.rs"] mod cpu; @@ -145,6 +148,7 @@ pub struct State { preview_image: Option, clipboard_image: Option, clipboard_text: Option, + comparison_images: Vec<(solidcraft_engine::render::job::JobId, Result)>, } /// Provisional pixels are never an export source and never replace the retained final image. @@ -361,6 +365,9 @@ pub struct ViewState { clean_setup: Option, job: Option, completed: Option, + retained: Vec, + follow_job: bool, + compare: Option, transparent: bool, method: ImageMethod, raytrace: RaytraceOptions, @@ -426,6 +433,9 @@ impl Default for ViewState { clean_setup: None, job: None, completed: None, + retained: Vec::new(), + follow_job: true, + compare: None, transparent: false, method: ImageMethod::Raster, raytrace: RaytraceOptions::default(), @@ -474,6 +484,7 @@ impl Default for State { preview_image: None, clipboard_image: None, clipboard_text: None, + comparison_images: Vec::new(), } } } @@ -509,6 +520,10 @@ pub(crate) fn result_active(app: &SolveApp) -> bool { active(app) && app.render_workspace.view.result } +pub(crate) fn comparison_drag_captured(app: &SolveApp) -> bool { + active(app) && app.render_workspace.view.compare.as_ref().is_some_and(|view| view.dragging) +} + pub(crate) fn fit_result(app: &mut SolveApp) { app.render_workspace.view.result_scale = ResultScale::Fit; } @@ -526,6 +541,9 @@ pub(crate) fn inspect_state(app: &SolveApp) -> serde_json::Value { json!({ "active": active(app), "stage": view.stage.key(), "setup": view.name, "draft_dirty": view.dirty, "method": method, "job": view.job, "completed": view.completed, + "results": view.retained, + "comparison": view.compare, + "queue": app.session.render_queue_state(), "showing_result": view.result, "export_format": if view.studio.export_exr {"exr"} else {"png"}, }) } @@ -614,6 +632,15 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) { Err(e) => app.set_status(e.to_string(), true), } } + crate::documents::advance_render_batches(app, ctx); + if let Err(error) = app.session.advance_render_batch() { + app.set_status(error.to_string(), true); + } + follow_batch(app); + let queue = app.session.render_queue_state(); + if queue.running != 0 || queue.waiting != 0 { + ctx.request_repaint_after(std::time::Duration::from_millis(100)); + } if app.render_workspace.view.job.is_some() { cache_render_images(app, ctx); } @@ -640,6 +667,7 @@ pub(crate) fn invalidate_images(app: &mut SolveApp) { app.render_workspace.image = None; app.render_workspace.image_info = None; app.render_workspace.preview_image = None; + app.render_workspace.comparison_images.clear(); } pub fn invalidate_scene(app: &mut SolveApp) { @@ -1136,9 +1164,6 @@ fn job_controls(app: &mut SolveApp, ui: &mut egui::Ui, compact: bool) { Ok(status) => { let phase = status["progress"]["phase"].as_str().unwrap_or(crate::i18n::tr("render.property_unknown")); busy = matches!(phase, "queued" | "preparing" | "running" | "encoding" | "cancelling"); - if phase == "completed" { - app.render_workspace.view.completed = Some(job); - } state = Some(status); } Err(error) => { @@ -1278,6 +1303,11 @@ fn cache_completed_image(app: &mut SolveApp, ctx: &egui::Context) { let result = (|| -> Result { let handle = app.session.render_job_handle(job).map_err(|e| e.to_string())?; let frame = handle.frame().map_err(|e| e.to_string())?.ok_or(crate::i18n::tr("render.error_no_completed_image"))?; + if let Some((_, cached)) = app.render_workspace.comparison_images.iter().find(|(id, _)| *id == job) { + let texture = cached.clone()?; + app.render_workspace.image_info = Some(frame.info.clone()); + return Ok(texture); + } let captured = handle.status().map_err(|e| e.to_string())?; let budget = if frame.info.executor.as_str() == "gpu-path" { solidcraft_engine::render::job::GPU_PATH_LIMITS @@ -1285,7 +1315,6 @@ fn cache_completed_image(app: &mut SolveApp, ctx: &egui::Context) { captured_image_limits(&captured.request) }; let image = decode_render_image(frame.png(), frame.info.width, frame.info.height, budget, ctx.input(|i| i.max_texture_side))?; - app.session.execute("render.result.pin", &json!({"job":job})).map_err(|e| e.to_string())?; app.render_workspace.image_info = Some(frame.info.clone()); Ok(ctx.load_texture("sc_render_image", image, egui::TextureOptions::LINEAR)) })(); @@ -1341,16 +1370,17 @@ fn cache_preview_frame(app: &mut SolveApp, ctx: &egui::Context, info: &PreviewIn } fn cache_preview_image(app: &mut SolveApp, ctx: &egui::Context) { - if let Some(job) = app.render_workspace.view.job + if app.render_workspace.view.follow_job + && let Some(job) = app.render_workspace.view.job && let Ok(handle) = app.session.render_job_handle(job) { let preview = handle.preview().ok().flatten(); // Read the final after the checkpoint: completion may occur after the panel's // earlier status query. Promote the real final before dropping its preview, // rather than briefly falling back to an older job and losing result framing. - if handle.frame().ok().flatten().is_some() { - app.render_workspace.view.completed = Some(job); - } else if let Some(preview) = preview { + if handle.frame().ok().flatten().is_none() + && let Some(preview) = preview + { cache_preview_frame(app, ctx, &preview.info, preview.png()); return; } @@ -1373,11 +1403,44 @@ fn cache_render_images(app: &mut SolveApp, ctx: &egui::Context) { app.render_workspace.view.result_job == Some(preview.info.frame.job) && app.render_workspace.view.job == Some(preview.info.frame.job) }); cache_preview_image(app, ctx); + sync_results(app); cache_completed_image(app, ctx); // Checkpoint updates and preview→final/cancel transitions preserve shared pan/zoom. remember_displayed_job(app, preserve_view); } +fn sync_results(app: &mut SolveApp) { + let Ok(mut results) = app.session.render_retained_results() else { return }; + let view = &mut app.render_workspace.view; + for result in &mut results { + if result.shot.is_none() { + result.shot = view.retained.iter().find(|old| old.frame.job == result.frame.job).and_then(|old| old.shot.clone()); + if result.shot.is_none() && view.job == Some(result.frame.job) { + result.shot = view.job_shot.clone(); + } + } + } + view.retained = results; + view.completed = app.session.render_selected_result(); + if view.compare.as_ref().is_some_and(|comparison| { + [comparison.left, comparison.right].into_iter().flatten().any(|job| !view.retained.iter().any(|result| result.frame.job == job)) + }) { + view.compare = None; + app.render_workspace.comparison_images.clear(); + } +} + +fn follow_batch(app: &mut SolveApp) { + let queue = app.session.render_queue_state(); + if let Some(job) = queue.job { + if app.render_workspace.view.job != Some(job) { + app.render_workspace.view.follow_job = app.render_workspace.view.compare.is_none(); + } + app.render_workspace.view.job = Some(job); + app.render_workspace.view.job_shot = queue.shot; + } +} + fn captured_image_limits(request: &solidcraft_engine::render::job::ImageRequest) -> RenderLimits { if request.integrator == Integrator::Raytrace { request.cpu_budget().image_limits(request.raytrace.as_ref().is_some_and(|o| o.progressive.is_some())) @@ -1489,6 +1552,35 @@ fn result_rect(camera: Camera, size: [u32; 2], canvas: egui::Rect) -> egui::Rect } fn result_actions(app: &mut SolveApp, ui: &mut egui::Ui) { + compare::controls(app, ui); + let results = app.render_workspace.view.retained.clone(); + if !results.is_empty() { + let selected = results.iter().position(|result| Some(result.frame.job) == app.render_workspace.view.completed); + let label = selected.and_then(|index| results.get(index)).map(result_label).unwrap_or_else(|| app.tr("render.results_choose").to_string()); + let mut chosen = None; + let picker = crate::ui_kit::compact_dropdown_menu(ui, "render_results", &label, |ui| { + for (index, result) in results.iter().enumerate().rev() { + let response = crate::ui_kit::list_picker(ui, &format!("result:{index}"), &result_label(result), selected == Some(index)); + crate::scenario::publish_target(&format!("render:result:select:{index}"), response.rect); + if response.clicked() { + chosen = Some(index); + ui.close(); + } + } + }); + crate::scenario::publish_target("render:results", picker.rect); + if let Some(index) = chosen { + let _ = app.run("render.result.select", json!({"index":index})); + } + let discard = + ui.add_enabled_ui(selected.is_some(), |ui| crate::ui_kit::StageBar::icon_action(ui, "delete", app.tr("cmd.render.result.discard"))).inner; + crate::scenario::publish_target("render:result-discard", discard.rect); + if discard.clicked() + && let Some(index) = selected + { + let _ = app.run("render.result.discard", json!({"index":index})); + } + } for (view, key) in [("model", "render.state_model"), ("fit", "render.output_fit"), ("actual", "render.result_actual")] { let enabled = view != "actual" || !reduced_display(app); if crate::ui_kit::button(ui, app.tr(key), crate::ui_kit::Button::Enabled(enabled)).clicked() { @@ -1517,6 +1609,15 @@ fn result_actions(app: &mut SolveApp, ui: &mut egui::Ui) { } } +fn result_label(result: &solidcraft_engine::render_jobs::RetainedResult) -> String { + let name = result.shot.as_deref().unwrap_or_else(|| crate::i18n::tr("render.results_unnamed")); + let label = crate::i18n::format( + "render.results_label", + &[("number", &result.frame.job.serial.to_string()), ("shot", name), ("seconds", &format!("{:.0}", result.seconds))], + ); + if result.stale { crate::i18n::format("render.results_stale_label", &[("result", &label)]) } else { label } +} + fn show_result(app: &mut SolveApp, ui: &mut egui::Ui) { cache_render_images(app, ui.ctx()); let t = Tokens::get(); @@ -1966,6 +2067,12 @@ fn preview_background(app: &SolveApp) -> Tokens { } pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { + if app.render_workspace.view.compare.is_some() { + app.render_workspace.view.environment_ring = environment::RingView::default(); + assign::stop(app); + compare::show(app, ui); + return; + } if app.render_workspace.view.result { app.render_workspace.view.environment_ring = environment::RingView::default(); assign::stop(app); @@ -2019,8 +2126,26 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { } else { app.viewport.hover = None; } + crate::gpu::paint_background(ui.painter(), viewport, &preview_background(app)); + paint_product(app, ui, rect, app.cam, None); + shot::overlay(app, ui, viewport); + crate::viewport::axis_view(app, ui, viewport); + crate::navigation_bar_view::show(app, ui, viewport); +} + +fn product_projection(camera: Camera, radius: f64, canvas: egui::Rect, image: Option) -> solidcraft_engine::render::Mat4 { + let image = image.unwrap_or(canvas); + let projection = camera.view_proj(f64::from(image.width() / image.height().max(1.0)), radius); + let sx = f64::from(image.width() / canvas.width().max(1.0)); + let sy = f64::from(image.height() / canvas.height().max(1.0)); + let tx = f64::from(2.0 * (image.center().x - canvas.center().x) / canvas.width().max(1.0)); + let ty = f64::from(2.0 * (canvas.center().y - image.center().y) / canvas.height().max(1.0)); + solidcraft_engine::render::Mat4([[sx, 0.0, 0.0, 0.0], [0.0, sy, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [tx, ty, 0.0, 1.0]]).mul(&projection) +} + +fn paint_product(app: &mut SolveApp, ui: &mut egui::Ui, rect: egui::Rect, camera: Camera, image: Option) { let background = preview_background(app); - crate::gpu::paint_background(ui.painter(), viewport, &background); + crate::gpu::paint_background(ui.painter(), rect, &background); let result = (|| -> Result<(), String> { if app.viewport.gpu.is_none() { return Err(crate::i18n::tr("render.error_gpu_preview").into()); @@ -2077,7 +2202,6 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { if scene.bounds.is_empty() { return Err(crate::i18n::tr("render.error_visible_solid").into()); } - let camera = app.cam; let radius = scene.bounds.diagonal().max(10.0) + scene.bounds.center().dist(camera.target); let eye = camera.eye(); let highlight_key = crate::viewport::highlight_key(app); @@ -2102,7 +2226,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { pv_key: 0, pv_slot: slot, pv_hide: false, - view_proj: camera.view_proj(f64::from(rect.width() / rect.height().max(1.0)), radius).to_f32(), + view_proj: product_projection(camera, radius, rect, image).to_f32(), back: camera.back().to_f32(), size_px: [rect.width() * ppp, rect.height() * ppp], clip: [0.0; 4], @@ -2125,15 +2249,12 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { [f32::from(c.r()) / 255.0, f32::from(c.g()) / 255.0, f32::from(c.b()) / 255.0] }, }); - crate::blur::viewport(ui.painter(), rect, callback, viewport, [background.viewport_top, background.viewport_bottom]); + crate::blur::viewport(ui.painter(), rect, callback, rect, [background.viewport_top, background.viewport_bottom]); Ok(()) })(); if let Err(error) = result { preview_error(app, ui, rect, &error); } - shot::overlay(app, ui, viewport); - crate::viewport::axis_view(app, ui, viewport); - crate::navigation_bar_view::show(app, ui, viewport); } /// Apply validated UI requests after the same registry call used by automation. @@ -2142,6 +2263,45 @@ pub(crate) fn apply_command(app: &mut SolveApp, id: &str, reply: &serde_json::Va "render.preflight.copy" => { app.render_workspace.clipboard_text = Some(reply["text"].as_str().ok_or("invalid check report")?.to_string()); } + "render.compare" => compare::apply(app, reply)?, + "render.compare.divider" => { + let position = reply["position"].as_f64().ok_or("invalid comparison divider position")?; + if let Some(view) = &mut app.render_workspace.view.compare { + view.position = crate::ui_kit::comparison_position(position as f32); + } + } + "render.batch" => follow_batch(app), + "render.start" | "render.result.regrade" => { + let job = serde_json::from_value(reply["job"].clone()).map_err(|e| format!("invalid render job identity: {e}"))?; + let shot = if id == "render.result.regrade" { + app.render_workspace + .view + .retained + .iter() + .find(|result| Some(result.frame.job) == app.render_workspace.view.completed) + .and_then(|result| result.shot.clone()) + } else { + Some(app.render_workspace.view.name.clone()) + }; + if let Some(shot) = &shot { + let _ = app.session.label_render_job(job, shot); + } + app.render_workspace.view.job = Some(job); + app.render_workspace.view.job_shot = shot; + app.render_workspace.view.follow_job = app.render_workspace.view.compare.is_none(); + } + "render.result.select" | "render.result.discard" | "render.result.pin" => { + sync_results(app); + app.render_workspace.preview_image = None; + app.render_workspace.view.follow_job = false; + if matches!(id, "render.result.select" | "render.result.pin") { + app.render_workspace.view.compare = None; + app.render_workspace.comparison_images.clear(); + } + if id == "render.result.select" { + app.render_workspace.view.result = true; + } + } "render.output.size" => { let width = reply["width"].as_u64().and_then(|v| u32::try_from(v).ok()).ok_or("invalid output width")?; let height = reply["height"].as_u64().and_then(|v| u32::try_from(v).ok()).ok_or("invalid output height")?; @@ -2159,6 +2319,10 @@ pub(crate) fn apply_command(app: &mut SolveApp, id: &str, reply: &serde_json::Va return Err(app.tr("render.result_reduced_display").into()); } app.render_workspace.view.result = view != "model"; + if matches!(view, "model") || id == "render.result.close" { + app.render_workspace.view.compare = None; + app.render_workspace.comparison_images.clear(); + } match view { "fit" => fit_result(app), "actual" => app.render_workspace.view.result_scale = ResultScale::Actual, @@ -2224,6 +2388,9 @@ pub(crate) fn interactive_command_info(app: &SolveApp, command: &solidcraft_engi } info } +pub(crate) fn comparison_controls(app: &mut SolveApp, ui: &mut egui::Ui) { + compare::controls(app, ui); +} pub(crate) fn start_interactive(app: &mut SolveApp, id: &str) -> bool { let handled = assign::start(app, id) || ribbon::start(app, id); // Opening Appearance Advanced must still reach its atmosphere controls after leaving Wear. diff --git a/crates/ui-egui/src/render_workspace_compare.rs b/crates/ui-egui/src/render_workspace_compare.rs new file mode 100644 index 000000000..ed28ed33b --- /dev/null +++ b/crates/ui-egui/src/render_workspace_compare.rs @@ -0,0 +1,291 @@ +//! Result comparison composition. The kit owns controls, chips and the divider. +use super::*; +use crate::ui_kit; +use solidcraft_engine::render::job::JobId; + +#[derive(Clone, Debug, serde::Serialize)] +pub(super) struct View { + pub left: Option, + pub right: Option, + pub position: f32, + pub reference: JobId, + #[serde(skip)] + pub dragging: bool, +} + +fn side_value(app: &SolveApp, side: Option) -> Option { + match side { + None => Some(json!("live")), + Some(job) => app.render_workspace.view.retained.iter().position(|result| result.frame.job == job).map(|index| json!(index)), + } +} + +pub(super) fn apply(app: &mut SolveApp, reply: &serde_json::Value) -> Result<(), String> { + if reply.get("off").and_then(serde_json::Value::as_bool) == Some(true) { + app.render_workspace.view.compare = None; + app.render_workspace.comparison_images.clear(); + return Ok(()); + } + sync_results(app); + let [left, right] = app.session.render_comparison().ok_or("comparison result is no longer retained")?; + let position = app.render_workspace.view.compare.as_ref().map_or(0.5, |view| view.position); + let reference = app + .render_workspace + .view + .compare + .as_ref() + .map(|view| view.reference) + .filter(|job| [left, right].contains(&Some(*job))) + .or(right) + .or(left) + .ok_or("comparison needs a retained result")?; + if app.render_workspace.view.compare.as_ref().is_none_or(|view| view.reference != reference) { + app.render_workspace.view.result_scale = ResultScale::Fit; + } + app.render_workspace.view.compare = Some(View { left, right, position, reference, dragging: false }); + app.render_workspace.view.result = true; + app.render_workspace.view.follow_job = false; + app.render_workspace.preview_image = None; + app.cancel_view_animation(); + app.viewport.nav = None; + app.viewport.key_hold = None; + app.viewport.orbit_free = None; + Ok(()) +} + +pub(super) fn start_default(app: &mut SolveApp) -> Result<(), String> { + sync_results(app); + if app.render_workspace.view.compare.is_some() { + app.run("render.compare", json!({"off":true}))?; + } else { + let index = app + .render_workspace + .view + .retained + .iter() + .position(|result| Some(result.frame.job) == app.render_workspace.view.completed) + .ok_or_else(|| app.tr("render.ribbon_no_result").to_string())?; + app.run("render.compare", json!({"left":"live","right":index}))?; + } + Ok(()) +} + +pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { + let results = &app.render_workspace.view.retained; + if results.is_empty() { + return; + } + let mut labels = vec![app.tr("render.compare_live").to_owned()]; + labels.extend(results.iter().map(|result| crate::i18n::format("render.compare_render", &[("number", &result.frame.job.serial.to_string())]))); + let mut targets = vec!["render:compare:live".to_string()]; + targets.extend(results.iter().enumerate().map(|(index, _)| format!("render:compare:result:{index}"))); + let choices: Vec<_> = std::iter::once(None).chain(results.iter().map(|result| Some(result.frame.job))).collect(); + let current = if app.render_workspace.view.result { app.render_workspace.view.completed } else { None }; + let comparison = app.render_workspace.view.compare.clone(); + let states: Vec<_> = + choices.iter().map(|side| comparison.as_ref().map_or(*side == current, |view| *side == view.left || *side == view.right)).collect(); + let mut selected = usize::MAX; + if ui_kit::segmented( + ui, + &mut selected, + &labels.iter().map(String::as_str).collect::>(), + ui_kit::Segments { + targets: &targets.iter().map(String::as_str).collect::>(), + states: &states, + intrinsic: true, + dense: true, + compact: true, + workspace_accent: true, + ..Default::default() + }, + ) && let Some(chosen) = choices.get(selected).copied() + { + if let Some(view) = comparison { + if chosen == view.left || chosen == view.right { + let remaining = if chosen == view.left { view.right } else { view.left }; + let _ = app.run("render.compare", json!({"off":true})); + choose_single(app, remaining); + } else if let (Some(left), Some(right)) = (side_value(app, view.left), side_value(app, chosen)) { + let _ = app.run("render.compare", json!({"left":left,"right":right})); + } + } else if chosen != current { + let (left, right) = if chosen.is_none() { (chosen, current) } else { (current, chosen) }; + if let (Some(left), Some(right)) = (side_value(app, left), side_value(app, right)) { + let _ = app.run("render.compare", json!({"left":left,"right":right})); + } + } + } + if let Some(view) = app.render_workspace.view.compare.clone() { + let swap = ui_kit::compact_icon_label_button(ui, app.tr("render.compare_swap"), "compare", true); + crate::scenario::publish_target("render:compare:swap", swap.rect); + if swap.clicked() + && let (Some(left), Some(right)) = (side_value(app, view.right), side_value(app, view.left)) + { + let _ = app.run("render.compare", json!({"left":left,"right":right})); + } + } +} + +fn choose_single(app: &mut SolveApp, side: Option) { + match side { + None => { + let _ = app.run("render.result.view", json!({"view":"model"})); + } + Some(job) => { + if let Some(index) = app.render_workspace.view.retained.iter().position(|result| result.frame.job == job) { + let _ = app.run("render.result.select", json!({"index":index})); + } + } + } +} + +fn texture(app: &mut SolveApp, ctx: &egui::Context, job: JobId) -> Result { + if let Some((_, image)) = app.render_workspace.comparison_images.iter().find(|(id, _)| *id == job) { + return image.clone(); + } + if let Some((id, image)) = &app.render_workspace.image + && *id == job + { + let image = image.clone(); + app.render_workspace.comparison_images.push((job, image.clone())); + return image; + } + let image: Result = (|| { + let handle = app.session.render_job_handle(job).map_err(|error| error.to_string())?; + let frame = handle.frame().map_err(|error| error.to_string())?.ok_or("comparison image is not completed")?; + let captured = handle.status().map_err(|error| error.to_string())?; + let limits = if frame.info.executor.as_str() == "gpu-path" { + solidcraft_engine::render::job::GPU_PATH_LIMITS + } else { + captured_image_limits(&captured.request) + }; + let image = decode_render_image(frame.png(), frame.info.width, frame.info.height, limits, ctx.input(|input| input.max_texture_side))?; + Ok(ctx.load_texture("sc_render_compare", image, egui::TextureOptions::LINEAR)) + })(); + app.render_workspace.comparison_images.push((job, image.clone())); + image +} + +fn label(app: &SolveApp, side: Option) -> String { + side.and_then(|job| app.render_workspace.view.retained.iter().find(|result| result.frame.job == job)).map_or_else( + || app.tr("render.compare_live_preview").to_owned(), + |result| { + crate::i18n::format( + "render.compare_side", + &[ + ("number", &result.frame.job.serial.to_string()), + ("shot", result.shot.as_deref().unwrap_or_else(|| crate::i18n::tr("render.results_unnamed"))), + ], + ) + }, + ) +} + +pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui) { + cache_render_images(app, ui.ctx()); + if app.render_workspace.view.compare.is_none() { + show_result(app, ui); + return; + } + ui.painter().rect_filled(ui.max_rect(), 0.0, Tokens::get().viewport_bottom); + let mut free = crate::render_ui::canvas(app, ui.max_rect()); + if ribbon::busy(app) { + free = ui_kit::Container::below_navigation_row(free); + } + let mut content = ui.new_child(egui::UiBuilder::new().max_rect(free).id_salt("render_compare_content")); + let ui = &mut content; + ui_kit::Container::navigation_contents(ui, |ui| { + ui.horizontal_wrapped(|ui| result_actions(app, ui)); + }); + let Some(view) = app.render_workspace.view.compare.clone() else { return }; + app.render_workspace.comparison_images.retain(|(job, _)| [view.left, view.right].contains(&Some(*job))); + let Some(reference) = app.render_workspace.view.retained.iter().find(|result| result.frame.job == view.reference).cloned() else { return }; + let stale = app.render_workspace.view.retained.iter().any(|result| [view.left, view.right].contains(&Some(result.frame.job)) && result.stale); + // Keep freshness and the capture summary below the image, as in the result board. + ui_kit::Panel::pinned_footer(ui, "render_compare_summary", 2, |ui| { + ui_kit::completion_text(ui, app.tr(if stale { "render.image_stale" } else { "render.result_current" }), !stale); + let summary = crate::i18n::format( + "render.compare_summary", + &[ + ("shot", reference.shot.as_deref().unwrap_or_else(|| crate::i18n::tr("render.results_unnamed"))), + ("width", &reference.frame.width.to_string()), + ("height", &reference.frame.height.to_string()), + ("seconds", &format!("{:.0}", reference.seconds)), + ("renderer", reference.frame.executor.as_str()), + ("revision", &reference.frame.scene_generation.to_string()), + ], + ); + ui_kit::text(ui, &summary, ui_kit::Text::Inline); + }); + let canvas = ui.available_rect_before_wrap(); + if !canvas.is_positive() { + return; + } + let response = ui.allocate_rect(canvas, Sense::click_and_drag()); + app.viewport.rect = Some(canvas); + crate::viewport::refresh_layout(app, ui.ctx()); + let size = [reference.frame.width, reference.frame.height]; + if app.render_workspace.view.result_scale != ResultScale::Free { + app.render_workspace.view.result_camera = result_camera(size, canvas, ui.ctx().pixels_per_point(), app.render_workspace.view.result_scale); + } + // Reserve the divider before navigation; captured drags cannot reach any camera path. + let mut position = view.position; + let divider = ui_kit::comparison_divider(ui, canvas, &mut position, app.tr("render.compare_divider")); + let captured = divider.dragged() || divider.is_pointer_button_down_on() || divider.drag_stopped(); + if let Some(view) = &mut app.render_workspace.view.compare { + view.dragging = divider.is_pointer_button_down_on() || divider.dragged(); + } + if divider.changed() + && let Err(error) = app.run("render.compare.divider", json!({"position":position})) + { + app.set_status(error, true); + } + if !captured { + with_result_camera(app, |app| { + crate::navigation::handle(app, ui, canvas, &response, crate::navigation::NavCaps { orbit: false, pick: false }); + }); + } + let image = result_rect(app.render_workspace.view.result_camera, size, canvas); + let split = canvas.left() + canvas.width() * position; + let halves = [ + egui::Rect::from_min_max(canvas.min, egui::pos2(split, canvas.bottom())), + egui::Rect::from_min_max(egui::pos2(split, canvas.top()), canvas.max), + ]; + let camera = app.session.render_job_handle(reference.frame.job).ok().and_then(|handle| handle.status().ok()).map(|status| status.request.camera); + // Paint sources behind the already registered handle, then raise its shared chrome. + for ((side, half), right) in [view.left, view.right].into_iter().zip(halves).zip([false, true]) { + let mut child = ui.new_child(egui::UiBuilder::new().max_rect(canvas).id_salt(("compare_side", right))); + child.set_clip_rect(half.intersect(image).intersect(ui.clip_rect())); + if child.clip_rect().is_positive() { + match side { + None => { + if let Some(camera) = camera { + paint_product(app, &mut child, canvas, camera, Some(image)); + } + } + Some(job) => match texture(app, ui.ctx(), job) { + Ok(texture) => { + let source = app.render_workspace.view.retained.iter().find(|result| result.frame.job == job); + let aspect = source.map_or(1.0, |result| result.frame.width as f32 / result.frame.height.max(1) as f32); + let height = image.height().min(image.width() / aspect); + let destination = egui::Rect::from_center_size(image.center(), egui::vec2(height * aspect, height)); + child.painter().image( + texture.id(), + destination, + egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), + Tokens::get().file_image_tint, + ); + } + Err(error) => { + ui_kit::text(&mut child, &error, ui_kit::Text::Inline); + } + }, + } + } + ui_kit::comparison_badge(ui, half, &label(app, side), right); + } + // The line and handle must stay above both source callbacks and label chips. + ui_kit::comparison_divider_chrome(ui, canvas, position); + crate::scenario::publish_rect("render:compare:canvas", canvas); + crate::scenario::publish_rect("render:compare:image", image); +} diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs index ffc21d715..307729afd 100644 --- a/crates/ui-egui/src/render_workspace_inspector.rs +++ b/crates/ui-egui/src/render_workspace_inspector.rs @@ -279,6 +279,29 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { } }, |ui| { + if output { + ui_kit::Panel::pinned_footer(ui, "render_output_footer", 1, |ui| { + ui.horizontal_wrapped(|ui| { + for (id, label, target) in [ + ("render.start", app.tr("cmd.render_start").to_owned(), "render:output:render"), + ( + "render.batch", + crate::i18n::format("render.batch_all_shots", &[("count", &app.session.doc.render.setups.len().to_string())]), + "render:output:all-shots", + ), + ] { + let ready = super::ribbon::action_ready(app, id); + let response = ui_kit::icon_label_action(ui, &label, Some("play"), ready.is_ok(), id == "render.start"); + let response = if let Err(reason) = ready { response.on_disabled_hover_text(reason) } else { response }; + crate::scenario::publish_target(target, response.rect); + if response.clicked() { + app.start(id); + } + } + }); + crate::scenario::publish_rect("render:output-footer", ui.min_rect()); + }); + } if !appearance_editor && !output && !standalone { header(app, ui); ui_kit::Panel::pinned_footer(ui, "render_job_footer", 4, |ui| { diff --git a/crates/ui-egui/src/render_workspace_ribbon.rs b/crates/ui-egui/src/render_workspace_ribbon.rs index ce8ec02f8..ff8cb4f20 100644 --- a/crates/ui-egui/src/render_workspace_ribbon.rs +++ b/crates/ui-egui/src/render_workspace_ribbon.rs @@ -7,7 +7,10 @@ use solidcraft_engine::render::job::Phase; use solidcraft_engine::{CommandInfo, CommandSpec}; fn is_job_action(id: &str) -> bool { - matches!(id, "render.preflight" | "render.start" | "render.cancel" | "render.export" | "render.result.regrade" | "render.result.copy") + matches!( + id, + "render.preflight" | "render.start" | "render.batch" | "render.cancel" | "render.export" | "render.result.regrade" | "render.result.copy" + ) } fn handled(id: &str) -> bool { is_job_action(id) @@ -47,10 +50,15 @@ fn handled(id: &str) -> bool { | "render.backends" | "render.result.view" | "render.result.close" + | "render.compare" ) } pub(super) fn busy(app: &SolveApp) -> bool { + let queue = app.session.render_queue_state(); + if queue.running != 0 || queue.waiting != 0 { + return true; + } app.render_workspace .view .job @@ -66,6 +74,19 @@ pub(super) fn action_ready(app: &SolveApp, id: &str) -> Result<(), String> { return Err(app.tr("render.ribbon_finish_dialog").into()); } match id { + "render.batch" => { + if app.session.doc.render.setups.is_empty() { + return Err(app.tr("render.batch_empty").into()); + } + if app.session.doc.render.setups.len() > 32 { + return Err(app.tr("render.batch_limit").into()); + } + if busy(app) { + return Err(app.tr("render.ribbon_job_active").into()); + } + super::image_params(app).map(|_| ()) + } + "render.compare" if app.render_workspace.view.retained.is_empty() => Err(app.tr("render.ribbon_no_result").into()), "render.preflight" | "render.start" => { if id == "render.start" && busy(app) { return Err(app.tr("render.ribbon_job_active").into()); @@ -128,6 +149,10 @@ pub(super) fn command_info(app: &SolveApp, command: &CommandSpec) -> CommandInfo pub(super) fn perform_job(app: &mut SolveApp, id: &str) -> Result<(), String> { action_ready(app, id)?; match id { + "render.batch" => { + let request = super::image_params(app)?; + app.run(id, json!({"request":request}))?; + } "render.preflight" => { let request = super::image_params(app)?; let reply = match app.run(id, request.clone()) { @@ -161,7 +186,12 @@ pub(super) fn perform_job(app: &mut SolveApp, id: &str) -> Result<(), String> { app.render_workspace.view.job = Some(job); } "render.cancel" => { - let job = app.render_workspace.view.job.ok_or_else(|| app.tr("render.ribbon_no_active_job").to_string())?; + let job = app + .session + .render_queue_state() + .job + .or(app.render_workspace.view.job) + .ok_or_else(|| app.tr("render.ribbon_no_active_job").to_string())?; app.run(id, json!({"job":job}))?; } "render.export" => { @@ -238,6 +268,7 @@ fn navigate(app: &mut SolveApp, id: &str) -> Result<(), String> { focus(app, Page::Appearance, None); inspector::reveal(app, "render:appearance:advanced"); } + "render.compare" => super::compare::start_default(app)?, "render.result.close" => { app.run(id, json!({}))?; } diff --git a/crates/ui-egui/src/render_workspace_shots.rs b/crates/ui-egui/src/render_workspace_shots.rs index ef4879d8a..48fe8b1ce 100644 --- a/crates/ui-egui/src/render_workspace_shots.rs +++ b/crates/ui-egui/src/render_workspace_shots.rs @@ -45,6 +45,8 @@ pub(crate) fn contents(app: &mut SolveApp, ui: &mut egui::Ui) { ) }) .unwrap_or_else(|| app.tr("render.shots_no_result").to_string()); + let queue = app.session.render_queue_state(); + let queue_label = crate::i18n::format("render.batch_status", &[("running", &queue.running.to_string()), ("waiting", &queue.waiting.to_string())]); let (mut hide, mut start, mut save, mut chosen, mut size) = (false, false, false, None, None); let mut visible = Vec::new(); ui_kit::Panel::strip_contents( @@ -53,6 +55,8 @@ pub(crate) fn contents(app: &mut SolveApp, ui: &mut egui::Ui) { let response = ui_kit::strip_toggle(ui, true, crate::i18n::tr_label("Hide Shots strip")); crate::scenario::publish_target("render:shots:hide", response.rect); hide = response.clicked(); + let response = ui_kit::completion_text(ui, &queue_label, false); + crate::scenario::publish_rect("render:shots:queue", response.rect); let response = ui_kit::icon_label_action(ui, app.tr("cmd.render_start"), Some("play"), ready.is_ok(), true); let response = if let Err(reason) = &ready { response.on_disabled_hover_text(reason) } else { response }; crate::scenario::publish_target("render:shots:render", response.rect); diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs index ea6a4f01e..42703667a 100644 --- a/crates/ui-egui/src/render_workspace_tests.rs +++ b/crates/ui-egui/src/render_workspace_tests.rs @@ -2353,6 +2353,7 @@ fn delayed_image_export_never_substitutes_a_newer_retained_image() { use crate::picker_test_support::{Slot, save}; let (mut h, job) = async_export_fixture(); let path = h.dir.join("old-image.png"); + let bytes = h.app.session.render_job_handle(job).unwrap().frame().unwrap().unwrap().png().to_vec(); let ctx = crate::fonts::test_context(); let slot: Slot = Default::default(); save(&mut h.app, &slot); @@ -2362,9 +2363,18 @@ fn delayed_image_export_never_substitutes_a_newer_retained_image() { h.app.render_workspace.view.completed = Some(newer); *slot.borrow_mut() = Some(Some(path.to_string_lossy().into_owned())); crate::file_picker::tick(&mut h.app, &ctx); - assert!(!path.exists(), "the evicted requested image must fail instead of exporting the newer image"); - assert!(matches!(&h.app.status, Some((_, _, true)))); + assert_eq!(std::fs::read(&path).unwrap(), bytes, "an older retained image remains the exact pending export source"); assert_eq!(h.app.render_workspace.view.completed, Some(newer)); + let evicted = h.dir.join("evicted.png"); + export_image(&mut h.app, job, false); + crate::file_picker::tick(&mut h.app, &ctx); + for _ in 0..7 { + completed_preview(&mut h, [50, 60, 70]); + } + *slot.borrow_mut() = Some(Some(evicted.to_string_lossy().into_owned())); + crate::file_picker::tick(&mut h.app, &ctx); + assert!(!evicted.exists(), "an evicted requested image fails without substituting a newer image"); + assert!(matches!(&h.app.status, Some((_, _, true)))); let newer_path = h.dir.join("new-image.png"); h.app.run("render.export", json!({"job":newer,"path":newer_path})).unwrap(); assert!(newer_path.is_file()); @@ -5838,6 +5848,117 @@ fn output_viewer_r_starts_active_setup_and_escape_returns_to_model_without_cance assert_ne!(crate::keymap::command_for(&h.app, "R"), Some("render.start")); } +#[test] +fn retained_results_picker_and_discard_dispatch_the_selected_index() { + let mut h = output_viewer_fixture(); + let first = completed_preview(&mut h, [20, 40, 60]); + let second = completed_preview(&mut h, [80, 100, 120]); + let document = h.app.session.doc.clone(); + let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision); + h.app.run("render.result.select", json!({"index":1})).unwrap(); + h.frames(3); + h.step(&json!({"click":{"handle":"render:results"}})).unwrap(); + h.frames(2); + h.step(&json!({"click":{"handle":"render:result:select:0"}})).unwrap(); + h.frames(2); + assert_eq!(h.app.render_workspace.view.completed, Some(first)); + h.step(&json!({"click":{"handle":"render:result-discard"}})).unwrap(); + h.frames(2); + assert_eq!(h.app.render_workspace.view.completed, Some(second)); + assert_eq!(h.app.render_workspace.view.retained.len(), 1); + assert!(Arc::ptr_eq(&document, &h.app.session.doc)); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision)); +} + +#[test] +fn retained_results_select_discard_copy_export_and_repaint_keep_exact_selected_pixels() { + let mut h = output_viewer_fixture(); + let ctx = crate::fonts::test_context(); + let document = h.app.session.doc.clone(); + let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision); + let mut jobs = Vec::new(); + for shade in 0..10 { + let job = completed_preview(&mut h, [shade * 20, 40, 60]); + h.app.render_workspace.view.job = Some(job); + h.app.render_workspace.view.job_shot = Some(format!("Shot {shade}")); + cache_render_images(&mut h.app, &ctx); + jobs.push(job); + } + assert_eq!(h.app.render_workspace.view.retained.len(), 8); + assert_eq!(h.app.render_workspace.view.retained.iter().map(|result| result.frame.job).collect::>(), jobs[2..]); + assert_eq!(h.app.render_workspace.view.retained[0].shot.as_deref(), Some("Shot 2")); + h.app.run("render.result.select", json!({"index":0})).unwrap(); + assert!(h.app.render_workspace.view.result); + for _ in 0..3 { + cache_render_images(&mut h.app, &ctx); + assert_eq!(h.app.render_workspace.view.completed, Some(jobs[2])); + assert_eq!(h.app.render_workspace.image_info.as_ref().unwrap().job, jobs[2]); + } + h.app.run("render.result.copy", json!({})).unwrap(); + assert!(h.app.render_workspace.clipboard_image.as_ref().unwrap().pixels.iter().all(|pixel| *pixel == Color32::from_rgb(40, 40, 60))); + let frame = h.app.session.render_job_handle(jobs[2]).unwrap().frame().unwrap().unwrap(); + let path = h.dir.join("selected-result.png"); + h.app.run("render.export", json!({"path":path})).unwrap(); + assert_eq!(std::fs::read(path).unwrap(), frame.png()); + h.app.run("render.result.discard", json!({"index":0})).unwrap(); + cache_render_images(&mut h.app, &ctx); + assert_eq!(h.app.render_workspace.view.completed, Some(jobs[9])); + assert!(h.app.session.render_job_handle(jobs[2]).is_err()); + assert!(h.app.run("render.result.select", json!({"index":7})).is_err()); + assert!(Arc::ptr_eq(&document, &h.app.session.doc)); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision)); + ctx.run_ui(Default::default(), |_| {}).textures_delta.clear(); +} + +#[test] +fn retained_results_and_selection_stay_with_the_document_tab_and_clear_on_reset() { + let mut h = output_viewer_fixture(); + let first = completed_preview(&mut h, [20, 40, 60]); + let second = completed_preview(&mut h, [80, 100, 120]); + h.app.render_workspace.view.job = Some(second); + cache_render_images(&mut h.app, &h.ctx); + h.app.run("render.result.select", json!({"index":0})).unwrap(); + h.app.run("solid.box", json!({"length":1,"width":1,"height":1})).unwrap(); + cache_render_images(&mut h.app, &h.ctx); + assert!(h.app.render_workspace.view.retained.iter().all(|result| result.stale)); + crate::documents::open_tab(&mut h.app, Session::default()).unwrap(); + assert!(h.app.render_workspace.view.retained.is_empty()); + assert!(h.app.run("render.result.select", json!({"index":0})).is_err()); + crate::documents::switch(&mut h.app, 0); + cache_render_images(&mut h.app, &h.ctx); + assert_eq!(h.app.render_workspace.view.completed, Some(first)); + assert_eq!(h.app.render_workspace.view.retained.len(), 2); + h.app.run("render.result.discard", json!({"index":0})).unwrap(); + h.app.run("render.result.discard", json!({"index":0})).unwrap(); + cache_render_images(&mut h.app, &h.ctx); + assert!(h.app.render_workspace.view.completed.is_none()); + assert!(displayed_image(&h.app).is_none(), "polling the discarded active job cannot resurrect its image"); + reset_document(&mut h.app); + assert!(h.app.render_workspace.view.retained.is_empty()); +} + +#[test] +fn retained_results_capture_the_draft_shot_name_before_the_user_switches_shots() { + let mut h = output_viewer_fixture(); + h.app.render_workspace.view.name = "Hero".into(); + let reply = h.app.run("render.start", json!({"settings":{"width":8,"height":8}})).unwrap(); + let job = serde_json::from_value(reply["job"].clone()).unwrap(); + let host = h.app.session.render_job_host().unwrap().clone(); + for _ in 0..100 { + if !host.pump(16384).unwrap() { + break; + } + } + let duration = h.app.session.render_job_handle(job).unwrap().completed_duration().unwrap().unwrap().as_secs_f64(); + h.app.render_workspace.view.name = "Front".into(); + h.app.run("render.start", json!({"settings":{"width":8,"height":8}})).unwrap(); + sync_results(&mut h.app); + assert_eq!(h.app.render_workspace.view.retained[0].shot.as_deref(), Some("Hero")); + assert_eq!(h.app.render_workspace.view.retained[0].seconds, duration); + assert_eq!(h.app.render_workspace.view.completed, Some(job)); + assert!(h.app.dialog.is_none()); +} + /// Actual app controls and retained pixels, rasterized from egui without a window. #[test] fn output_viewer_evidence() { @@ -5938,8 +6059,9 @@ fn output_viewer_evidence() { } #[test] -fn output_viewer_radial_defaults_enable_lights_and_keep_planned_compare_disabled() { - let h = output_viewer_fixture(); +fn output_viewer_radial_defaults_enable_lights_and_compare_requires_a_result() { + let mut h = render_lights_fixture(); + h.app.session.set_render_job_host(Some(solidcraft_engine::render::job::CpuHost::cooperative())).unwrap(); let expected = [ "render.start", "appearance.assign", @@ -5951,8 +6073,12 @@ fn output_viewer_radial_defaults_enable_lights_and_keep_planned_compare_disabled "undo", ]; assert_eq!(crate::mouse_gesture::Studio::Render.defaults(), expected); + assert!(solidcraft_engine::find_command("render.lights.add").unwrap().planned.is_none()); assert!(crate::mouse_gesture::item(&h.app, "render.lights.add").unwrap().enabled); assert!(!crate::mouse_gesture::item(&h.app, "render.compare").unwrap().enabled); + completed_preview(&mut h, [20, 40, 60]); + assert!(crate::mouse_gesture::item(&h.app, "render.compare").unwrap().enabled); + assert!(crate::mouse_gesture::item(&h.app, "render.lights.add").unwrap().enabled); } #[test] @@ -5980,7 +6106,7 @@ fn output_viewer_presets_are_commands_with_limits_and_custom_keeps_the_size() { } #[test] -fn output_viewer_has_sections_without_pages_or_footer_and_selected_row_routes_to_output() { +fn output_viewer_has_sections_and_shared_footer_without_pages_and_selected_row_routes_to_output() { for dark in [false, true] { let mut h = output_viewer_fixture(); h.app.preferences.theme = if dark { "dark" } else { "light" }.into(); @@ -5991,6 +6117,10 @@ fn output_viewer_has_sections_without_pages_or_footer_and_selected_row_routes_to assert!(crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr(key))).is_some(), "{key}"); } assert!(crate::scenario::rect_of("render:job-footer").is_none()); + let footer = crate::scenario::rect_of("render:output-footer").unwrap(); + for target in ["render:output:render", "render:output:all-shots"] { + assert!(footer.contains_rect(crate::scenario::rect_of(target).unwrap())); + } for page in ["output", "effects", "all"] { assert!(crate::scenario::rect_of(&format!("render:page:{page}")).is_none()); } @@ -6464,6 +6594,145 @@ fn render_lights_each_kind_contains_design_sections_and_real_parameter_fields_in } } +fn render_results_compare_fixture() -> (Harness, solidcraft_engine::render::job::JobId, solidcraft_engine::render::job::JobId) { + let mut h = output_viewer_fixture(); + h.call("ui.resize", json!({"width":1440,"height":900})); + let first = completed_preview(&mut h, [20, 40, 60]); + h.app.render_workspace.view.job = Some(first); + h.app.render_workspace.view.job_shot = Some("Front".into()); + cache_render_images(&mut h.app, &h.ctx); + let second = completed_preview(&mut h, [80, 100, 120]); + h.app.render_workspace.view.job = Some(second); + h.app.render_workspace.view.job_shot = Some("Hero".into()); + cache_render_images(&mut h.app, &h.ctx); + (h, first, second) +} + +#[test] +fn render_results_compare_live_two_renders_swap_labels_and_common_framing_use_the_shared_controls() { + let (mut h, first, second) = render_results_compare_fixture(); + let document = h.app.session.doc.clone(); + let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision); + let camera = h.app.cam; + h.app.run("render.compare", json!({"left":"live","right":1})).unwrap(); + h.frames(3); + let view = h.app.render_workspace.view.compare.as_ref().unwrap(); + assert_eq!((view.left, view.right, view.reference), (None, Some(second), second)); + let image = crate::scenario::rect_of("render:compare:image").unwrap(); + let canvas = crate::scenario::rect_of("render:compare:canvas").unwrap(); + for target in ["render:compare:left-label", "render:compare:right-label", "render:compare:divider"] { + assert!(canvas.contains_rect(crate::scenario::rect_of(target).unwrap()), "{target}"); + } + assert!( + h.shapes.iter().any(|shape| matches!(&shape.shape, egui::Shape::Text(text) if text.galley.text() == h.app.tr("render.compare_live_preview"))) + ); + h.step(&json!({"click":{"handle":"render:compare:swap"}})).unwrap(); + h.frames(2); + let view = h.app.render_workspace.view.compare.as_ref().unwrap(); + assert_eq!((view.left, view.right, view.reference), (Some(second), None, second)); + assert_eq!(crate::scenario::rect_of("render:compare:image"), Some(image)); + h.app.run("render.compare", json!({"left":0,"right":1})).unwrap(); + h.frames(2); + let first_texture = h.app.render_workspace.comparison_images.iter().find(|(job, _)| *job == first).unwrap().1.as_ref().unwrap().id(); + let second_texture = h.app.render_workspace.image.as_ref().unwrap().1.as_ref().unwrap().id(); + let vertices = |texture| { + h.shapes + .iter() + .find_map(|shape| match &shape.shape { + egui::Shape::Mesh(mesh) if mesh.texture_id == texture => Some(mesh.vertices.iter().map(|vertex| vertex.pos).collect::>()), + _ => None, + }) + .unwrap() + }; + assert_eq!(vertices(first_texture), vertices(second_texture), "both rendered sources use the same image framing"); + h.step(&json!({"click":{"handle":"render:compare:swap"}})).unwrap(); + h.frames(2); + assert_eq!(h.app.render_workspace.image.as_ref().unwrap().1.as_ref().unwrap().id(), first_texture); + assert!(h.app.render_workspace.comparison_images.iter().any(|(job, image)| *job == second && image.as_ref().unwrap().id() == second_texture)); + assert!(h.app.render_workspace.comparison_images.len() <= 2); + assert_eq!(h.app.cam, camera); + assert!(Arc::ptr_eq(&document, &h.app.session.doc)); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision)); + h.app.run("render.compare", json!({"off":true})).unwrap(); + assert!(h.app.render_workspace.view.compare.is_none()); + assert!(h.app.render_workspace.comparison_images.is_empty()); +} + +#[test] +fn render_results_compare_divider_drag_clamps_and_blocks_all_camera_input() { + use egui::{Event, Modifiers, MouseWheelUnit, PointerButton, vec2}; + let (mut h, _, _) = render_results_compare_fixture(); + h.app.run("render.compare", json!({"left":0,"right":1})).unwrap(); + let pending = h.app.run("render.start", json!({"settings":{"width":16,"height":16}})).unwrap()["job"].clone(); + assert!(!h.app.render_workspace.view.follow_job, "new job previews must not replace comparison framing"); + h.frames(3); + h.app.preferences.nav = "maya".into(); + h.app.render_workspace.view.result_scale = ResultScale::Free; + let product = h.app.cam; + let result = h.app.render_workspace.view.result_camera; + let document = h.app.session.doc.clone(); + let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision); + let canvas = crate::scenario::rect_of("render:compare:canvas").unwrap(); + let start = crate::scenario::rect_of("render:compare:handle").unwrap().center(); + h.frame_with(vec![ + Event::ModifiersChanged(Modifiers::ALT), + Event::PointerMoved(start), + Event::PointerButton { pos: start, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::ALT }, + ]); + let end = egui::pos2(canvas.right() + 100.0, start.y); + h.frame_with(vec![ + Event::PointerMoved(end), + Event::MouseWheel { unit: MouseWheelUnit::Point, delta: vec2(0.0, -300.0), modifiers: Modifiers::ALT, phase: egui::TouchPhase::Move }, + ]); + assert!( + (h.app.render_workspace.view.compare.as_ref().unwrap().position - 0.95).abs() < 1e-6, + "divider position {:?}, canvas {canvas:?}, press {start:?}, pointer {end:?}, captured {:?}", + h.app.render_workspace.view.compare.as_ref().unwrap().position, + h.ctx.dragged_id() + ); + assert_eq!(h.app.render_workspace.view.result_camera, result); + assert_eq!(h.app.cam, product); + let end = egui::pos2(canvas.left() - 100.0, start.y); + h.frame_with(vec![Event::PointerMoved(end)]); + assert!((h.app.render_workspace.view.compare.as_ref().unwrap().position - 0.05).abs() < 1e-6); + assert_eq!(h.app.render_workspace.view.result_camera, result); + assert_eq!(h.app.cam, product); + h.frame_with(vec![ + Event::PointerButton { pos: end, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::ALT }, + Event::ModifiersChanged(Modifiers::NONE), + ]); + assert!(Arc::ptr_eq(&document, &h.app.session.doc)); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision)); + h.app.run("render.cancel", json!({"job":pending})).unwrap(); +} + +#[test] +fn render_results_compare_live_projection_matches_image_fit_zoom_and_pan_without_an_oversized_gpu_viewport() { + use solidcraft_engine::geom::Vec3; + let canvas = egui::Rect::from_min_size(egui::pos2(100.0, 200.0), egui::vec2(800.0, 600.0)); + for fov in [0.0, 0.6] { + let camera = Camera { fov, roll: 0.25, ..Default::default() }; + for image in [ + egui::Rect::from_center_size(canvas.center(), egui::vec2(400.0, 400.0)), + egui::Rect::from_center_size(canvas.center(), egui::vec2(1600.0, 1200.0)), + egui::Rect::from_min_size(egui::pos2(-200.0, 350.0), egui::vec2(1200.0, 900.0)), + ] { + let projection = product_projection(camera, 100.0, canvas, Some(image)); + for point in [camera.target, camera.target + Vec3::X * 5.0, camera.target + Vec3::Z * 10.0] { + let (x, y, _) = camera.to_screen(point, f64::from(image.width()), f64::from(image.height()), 100.0).unwrap(); + let expected = egui::pos2(image.left() + x as f32, image.top() + y as f32); + let clip = projection.apply(point); + let actual = egui::pos2( + canvas.left() + ((clip[0] / clip[3] + 1.0) * 0.5) as f32 * canvas.width(), + canvas.top() + ((1.0 - clip[1] / clip[3]) * 0.5) as f32 * canvas.height(), + ); + assert!(actual.distance(expected) < 0.001, "{actual:?} != {expected:?}"); + } + } + assert_eq!(product_projection(camera, 100.0, canvas, None), camera.view_proj(f64::from(canvas.width() / canvas.height()), 100.0)); + } +} + #[test] fn render_lighting_preset_materialises_values_and_replacement_requires_review_consent() { let mut h = render_lights_fixture(); @@ -6713,3 +6982,106 @@ fn entering_render_fits_a_saved_portrait_setup_inside_its_final_frame() { assert_eq!((h.app.cam, h.app.ui.perspective), design, "fov {fov}: leaving Render restores the Design camera"); } } + +#[test] +fn render_results_compare_segments_work_from_live_and_close_safely_when_a_source_is_discarded() { + let (mut h, first, second) = render_results_compare_fixture(); + h.app.run("render.result.view", json!({"view":"model"})).unwrap(); + h.frames(3); + h.step(&json!({"click":{"handle":"render:compare:result:0"}})).unwrap(); + h.frames(2); + let view = h.app.render_workspace.view.compare.as_ref().unwrap(); + assert_eq!((view.left, view.right), (None, Some(first))); + h.step(&json!({"click":{"handle":"render:compare:result:1"}})).unwrap(); + h.frames(2); + assert_eq!(h.app.render_workspace.view.compare.as_ref().unwrap().right, Some(second)); + h.step(&json!({"click":{"handle":"render:compare:live"}})).unwrap(); + h.frames(2); + assert!(h.app.render_workspace.view.compare.is_none()); + assert_eq!(h.app.render_workspace.view.completed, Some(second)); + h.app.run("render.compare", json!({"left":0,"right":1})).unwrap(); + h.frames(2); + h.app.run("render.result.discard", json!({"index":0})).unwrap(); + h.frames(2); + assert!(h.app.render_workspace.view.compare.is_none()); + assert_eq!(h.app.render_workspace.view.completed, Some(second)); + let third = completed_preview(&mut h, [100, 120, 140]); + let fourth = completed_preview(&mut h, [140, 160, 180]); + h.app.run("render.compare", json!({"left":1,"right":2})).unwrap(); + h.app.run("render.result.discard", json!({"index":0})).unwrap(); + h.frames(2); + let view = h.app.render_workspace.view.compare.as_ref().unwrap(); + assert_eq!((view.left, view.right), (Some(third), Some(fourth)), "discarding an unrelated earlier row must not retarget comparison"); + assert_eq!(h.app.session.render_comparison(), Some([Some(third), Some(fourth)])); + assert!(h.app.run("render.compare", json!({"left":"live","right":99})).is_err()); +} + +fn render_results_batch_fixture() -> Harness { + let mut h = output_viewer_fixture(); + h.call("ui.resize", json!({"width":1440,"height":900})); + for (index, name) in ["Front", "Hero", "Top"].iter().enumerate() { + let camera = Camera { yaw: index as f64 * 0.3, ..Default::default() }; + h.app.run("render.settings.set", json!({"name":name,"set":{"camera":camera,"width":8,"height":8}})).unwrap(); + } + h.frames(3); + h +} + +#[test] +fn render_results_batch_output_footer_only_starts_on_click_and_cancel_drops_waiting_shots() { + let mut h = render_results_batch_fixture(); + assert!(h.app.render_workspace.view.job.is_none()); + assert_eq!((h.app.session.render_queue_state().running, h.app.session.render_queue_state().waiting), (0, 0)); + h.app.render_workspace.view.draft.width = 128; + h.app.render_workspace.view.draft.height = 128; + h.app.render_workspace.view.dirty = true; + h.frames(2); + let document = h.app.session.doc.clone(); + let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision); + let camera = h.app.cam; + h.step(&json!({"click":{"handle":"render:output:all-shots"}})).unwrap(); + h.frames(1); + let queue = h.app.session.render_queue_state(); + assert_eq!((queue.running, queue.waiting), (1, 2)); + assert_eq!(h.app.render_workspace.view.job, queue.job); + let status = crate::i18n::format("render.batch_status", &[("running", "1"), ("waiting", "2")]); + assert!(h.shapes.iter().any(|shape| matches!(&shape.shape,egui::Shape::Text(text) if text.galley.text()==status))); + assert!(crate::scenario::rect_of("render:shots:queue").is_some()); + h.step(&json!({"click":{"handle":"render:stage:render.cancel"}})).unwrap(); + h.frames(3); + assert_eq!((h.app.session.render_queue_state().running, h.app.session.render_queue_state().waiting), (0, 0)); + assert!(h.app.session.render_retained_results().unwrap().is_empty()); + assert_eq!(h.app.cam, camera); + assert!(Arc::ptr_eq(&document, &h.app.session.doc)); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision)); +} + +#[test] +fn render_results_batch_continues_in_background_tabs_and_keeps_each_shot_result_with_its_document() { + let mut h = render_results_batch_fixture(); + let document = h.app.session.doc.clone(); + let before = (h.app.session.undo.len(), h.app.session.redo.len()); + let captured_revision = h.app.session.revision; + let host = h.app.session.render_job_host().unwrap().clone(); + h.app.run("render.batch", json!({"request":{"settings":{"width":8,"height":8}}})).unwrap(); + crate::documents::open_tab(&mut h.app, Session::default()).unwrap(); + let other = h.app.session.doc.clone(); + for _ in 0..3 { + for _ in 0..100 { + if !host.pump(4096).unwrap() { + break; + } + } + h.frames(1); + } + assert!(Arc::ptr_eq(&other, &h.app.session.doc)); + assert!(h.app.session.render_retained_results().unwrap().is_empty()); + crate::documents::switch(&mut h.app, 0); + h.frames(2); + let results = h.app.session.render_retained_results().unwrap(); + assert_eq!(results.iter().map(|result| result.shot.as_deref().unwrap()).collect::>(), ["Front", "Hero", "Top"]); + assert_eq!((h.app.session.render_queue_state().running, h.app.session.render_queue_state().waiting), (0, 0)); + assert!(Arc::ptr_eq(&document, &h.app.session.doc)); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len())); + assert!(results.iter().all(|result| result.frame.scene_generation == captured_revision)); +} diff --git a/crates/ui-egui/src/ui_kit/compare.rs b/crates/ui-egui/src/ui_kit/compare.rs new file mode 100644 index 000000000..e28c3d98f --- /dev/null +++ b/crates/ui-egui/src/ui_kit/compare.rs @@ -0,0 +1,55 @@ +//! Shared image-comparison divider and corner chips. Geometry and ink use kit tokens. +use crate::{scenario, theme::Tokens}; +use egui::{Rect, Sense, Ui, pos2, vec2}; + +pub(crate) fn comparison_position(position: f32) -> f32 { + if position.is_finite() { position.clamp(0.05, 0.95) } else { 0.5 } +} + +/// A vertical wipe handle. The caller owns its command and suppresses canvas navigation while captured. +pub(crate) fn comparison_divider(ui: &mut Ui, canvas: Rect, position: &mut f32, label: &str) -> egui::Response { + let t = Tokens::get(); + *position = comparison_position(*position); + let x = canvas.left() + canvas.width() * *position; + let rail = Rect::from_center_size(pos2(x, canvas.center().y), vec2(t.space_16, canvas.height())); + let mut response = ui.interact(rail, ui.id().with("comparison_divider"), Sense::drag()).on_hover_cursor(egui::CursorIcon::ResizeHorizontal); + if response.dragged() + && let Some(pointer) = response.interact_pointer_pos() + { + *position = comparison_position((pointer.x - canvas.left()) / canvas.width().max(1.0)); + response.mark_changed(); + } + comparison_divider_chrome(ui, canvas, *position); + response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Slider, ui.is_enabled(), label)); + scenario::publish_target("render:compare:divider", rail); + response +} + +pub(crate) fn comparison_divider_chrome(ui: &Ui, canvas: Rect, position: f32) { + let t = Tokens::get(); + let x = canvas.left() + canvas.width() * comparison_position(position); + let painter = ui.painter().with_clip_rect(canvas.intersect(ui.clip_rect())); + let accent = crate::theme::TabAccent::current(ui.ctx()); + painter.vline(x, canvas.y_range(), egui::Stroke::new(t.space_2, accent.ink)); + let handle = Rect::from_center_size(pos2(x, canvas.center().y), vec2(t.space_16, t.space_24 + t.space_8)); + painter.rect_filled(handle, t.control_radius, t.panel); + painter.rect_stroke(handle, t.control_radius, t.control_border_stroke(accent.ink), egui::StrokeKind::Inside); + for offset in [-t.space_6, 0.0, t.space_6] { + painter.circle_filled(handle.center() + vec2(0.0, offset), t.space_2, accent.ink); + } + scenario::publish_rect("render:compare:handle", handle); +} + +/// Token-painted chip anchored inside either clipped half of the image canvas. +pub(crate) fn comparison_badge(ui: &mut Ui, bounds: Rect, label: &str, right: bool) { + let t = Tokens::get(); + let galley = ui.painter().layout_no_wrap(label.to_owned(), egui::FontId::proportional(t.font_label), t.form_ink); + let size = vec2((galley.size().x + t.space_16).min((bounds.width() - t.space_16).max(0.0)), t.control_height); + let x = if right { bounds.right() - size.x - t.space_8 } else { bounds.left() + t.space_8 }; + let rect = Rect::from_min_size(pos2(x, bounds.top() + t.space_8), size); + let painter = ui.painter().with_clip_rect(bounds.intersect(ui.clip_rect())); + painter.rect_filled(rect, t.control_radius, t.panel); + painter.rect_stroke(rect, t.control_radius, t.control_border_stroke(t.control_border), egui::StrokeKind::Inside); + painter.with_clip_rect(rect).galley(pos2(rect.left() + t.space_8, rect.center().y - galley.size().y * 0.5), galley, t.form_ink); + scenario::publish_rect(if right { "render:compare:right-label" } else { "render:compare:left-label" }, rect); +} diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs index 3027ff092..608422d42 100644 --- a/crates/ui-egui/src/ui_kit/gallery.rs +++ b/crates/ui-egui/src/ui_kit/gallery.rs @@ -171,6 +171,15 @@ const ELEMENTS: &[Element] = &[ let (viewport, _) = ui.allocate_exact_size(vec2(200.0, 150.0), egui::Sense::hover()); frame_guides(ui, viewport, viewport.shrink(20.0), FrameGuides { thirds: true, safe_area: true, centre_mark: true }); }), + element!("comparison_divider", |ui, _| { + let (rect, _) = ui.allocate_exact_size(vec2(220.0, 100.0), egui::Sense::hover()); + let mut position = 0.5; + comparison_divider(ui, rect, &mut position, "Comparison divider"); + }), + element!("comparison_badge", |ui, _| { + let (rect, _) = ui.allocate_exact_size(vec2(220.0, 100.0), egui::Sense::hover()); + comparison_badge(ui, rect, "Live preview", false); + }), element!("tree_row_rect", |ui, _| { for (index, row) in [ Row { label: "Objects", ..Default::default() }, diff --git a/crates/ui-egui/src/ui_kit/mod.rs b/crates/ui-egui/src/ui_kit/mod.rs index 4e5d5eede..c280159ca 100644 --- a/crates/ui-egui/src/ui_kit/mod.rs +++ b/crates/ui-egui/src/ui_kit/mod.rs @@ -7,6 +7,7 @@ mod assistant_entry; mod checks; mod choice; mod color; +mod compare; mod confirm; pub mod container; mod details; @@ -57,6 +58,7 @@ pub(crate) use checks::tests::{raster as test_raster, textures_update as test_te pub(crate) use checks::*; pub(crate) use choice::*; pub(crate) use color::*; +pub(crate) use compare::*; pub(crate) use confirm::{Confirm, Tone}; pub use container::{Container, DockEdges, Edge, Surface}; pub(crate) use details::*; diff --git a/crates/ui-egui/src/ui_kit/test_support_tests.rs b/crates/ui-egui/src/ui_kit/test_support_tests.rs index 216894e92..f288a8536 100644 --- a/crates/ui-egui/src/ui_kit/test_support_tests.rs +++ b/crates/ui-egui/src/ui_kit/test_support_tests.rs @@ -4,6 +4,29 @@ use egui::{Ui, vec2}; pub(crate) use crate::test_support::{key, pointer}; +#[test] +fn render_results_shared_divider_clamps_hostile_positions_and_uses_bounded_chrome() { + for (input, expected) in [(f32::NAN, 0.5), (f32::INFINITY, 0.5), (f32::NEG_INFINITY, 0.5), (-1e30, 0.05), (0.25, 0.25), (1e30, 0.95)] { + assert_eq!(comparison_position(input), expected); + } + let ctx = crate::fonts::test_context(); + let position = std::cell::Cell::new(0.5); + let mut draw = |ui: &mut Ui| { + let (canvas, _) = ui.allocate_exact_size(vec2(240.0, 180.0), egui::Sense::hover()); + let mut value = position.get(); + comparison_divider(ui, canvas, &mut value, "Comparison divider"); + comparison_badge(ui, canvas, "Live preview", false); + position.set(value); + }; + frame(&ctx, vec![], &mut draw); + let handle = scenario::rect_of("render:compare:handle").unwrap().center(); + frame(&ctx, pointer(handle, true), &mut draw); + let end = egui::pos2(1000.0, handle.y); + frame(&ctx, vec![egui::Event::PointerMoved(end)], &mut draw); + assert_eq!(position.get(), 0.95); + frame(&ctx, pointer(end, false), &mut draw); +} + fn draw_frame(ctx: &egui::Context, events: Vec, mut add: impl FnMut(&mut Ui)) -> egui::FullOutput { scenario::clear_handles(); crate::test_support::frame( diff --git a/docs/render-workspace.md b/docs/render-workspace.md index 2284dd96b..b9092f5b4 100644 --- a/docs/render-workspace.md +++ b/docs/render-workspace.md @@ -14,6 +14,35 @@ The current integrated GPU renderer shows a separate product scene. Return to De restores its camera, projection preference and existing viewport drawing policy. The live product preview remains independent of the selected image method. +## Retained comparisons and all-shot rendering + +The result viewer retains up to eight completed images per document tab, outside +the design and undo history. `render.compare {left, right}` accepts `"live"` or a +zero-based retained-result index (oldest first); the sides must differ. It resolves +indices to job identities so later index shifts cannot retarget an open comparison. +`render.compare {off:true}` leaves comparison. The shared segments toggle the two +sources, Swap exchanges them, and the shared divider stays within 5–95%. Both sides +share image pan/zoom; the live product uses the captured camera and current design. +Dragging the divider cannot navigate either camera. Copy, export and regrade use +the compared result on the right (or the left when the right is Live). That selection +remains stable while new results arrive; evicting a source ends its comparison. + +The Output footer's **All shots (n)** runs `render.batch`. The command snapshots up +to 32 saved shot cameras and names and uses one common image setup. The UI supplies +the current draft as `request` (the existing `render.start` parameters); a headless +`render.batch {}` uses the first saved setup in name order. Each queued shot keeps its +own captured camera while all other options remain the same. Each admission runs +through `render.start`, one job at a time. No shots, an active render/queue or stale +geometry refuses without editing the design or history. + +`render.status {}` advances an explicitly started queue and returns +`{queue:{running,waiting,job,shot,error}}`; a status call with a job also includes +that queue metadata. The UI ticks advance queues in active and background tabs. +`render.cancel {}` cancels the active batch job and drops all waiting shots; an +explicit job ID retains the single-job cancellation API. Opening a stage, editor +or queue readout never starts a batch. The Shots strip reports running and waiting +counts, and completed shots enter the same retained-result list. + ## Stage bar and floating docks Render has no ribbon. A shared 88 pt two-row stage bar sits 8 pt to the right of @@ -544,8 +573,10 @@ The stage bar's Check chip and Output's note count open Check. Check now runs th read-only `render.preflight` without admitting a job. Notes offer links to their owning editor. Copy report and diagnostic JSON use `render.preflight.copy` and the platform clipboard queue; headless calls only validate and echo bounded text. -Named quality presets, EXR export and rendering all shots remain faded with their -existing reasons. Destination selection uses the completed-image export picker. +Named quality presets and EXR export remain faded with their existing reasons. +Destination selection uses the completed-image export picker. The pinned Render +Image / All shots footer starts the active setup or queues all saved shots through +`render.batch`; opening the editor never starts a job. Render and Cancel stay in the stage bar. Active jobs also show a single-row progress pill with Cancel. The result viewer retains Copy, export, close, Fit/100% and shared diff --git a/docs/ui-kit.md b/docs/ui-kit.md index d5fcf35ad..742314845 100644 --- a/docs/ui-kit.md +++ b/docs/ui-kit.md @@ -199,6 +199,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera | Module / element | Use and options | Main tokens | | --- | --- | --- | +| compare: `comparison_divider`, `comparison_divider_chrome`, `comparison_badge` | Clamped vertical image wipe handle and bounded corner labels. The caller owns commands, shared framing and navigation suppression while the handle captures input; the paint-only chrome can be raised above source callbacks. | `control_height/radius/border`, `space_2/6/8/16/24`, `font_label`, `form_ink`, `panel`, active `TabAccent` | | assistant: `assistant_header`, `assistant_controls`, `assistant_badge`, `assistant_bubble`, `assistant_prose`, `assistant_tool_frame/row/detail/status`, `AssistantToolState`, `assistant_approval/actions`, `assistant_composer/footer`, `assistant_input`, `assistant_send`, `assistant_empty`, `assistant_banner`/`banner`, `AssistantTone` | Shared Assistant presentation: 40 pt header, 22 pt state pill, right-aligned user messages limited to 86% width, unboxed assistant prose, bordered tool groups and command detail, tinted approval heading, rounded focused composer with one unframed growing editor and pinned footer, centred setup copy and semantic notices. Closures preserve existing permission choices, protocol routing, queue actions and scenario handles. | `form_header_height/close_size`, `font_label/small/body`, `dialog_body/footer/rule`, `control_fill/border/radius`, `form_ink/dim/primary/success/error`, `accent_soft/selected_ink`, `warning`, radii and spacing | | history: `StripHeading`, `HistoryChip`, `HistoryStyle`, `history_drop_bar`, `history_marker`, `HistorySeam`, `history_seam` | Shared strip headings use semibold `font_heading`, `text`, a centred baseline and `space_12` trailing gap. One painter family for bottom chips, 38 pt vertical icon chips and single-line 26 pt name rows (the browser's shared `TREE_ROW_HEIGHT`). Selected items use the active tab tint/ink/border; all variants retain multi-tone feature artwork using one shared kind-to-accent rule (Sketch green, Surface orange, Mesh yellow, Form purple, solids base blue); rolled-back items have 42% opacity; a reference row (a sketch listed under another feature, #6489) has its name in secondary text. Error/warning badges, suppression strikes, horizontal/vertical drop bars and rollback line/hollow circle are shared. No connector lines. | `control_height`, `space_2/3/4/6/8/10/12/14/16/24`, radii, typography, `TabAccent`, `timeline_item`, `control_border`, `text/dim`, `form_error/fill` | | tree: `tree_row`, `Row`, `TreeAction` | Shared Browser rows with disclosure, visibility (an eye column at the row's end, clear of a floating scroll bar, with a gap between the disclosure and the activation radio; or beside the disclosure with `eye_left`), activation, selection, appearance swatches, optional subtitle and trailing actions. Compact scene rows are 28 pt, with inline right-aligned summaries, circular swatches, trailing eyes and full-width selection tint. Actions use quiet icons and can appear on hover. Disabled actions retain their reasons and cannot select or fold the row. Browser automation records the same row geometry. | `TREE_ROW_HEIGHT`, `font_label/small`, spacing, control radius/border, `text/dim`, workspace selection tint |