From d2fcab84322bafac4a187cff91eb4f7800d652ef Mon Sep 17 00:00:00 2001 From: Nathan Dane Date: Thu, 29 Oct 2026 07:03:24 +0000 Subject: [PATCH] Render shot editor: camera and frame controls, aspect presets, guides and frame overlay (#6281) (#7232) * Render shot editor: camera and frame controls, aspect presets, guides and the frame overlay * Render shot: Shot editor and Scene overview to the approved design * Distinguish Render stage variants from native window frames * fix: restore library inspection after clearing shot selection * test: follow the merged Output Check navigation * test: inspect Check without requiring a preflight result * test: cancel Shot removal through its shared dialog action * fix: remove obsolete Inspector stage form after editor integration * fix: preserve Appearance Advanced when clearing Wear focus * test: expect the dedicated Check editor from Scene overview --- assets/locales/pending/render-frame.json | 226 ++++++++ assets/locales/pending/render-shot-scene.json | 298 ++++++++++ .../engine/src/cmd/render/settings_tests.rs | 41 ++ crates/engine/src/cmd/view_navigation.rs | 53 ++ crates/engine/src/schema/view_navigation.rs | 34 ++ crates/ui-egui/src/lib.rs | 7 + crates/ui-egui/src/render_workspace.rs | 33 +- .../ui-egui/src/render_workspace_inspector.rs | 167 ++++-- .../src/render_workspace_inspector_tests.rs | 297 +++++++++- .../ui-egui/src/render_workspace_library.rs | 16 +- .../src/render_workspace_library_review.rs | 2 + crates/ui-egui/src/render_workspace_shot.rs | 511 ++++++++++++++++++ crates/ui-egui/src/render_workspace_tests.rs | 209 ++++++- crates/ui-egui/src/ui_kit/actions.rs | 8 + crates/ui-egui/src/ui_kit/fields.rs | 28 + crates/ui-egui/src/ui_kit/framing.rs | 112 ++++ crates/ui-egui/src/ui_kit/gallery.rs | 24 + crates/ui-egui/src/ui_kit/mod.rs | 2 + crates/ui-egui/src/ui_kit_guard_tests.rs | 6 +- docs/render-shot-scene.md | 47 ++ docs/render-workspace.md | 14 + docs/ui-kit.md | 11 + 22 files changed, 2064 insertions(+), 82 deletions(-) create mode 100644 assets/locales/pending/render-frame.json create mode 100644 assets/locales/pending/render-shot-scene.json create mode 100644 crates/ui-egui/src/render_workspace_shot.rs create mode 100644 crates/ui-egui/src/ui_kit/framing.rs create mode 100644 docs/render-shot-scene.md diff --git a/assets/locales/pending/render-frame.json b/assets/locales/pending/render-frame.json new file mode 100644 index 000000000..15d455f8e --- /dev/null +++ b/assets/locales/pending/render-frame.json @@ -0,0 +1,226 @@ +{ + "en": { + "cmd.view_render_frame": "Render Frame Guides", + "render.frame_aspect": "Aspect", + "render.frame_centre_mark": "Centre mark", + "render.frame_copy_limit": "No available duplicate shot name", + "render.frame_copy_name": "{name} copy {number}", + "render.frame_custom": "Custom", + "render.frame_distance_unit": " × size", + "render.frame_exposure": "Exposure", + "render.frame_fov": "Field of view", + "render.frame_guides": "Guides", + "render.frame_invalid_aspect": "Invalid aspect preset", + "render.frame_lens": "FOV {fov}° · ≈ {mm} mm", + "render.frame_name": "Name", + "render.frame_output_size": "Output size", + "render.frame_photo": "3:2 · Photo", + "render.frame_portrait": "4:5 · Portrait", + "render.frame_projection": "Projection", + "render.frame_render_shot": "Render this shot", + "render.frame_rule_thirds": "Rule of thirds", + "render.frame_safe_area": "Safe area", + "render.frame_shot_title": "Shot · {name}", + "render.frame_square": "1:1 · Square", + "render.frame_tall": "9:16 · Vertical", + "render.frame_thirds": "Thirds", + "render.frame_wide": "16:9 · Widescreen", + "render.frame_duplicate": "Duplicate" + }, + "de": { + "cmd.view_render_frame": "Render-Bildhilfen", + "render.frame_aspect": "Seitenverhältnis", + "render.frame_centre_mark": "Mittelpunkt", + "render.frame_copy_limit": "Kein freier Name für eine Aufnahme-Kopie", + "render.frame_copy_name": "{name} Kopie {number}", + "render.frame_custom": "Benutzerdefiniert", + "render.frame_distance_unit": " × Größe", + "render.frame_exposure": "Belichtung", + "render.frame_fov": "Bildwinkel", + "render.frame_guides": "Hilfslinien", + "render.frame_invalid_aspect": "Ungültige Seitenverhältnis-Vorgabe", + "render.frame_lens": "Bildwinkel {fov}° · ≈ {mm} mm", + "render.frame_name": "Name", + "render.frame_output_size": "Ausgabegröße", + "render.frame_photo": "3:2 · Foto", + "render.frame_portrait": "4:5 · Hochformat", + "render.frame_projection": "Projektion", + "render.frame_render_shot": "Diese Aufnahme rendern", + "render.frame_rule_thirds": "Drittelregel", + "render.frame_safe_area": "Sicherer Bereich", + "render.frame_shot_title": "Aufnahme · {name}", + "render.frame_square": "1:1 · Quadrat", + "render.frame_tall": "9:16 · Vertikal", + "render.frame_thirds": "Drittellinien", + "render.frame_wide": "16:9 · Breitbild", + "render.frame_duplicate": "Duplizieren" + }, + "ja": { + "cmd.view_render_frame": "レンダーフレームガイド", + "render.frame_aspect": "アスペクト比", + "render.frame_centre_mark": "中心マーク", + "render.frame_copy_limit": "複製ショット名を作成できません", + "render.frame_copy_name": "{name} のコピー {number}", + "render.frame_custom": "カスタム", + "render.frame_distance_unit": " × サイズ", + "render.frame_exposure": "露出", + "render.frame_fov": "画角", + "render.frame_guides": "ガイド", + "render.frame_invalid_aspect": "無効なアスペクト比プリセット", + "render.frame_lens": "画角 {fov}° · 約 {mm} mm", + "render.frame_name": "名前", + "render.frame_output_size": "出力サイズ", + "render.frame_photo": "3:2 · 写真", + "render.frame_portrait": "4:5 · ポートレート", + "render.frame_projection": "投影", + "render.frame_render_shot": "このショットをレンダー", + "render.frame_rule_thirds": "三分割法", + "render.frame_safe_area": "セーフエリア", + "render.frame_shot_title": "ショット · {name}", + "render.frame_square": "1:1 · 正方形", + "render.frame_tall": "9:16 · 縦長", + "render.frame_thirds": "三分割線", + "render.frame_wide": "16:9 · ワイドスクリーン", + "render.frame_duplicate": "複製" + }, + "ko": { + "cmd.view_render_frame": "렌더 프레임 가이드", + "render.frame_aspect": "화면 비율", + "render.frame_centre_mark": "중심 표시", + "render.frame_copy_limit": "사용 가능한 복제 샷 이름이 없습니다", + "render.frame_copy_name": "{name} 복사본 {number}", + "render.frame_custom": "사용자 지정", + "render.frame_distance_unit": " × 크기", + "render.frame_exposure": "노출", + "render.frame_fov": "시야각", + "render.frame_guides": "가이드", + "render.frame_invalid_aspect": "잘못된 화면 비율 프리셋", + "render.frame_lens": "시야각 {fov}° · 약 {mm} mm", + "render.frame_name": "이름", + "render.frame_output_size": "출력 크기", + "render.frame_photo": "3:2 · 사진", + "render.frame_portrait": "4:5 · 세로", + "render.frame_projection": "투영", + "render.frame_render_shot": "이 샷 렌더링", + "render.frame_rule_thirds": "삼분할 법칙", + "render.frame_safe_area": "안전 영역", + "render.frame_shot_title": "샷 · {name}", + "render.frame_square": "1:1 · 정사각형", + "render.frame_tall": "9:16 · 세로형", + "render.frame_thirds": "삼분할선", + "render.frame_wide": "16:9 · 와이드스크린", + "render.frame_duplicate": "복제" + }, + "zh": { + "cmd.view_render_frame": "渲染构图辅助线", + "render.frame_aspect": "宽高比", + "render.frame_centre_mark": "中心标记", + "render.frame_copy_limit": "没有可用的镜头副本名称", + "render.frame_copy_name": "{name} 副本 {number}", + "render.frame_custom": "自定义", + "render.frame_distance_unit": " × 尺寸", + "render.frame_exposure": "曝光", + "render.frame_fov": "视场角", + "render.frame_guides": "辅助线", + "render.frame_invalid_aspect": "无效的宽高比预设", + "render.frame_lens": "视场角 {fov}° · 约 {mm} mm", + "render.frame_name": "名称", + "render.frame_output_size": "输出尺寸", + "render.frame_photo": "3:2 · 照片", + "render.frame_portrait": "4:5 · 人像", + "render.frame_projection": "投影", + "render.frame_render_shot": "渲染此镜头", + "render.frame_rule_thirds": "三分法", + "render.frame_safe_area": "安全区域", + "render.frame_shot_title": "镜头 · {name}", + "render.frame_square": "1:1 · 正方形", + "render.frame_tall": "9:16 · 竖屏", + "render.frame_thirds": "三分线", + "render.frame_wide": "16:9 · 宽屏", + "render.frame_duplicate": "复制" + }, + "ar": { + "cmd.view_render_frame": "أدلة إطار التصيير", + "render.frame_aspect": "النسبة", + "render.frame_centre_mark": "علامة المركز", + "render.frame_copy_limit": "لا يوجد اسم متاح للقطة مكررة", + "render.frame_copy_name": "{name} نسخة {number}", + "render.frame_custom": "مخصص", + "render.frame_distance_unit": " × الحجم", + "render.frame_exposure": "التعريض", + "render.frame_fov": "مجال الرؤية", + "render.frame_guides": "الأدلة", + "render.frame_invalid_aspect": "إعداد نسبة غير صالح", + "render.frame_lens": "مجال الرؤية {fov}° · ≈ {mm} مم", + "render.frame_name": "الاسم", + "render.frame_output_size": "حجم المخرجات", + "render.frame_photo": "3:2 · صورة", + "render.frame_portrait": "4:5 · عمودي", + "render.frame_projection": "الإسقاط", + "render.frame_render_shot": "صيّر هذه اللقطة", + "render.frame_rule_thirds": "قاعدة الأثلاث", + "render.frame_safe_area": "المنطقة الآمنة", + "render.frame_shot_title": "لقطة · {name}", + "render.frame_square": "1:1 · مربع", + "render.frame_tall": "9:16 · رأسي", + "render.frame_thirds": "الأثلاث", + "render.frame_wide": "16:9 · عريض", + "render.frame_duplicate": "تكرار" + }, + "he": { + "cmd.view_render_frame": "מדריכי מסגרת רינדור", + "render.frame_aspect": "יחס", + "render.frame_centre_mark": "סימן מרכז", + "render.frame_copy_limit": "אין שם פנוי לצילום משוכפל", + "render.frame_copy_name": "{name} עותק {number}", + "render.frame_custom": "מותאם", + "render.frame_distance_unit": " × גודל", + "render.frame_exposure": "חשיפה", + "render.frame_fov": "שדה ראייה", + "render.frame_guides": "מדריכים", + "render.frame_invalid_aspect": "הגדרת יחס לא תקינה", + "render.frame_lens": "שדה ראייה {fov}° · ≈ {mm} מ״מ", + "render.frame_name": "שם", + "render.frame_output_size": "גודל פלט", + "render.frame_photo": "3:2 · צילום", + "render.frame_portrait": "4:5 · לאורך", + "render.frame_projection": "היטל", + "render.frame_render_shot": "רנדר צילום זה", + "render.frame_rule_thirds": "כלל השלישים", + "render.frame_safe_area": "אזור בטוח", + "render.frame_shot_title": "צילום · {name}", + "render.frame_square": "1:1 · ריבוע", + "render.frame_tall": "9:16 · אנכי", + "render.frame_thirds": "שלישים", + "render.frame_wide": "16:9 · רחב", + "render.frame_duplicate": "שכפל" + }, + "vi": { + "cmd.view_render_frame": "Đường dẫn khung kết xuất", + "render.frame_aspect": "Tỷ lệ", + "render.frame_centre_mark": "Dấu tâm", + "render.frame_copy_limit": "Không còn tên khả dụng cho cảnh chụp nhân bản", + "render.frame_copy_name": "{name} bản sao {number}", + "render.frame_custom": "Tùy chỉnh", + "render.frame_distance_unit": " × kích thước", + "render.frame_exposure": "Phơi sáng", + "render.frame_fov": "Trường nhìn", + "render.frame_guides": "Đường dẫn", + "render.frame_invalid_aspect": "Tỷ lệ đặt sẵn không hợp lệ", + "render.frame_lens": "Trường nhìn {fov}° · ≈ {mm} mm", + "render.frame_name": "Tên", + "render.frame_output_size": "Kích thước đầu ra", + "render.frame_photo": "3:2 · Ảnh", + "render.frame_portrait": "4:5 · Chân dung", + "render.frame_projection": "Phép chiếu", + "render.frame_render_shot": "Kết xuất cảnh chụp này", + "render.frame_rule_thirds": "Quy tắc một phần ba", + "render.frame_safe_area": "Vùng an toàn", + "render.frame_shot_title": "Cảnh chụp · {name}", + "render.frame_square": "1:1 · Vuông", + "render.frame_tall": "9:16 · Dọc", + "render.frame_thirds": "Một phần ba", + "render.frame_wide": "16:9 · Màn ảnh rộng", + "render.frame_duplicate": "Nhân bản" + } +} diff --git a/assets/locales/pending/render-shot-scene.json b/assets/locales/pending/render-shot-scene.json new file mode 100644 index 000000000..10070dea0 --- /dev/null +++ b/assets/locales/pending/render-shot-scene.json @@ -0,0 +1,298 @@ +{ + "en": { + "render.shot_distance": "Distance", + "render.shot_lens": "Lens", + "render.shot_exposure_section": "Exposure", + "render.shot_size": "Size", + "render.shot_edit_output": "Edit in Output", + "render.shot_invalid_camera": "Camera values must be finite and within range.", + "render.shot_target": "Target", + "render.shot_frame_subject": "Frame subject", + "render.shot_look_selection": "Look at selection", + "render.shot_dof": "Depth of field", + "render.shot_aperture": "Aperture", + "render.shot_focus_distance": "Focus distance", + "render.shot_fov_reason": "Field of view needs perspective projection.", + "render.shot_selection_reason": "Select a body or face to aim at.", + "render.shot_lens_gpu_reason": "Depth of field needs GPU path tracing.", + "render.shot_lens_perspective_reason": "Depth of field needs perspective projection.", + "render.shot_lens_enable_reason": "Enable depth of field to edit aperture and focus distance.", + "render.shot_exposure_reason": "Exposure needs CPU ray tracing or GPU path tracing.", + "render.scene_stages": "Stages", + "render.scene_look_summary": "{looks} looks · {overrides} overrides", + "render.scene_light_summary": "{environment} · {lights} lights", + "render.scene_ready": "Ready to render", + "render.scene_check_passed": "Check passed · {notes} notes", + "render.scene_check_stale": "Check out of date · check again", + "render.scene_check_unchecked": "Not checked yet · 0 notes", + "render.scene_open_check": "Open Check", + "render.scene_renderer_ready": "{renderer} ready", + "render.scene_check_now": "Check now", + "render.scene_all_shots": "All shots ({count})", + "render.scene_batch_reason": "All shots needs the saved-shot render queue, which is not available yet.", + "render.scene_reminders": "Reminders", + "render.scene_reminder": "Scene preserves the design. Geometry, engineering properties and CAD are never changed from Render.", + "camera.shot_yaw": "Yaw", + "camera.shot_pitch": "Pitch", + "camera.shot_roll": "Roll" + }, + "ja": { + "render.shot_distance": "距離", + "render.shot_lens": "レンズ", + "render.shot_exposure_section": "露出", + "render.shot_size": "サイズ", + "render.shot_edit_output": "出力で編集", + "render.shot_invalid_camera": "カメラの値は有限で範囲内にしてください。", + "render.shot_target": "ターゲット", + "render.shot_frame_subject": "被写体を収める", + "render.shot_look_selection": "選択に注目", + "render.shot_dof": "被写界深度", + "render.shot_aperture": "絞り", + "render.shot_focus_distance": "焦点距離", + "render.shot_fov_reason": "画角には透視投影が必要です。", + "render.shot_selection_reason": "注目するボディまたは面を選択してください。", + "render.shot_lens_gpu_reason": "被写界深度には GPU パストレーシングが必要です。", + "render.shot_lens_perspective_reason": "被写界深度には透視投影が必要です。", + "render.shot_lens_enable_reason": "絞りと焦点距離を編集するには被写界深度を有効にしてください。", + "render.shot_exposure_reason": "露出には CPU レイトレーシングまたは GPU パストレーシングが必要です。", + "render.scene_stages": "ステージ", + "render.scene_look_summary": "{looks} ルック · {overrides} 上書き", + "render.scene_light_summary": "{environment} · {lights} ライト", + "render.scene_ready": "レンダリング準備", + "render.scene_check_passed": "チェック合格 · {notes} 件の注記", + "render.scene_check_stale": "チェックは古い状態です · 再チェック", + "render.scene_check_unchecked": "未チェック · 注記 0 件", + "render.scene_open_check": "チェックを開く", + "render.scene_renderer_ready": "{renderer} 準備完了", + "render.scene_check_now": "今すぐチェック", + "render.scene_all_shots": "すべてのショット ({count})", + "render.scene_batch_reason": "すべてのショットには、未対応の保存ショットのレンダーキューが必要です。", + "render.scene_reminders": "注意事項", + "render.scene_reminder": "シーンは設計を保持します。レンダーでは形状、工学的属性、CAD は変更されません。", + "camera.shot_yaw": "ヨー", + "camera.shot_pitch": "ピッチ", + "camera.shot_roll": "ロール" + }, + "zh": { + "render.shot_distance": "距离", + "render.shot_lens": "镜头", + "render.shot_exposure_section": "曝光", + "render.shot_size": "尺寸", + "render.shot_edit_output": "在输出中编辑", + "render.shot_invalid_camera": "相机值必须为范围内的有限数。", + "render.shot_target": "目标", + "render.shot_frame_subject": "框选主体", + "render.shot_look_selection": "看向所选内容", + "render.shot_dof": "景深", + "render.shot_aperture": "光圈", + "render.shot_focus_distance": "对焦距离", + "render.shot_fov_reason": "视场角需要透视投影。", + "render.shot_selection_reason": "请选择要看向的实体或面。", + "render.shot_lens_gpu_reason": "景深需要 GPU 路径追踪。", + "render.shot_lens_perspective_reason": "景深需要透视投影。", + "render.shot_lens_enable_reason": "启用景深以编辑光圈和对焦距离。", + "render.shot_exposure_reason": "曝光需要 CPU 光线追踪或 GPU 路径追踪。", + "render.scene_stages": "阶段", + "render.scene_look_summary": "{looks} 个外观 · {overrides} 个覆盖", + "render.scene_light_summary": "{environment} · {lights} 盏灯", + "render.scene_ready": "渲染准备", + "render.scene_check_passed": "检查通过 · {notes} 条说明", + "render.scene_check_stale": "检查已过期 · 请重新检查", + "render.scene_check_unchecked": "尚未检查 · 0 条说明", + "render.scene_open_check": "打开检查", + "render.scene_renderer_ready": "{renderer} 就绪", + "render.scene_check_now": "立即检查", + "render.scene_all_shots": "所有镜头 ({count})", + "render.scene_batch_reason": "所有镜头需要尚未提供的已保存镜头渲染队列。", + "render.scene_reminders": "提醒", + "render.scene_reminder": "场景保留设计。渲染不会更改几何、工程属性或 CAD。", + "camera.shot_yaw": "偏航", + "camera.shot_pitch": "俯仰", + "camera.shot_roll": "翻滚" + }, + "de": { + "render.shot_distance": "Abstand", + "render.shot_lens": "Objektiv", + "render.shot_exposure_section": "Belichtung", + "render.shot_size": "Größe", + "render.shot_edit_output": "In Ausgabe bearbeiten", + "render.shot_invalid_camera": "Kamerawerte müssen endlich und im gültigen Bereich sein.", + "render.shot_target": "Ziel", + "render.shot_frame_subject": "Motiv einpassen", + "render.shot_look_selection": "Auswahl anvisieren", + "render.shot_dof": "Schärfentiefe", + "render.shot_aperture": "Blende", + "render.shot_focus_distance": "Fokusabstand", + "render.shot_fov_reason": "Das Sichtfeld benötigt perspektivische Projektion.", + "render.shot_selection_reason": "Einen Körper oder eine Fläche als Ziel auswählen.", + "render.shot_lens_gpu_reason": "Schärfentiefe benötigt GPU-Pfadverfolgung.", + "render.shot_lens_perspective_reason": "Schärfentiefe benötigt perspektivische Projektion.", + "render.shot_lens_enable_reason": "Schärfentiefe aktivieren, um Blende und Fokusabstand zu bearbeiten.", + "render.shot_exposure_reason": "Belichtung benötigt CPU-Strahlverfolgung oder GPU-Pfadverfolgung.", + "render.scene_stages": "Phasen", + "render.scene_look_summary": "{looks} Looks · {overrides} Überschreibungen", + "render.scene_light_summary": "{environment} · {lights} Lichter", + "render.scene_ready": "Bereit zum Rendern", + "render.scene_check_passed": "Prüfung bestanden · {notes} Hinweise", + "render.scene_check_stale": "Prüfung veraltet · erneut prüfen", + "render.scene_check_unchecked": "Noch nicht geprüft · 0 Hinweise", + "render.scene_open_check": "Prüfung öffnen", + "render.scene_renderer_ready": "{renderer} bereit", + "render.scene_check_now": "Jetzt prüfen", + "render.scene_all_shots": "Alle Aufnahmen ({count})", + "render.scene_batch_reason": "Alle Aufnahmen benötigen die noch nicht verfügbare Renderwarteschlange.", + "render.scene_reminders": "Hinweise", + "render.scene_reminder": "Die Szene bewahrt den Entwurf. Geometrie, technische Eigenschaften und CAD werden in Render nie verändert.", + "camera.shot_yaw": "Gierwinkel", + "camera.shot_pitch": "Nickwinkel", + "camera.shot_roll": "Rollwinkel" + }, + "ko": { + "render.shot_distance": "거리", + "render.shot_lens": "렌즈", + "render.shot_exposure_section": "노출", + "render.shot_size": "크기", + "render.shot_edit_output": "출력에서 편집", + "render.shot_invalid_camera": "카메라 값은 범위 내의 유한한 수여야 합니다.", + "render.shot_target": "대상", + "render.shot_frame_subject": "피사체 맞추기", + "render.shot_look_selection": "선택 항목 바라보기", + "render.shot_dof": "피사계 심도", + "render.shot_aperture": "조리개", + "render.shot_focus_distance": "초점 거리", + "render.shot_fov_reason": "시야각에는 원근 투영이 필요합니다.", + "render.shot_selection_reason": "바라볼 바디나 면을 선택하세요.", + "render.shot_lens_gpu_reason": "피사계 심도에는 GPU 경로 추적이 필요합니다.", + "render.shot_lens_perspective_reason": "피사계 심도에는 원근 투영이 필요합니다.", + "render.shot_lens_enable_reason": "조리개와 초점 거리를 편집하려면 피사계 심도를 켜세요.", + "render.shot_exposure_reason": "노출에는 CPU 광선 추적 또는 GPU 경로 추적이 필요합니다.", + "render.scene_stages": "단계", + "render.scene_look_summary": "외관 {looks}개 · 재정의 {overrides}개", + "render.scene_light_summary": "{environment} · 조명 {lights}개", + "render.scene_ready": "렌더링 준비", + "render.scene_check_passed": "검사 통과 · 참고 {notes}개", + "render.scene_check_stale": "검사가 오래됨 · 다시 검사", + "render.scene_check_unchecked": "아직 검사하지 않음 · 참고 0개", + "render.scene_open_check": "검사 열기", + "render.scene_renderer_ready": "{renderer} 준비됨", + "render.scene_check_now": "지금 검사", + "render.scene_all_shots": "모든 샷 ({count})", + "render.scene_batch_reason": "모든 샷에는 아직 지원되지 않는 저장된 샷 렌더링 대기열이 필요합니다.", + "render.scene_reminders": "알림", + "render.scene_reminder": "장면은 설계를 보존합니다. 렌더링에서 형상, 엔지니어링 속성 및 CAD는 변경되지 않습니다.", + "camera.shot_yaw": "요", + "camera.shot_pitch": "피치", + "camera.shot_roll": "롤" + }, + "ar": { + "render.shot_distance": "المسافة", + "render.shot_lens": "العدسة", + "render.shot_exposure_section": "التعريض", + "render.shot_size": "الحجم", + "render.shot_edit_output": "تعديل في المخرجات", + "render.shot_invalid_camera": "يجب أن تكون قيم الكاميرا منتهية وضمن النطاق.", + "render.shot_target": "الهدف", + "render.shot_frame_subject": "ضبط الإطار على الموضوع", + "render.shot_look_selection": "النظر إلى التحديد", + "render.shot_dof": "عمق الميدان", + "render.shot_aperture": "فتحة العدسة", + "render.shot_focus_distance": "مسافة التركيز", + "render.shot_fov_reason": "مجال الرؤية يتطلب إسقاطًا منظوريًا.", + "render.shot_selection_reason": "اختر جسمًا أو وجهًا للتصويب نحوه.", + "render.shot_lens_gpu_reason": "عمق الميدان يتطلب تتبّع المسار على بطاقة الرسومات.", + "render.shot_lens_perspective_reason": "عمق الميدان يتطلب إسقاطًا منظوريًا.", + "render.shot_lens_enable_reason": "فعّل عمق الميدان لتعديل فتحة العدسة ومسافة التركيز.", + "render.shot_exposure_reason": "التعريض يتطلب تتبّع الأشعة على المعالج أو تتبّع المسار على بطاقة الرسومات.", + "render.scene_stages": "المراحل", + "render.scene_look_summary": "{looks} مظهرًا · {overrides} تجاوزًا", + "render.scene_light_summary": "{environment} · {lights} أضواء", + "render.scene_ready": "جاهز للتصيير", + "render.scene_check_passed": "اجتاز الفحص · {notes} ملاحظات", + "render.scene_check_stale": "الفحص قديم · افحص مجددًا", + "render.scene_check_unchecked": "لم يُفحص بعد · 0 ملاحظات", + "render.scene_open_check": "فتح الفحص", + "render.scene_renderer_ready": "{renderer} جاهز", + "render.scene_check_now": "افحص الآن", + "render.scene_all_shots": "كل اللقطات ({count})", + "render.scene_batch_reason": "«كل اللقطات» يتطلب قائمة تصيير اللقطات المحفوظة، وهي غير متاحة بعد.", + "render.scene_reminders": "تذكيرات", + "render.scene_reminder": "المشهد يحفظ التصميم. لا تتغيّر الهندسة والخصائص الهندسية وCAD أبدًا من التصيير.", + "camera.shot_yaw": "الانعراج", + "camera.shot_pitch": "الميل", + "camera.shot_roll": "الدوران" + }, + "he": { + "render.shot_distance": "מרחק", + "render.shot_lens": "עדשה", + "render.shot_exposure_section": "חשיפה", + "render.shot_size": "גודל", + "render.shot_edit_output": "ערוך בפלט", + "render.shot_invalid_camera": "ערכי המצלמה חייבים להיות סופיים ובטווח.", + "render.shot_target": "יעד", + "render.shot_frame_subject": "מסגר נושא", + "render.shot_look_selection": "הבט אל הבחירה", + "render.shot_dof": "עומק שדה", + "render.shot_aperture": "צמצם", + "render.shot_focus_distance": "מרחק מיקוד", + "render.shot_fov_reason": "שדה ראייה דורש היטל פרספקטיבי.", + "render.shot_selection_reason": "בחר גוף או פאה לכוון אליהם.", + "render.shot_lens_gpu_reason": "עומק שדה דורש מעקב נתיב ב-GPU.", + "render.shot_lens_perspective_reason": "עומק שדה דורש היטל פרספקטיבי.", + "render.shot_lens_enable_reason": "הפעל עומק שדה כדי לערוך צמצם ומרחק מיקוד.", + "render.shot_exposure_reason": "חשיפה דורשת מעקב קרניים במעבד או מעקב נתיב ב-GPU.", + "render.scene_stages": "שלבים", + "render.scene_look_summary": "{looks} מראות · {overrides} עקיפות", + "render.scene_light_summary": "{environment} · {lights} אורות", + "render.scene_ready": "מוכן לרינדור", + "render.scene_check_passed": "הבדיקה עברה · {notes} הערות", + "render.scene_check_stale": "הבדיקה לא עדכנית · בדוק שוב", + "render.scene_check_unchecked": "טרם נבדק · 0 הערות", + "render.scene_open_check": "פתח בדיקה", + "render.scene_renderer_ready": "{renderer} מוכן", + "render.scene_check_now": "בדוק עכשיו", + "render.scene_all_shots": "כל הצילומים ({count})", + "render.scene_batch_reason": "כל הצילומים דורש את תור הרינדור של צילומים שמורים, שעדיין אינו זמין.", + "render.scene_reminders": "תזכורות", + "render.scene_reminder": "הסצנה משמרת את התכנון. הגאומטריה, התכונות ההנדסיות וה-CAD לעולם אינם משתנים מהרינדור.", + "camera.shot_yaw": "פנייה", + "camera.shot_pitch": "הטיה", + "camera.shot_roll": "גלגול" + }, + "vi": { + "render.shot_distance": "Khoảng cách", + "render.shot_lens": "Ống kính", + "render.shot_exposure_section": "Phơi sáng", + "render.shot_size": "Kích thước", + "render.shot_edit_output": "Sửa trong Đầu ra", + "render.shot_invalid_camera": "Giá trị máy ảnh phải hữu hạn và trong phạm vi.", + "render.shot_target": "Mục tiêu", + "render.shot_frame_subject": "Lấy khung đối tượng", + "render.shot_look_selection": "Nhìn vào vùng chọn", + "render.shot_dof": "Độ sâu trường ảnh", + "render.shot_aperture": "Khẩu độ", + "render.shot_focus_distance": "Khoảng cách lấy nét", + "render.shot_fov_reason": "Trường nhìn cần phép chiếu phối cảnh.", + "render.shot_selection_reason": "Chọn một thân hoặc mặt để nhắm tới.", + "render.shot_lens_gpu_reason": "Độ sâu trường ảnh cần dò đường đi của tia bằng GPU.", + "render.shot_lens_perspective_reason": "Độ sâu trường ảnh cần phép chiếu phối cảnh.", + "render.shot_lens_enable_reason": "Bật độ sâu trường ảnh để chỉnh khẩu độ và khoảng cách lấy nét.", + "render.shot_exposure_reason": "Phơi sáng cần dò tia bằng CPU hoặc dò đường đi của tia bằng GPU.", + "render.scene_stages": "Giai đoạn", + "render.scene_look_summary": "{looks} diện mạo · {overrides} ghi đè", + "render.scene_light_summary": "{environment} · {lights} đèn", + "render.scene_ready": "Sẵn sàng kết xuất", + "render.scene_check_passed": "Kiểm tra đạt · {notes} ghi chú", + "render.scene_check_stale": "Kết quả kiểm tra đã cũ · hãy kiểm tra lại", + "render.scene_check_unchecked": "Chưa kiểm tra · 0 ghi chú", + "render.scene_open_check": "Mở kiểm tra", + "render.scene_renderer_ready": "{renderer} sẵn sàng", + "render.scene_check_now": "Kiểm tra ngay", + "render.scene_all_shots": "Mọi cảnh chụp ({count})", + "render.scene_batch_reason": "Mọi cảnh chụp cần hàng đợi kết xuất cảnh chụp đã lưu, chưa khả dụng.", + "render.scene_reminders": "Nhắc nhở", + "render.scene_reminder": "Cảnh giữ nguyên thiết kế. Hình học, thuộc tính kỹ thuật và CAD không bao giờ bị đổi từ Kết xuất.", + "camera.shot_yaw": "Xoay ngang", + "camera.shot_pitch": "Nghiêng", + "camera.shot_roll": "Lăn" + } +} diff --git a/crates/engine/src/cmd/render/settings_tests.rs b/crates/engine/src/cmd/render/settings_tests.rs index 76855512d..a83598145 100644 --- a/crates/engine/src/cmd/render/settings_tests.rs +++ b/crates/engine/src/cmd/render/settings_tests.rs @@ -87,6 +87,47 @@ fn environment_editor_command_has_schemas_and_strict_validation() { assert!(s.execute("render.environment.set", &json!({"name":"Studio","intensity":2,"unknown":true})).is_err()); } +#[test] +fn shot_frame_edits_are_bounded_atomic_and_one_undo_per_edit() { + let mut s = Session::default(); + save(&mut s, json!({"width":800,"height":600})); + for patch in [ + json!({"width":1920,"height":1080}), + json!({"width":1080,"height":1920}), + json!({"exposure_ev":-32}), + json!({"exposure_ev":32}), + json!({"camera":{"target":[0,0,0],"yaw":0,"pitch":0,"distance":1e9,"fov":0}}), + ] { + let before = s.doc.clone(); + let undo = s.undo.len(); + let evaluations = s.evaluations; + save(&mut s, patch.clone()); + assert_eq!(s.undo.len(), undo + 1); + assert_eq!(s.evaluations, evaluations); + save(&mut s, patch); + assert_eq!(s.undo.len(), undo + 1); + s.execute("edit.undo", &json!({})).unwrap(); + assert_eq!(s.doc, before); + } + let before = s.doc.clone(); + let undo = s.undo.len(); + for patch in [ + json!({"width":0}), + json!({"height":0}), + json!({"width":u32::MAX}), + json!({"width":4096,"height":4096}), + json!({"width":1e300}), + json!({"exposure_ev":32.1}), + json!({"exposure_ev":-32.1}), + json!({"exposure_ev":null}), + json!({"camera":{"target":[0,0,0],"yaw":0,"pitch":0,"distance":0,"fov":0}}), + ] { + assert!(s.execute("render.settings.set", &json!({"name":"Studio","set":patch})).is_err()); + assert!(Arc::ptr_eq(&s.doc, &before)); + assert_eq!(s.undo.len(), undo); + } +} + #[cfg(not(target_arch = "wasm32"))] #[test] fn embedded_hdr_capture_is_offline_atomic_deduplicated_and_undoable_after_source_removal() { diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs index ca384f2f4..30d8ff711 100644 --- a/crates/engine/src/cmd/view_navigation.rs +++ b/crates/engine/src/cmd/view_navigation.rs @@ -54,6 +54,11 @@ CommandSpec::new("view.render_focus", "Render Focus View", crate::checked!("view .icon("render_scene").noundo().doc_only() .contract(&FOCUS_CONTRACT).output(output_schema_for::) .params("on: bool → {on}; per-window UI state, never saved in the design; headless validation only"), +CommandSpec::new("view.render_frame", "Render Frame Guides", crate::checked!("view.render_frame", render_frame)) + .icon("camera").noundo().doc_only() + .contract(&RENDER_FRAME_CONTRACT) + .output(crate::schema::output_schema_for::) + .params("aspect?: 16:9|3:2|1:1|4:5|9:16|custom; thirds?, safe_area?, centre_mark?: bool. At least one field. Validated transient overlay request, echoed headlessly; never saves guides, changes output size, evaluates geometry or opens a dialog"), CommandSpec::new("view.render_browser", "Render Browser", crate::checked!("view.render_browser", render_browser)) .icon("list").noundo().doc_only() .contract(&BROWSER_CONTRACT).output(output_schema_for::) @@ -298,6 +303,17 @@ fn render_browser(_s: &mut Session, p: &Value) -> Result { serde_json::to_value(request).map_err(|e| bad("view.render_browser", e.to_string())) } +static RENDER_FRAME_CONTRACT: crate::schema::TypedContract = crate::schema::TypedContract::new(); + +fn render_frame(_s: &mut Session, p: &Value) -> Result { + let cmd = "view.render_frame"; + let request: crate::schema::view_navigation::RenderFrame = serde_json::from_value(p.clone()).map_err(|e| bad(cmd, e.to_string()))?; + if request.aspect.is_none() && request.thirds.is_none() && request.safe_area.is_none() && request.centre_mark.is_none() { + return Err(bad(cmd, "expected at least one frame control")); + } + serde_json::to_value(request).map_err(|e| bad(cmd, e.to_string())) +} + fn render_stage(_s: &mut Session, p: &Value) -> Result { #[derive(serde::Deserialize)] #[serde(deny_unknown_fields)] @@ -1071,6 +1087,43 @@ fn render_workspace_shots_strip_is_a_validated_headless_preference_request() { assert_eq!(before, (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty())); } +#[cfg(test)] +#[test] +fn render_frame_validates_hostile_requests_without_saving_guides_or_evaluating() { + let mut s = Session::default(); + let document = s.doc.clone(); + let before = (s.undo.len(), s.redo.len(), s.revision, s.evaluations, s.is_dirty()); + for mode in [crate::schema::ParamCheck::Off, crate::schema::ParamCheck::Strict] { + s.param_check = mode; + for aspect in ["16:9", "3:2", "1:1", "4:5", "9:16", "custom"] { + let request = json!({"aspect":aspect,"thirds":true,"safe_area":false,"centre_mark":true}); + assert_eq!(s.execute("view.render_frame", &request).unwrap(), request); + } + for request in [json!({"thirds":false}), json!({"safe_area":true}), json!({"centre_mark":false})] { + assert_eq!(s.execute("view.render_frame", &request).unwrap(), request); + } + for request in [ + Value::Null, + json!({}), + json!([]), + json!({"thirds":null}), + json!({"thirds":1e300}), + json!({"safe_area":"yes"}), + json!({"centre_mark":[]}), + json!({"aspect":"4:3"}), + json!({"aspect":"x".repeat(1025)}), + json!({"aspect":null}), + json!({"thirds":true,"extra":1}), + ] { + assert!(s.execute("view.render_frame", &request).is_err(), "{request}"); + } + } + 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())); + let command = crate::find_command("view.render_frame").unwrap(); + assert!(command.contract.is_some() && command.output.is_some()); +} + #[cfg(test)] #[test] fn render_workspace_stage_validates_without_document_changes_or_evaluation() { diff --git a/crates/engine/src/schema/view_navigation.rs b/crates/engine/src/schema/view_navigation.rs index a16c66860..39a60f8ab 100644 --- a/crates/engine/src/schema/view_navigation.rs +++ b/crates/engine/src/schema/view_navigation.rs @@ -145,6 +145,40 @@ impl JsonSchema for RenderSelect { } } +#[derive(Clone, Copy, Debug, Deserialize, Serialize, JsonSchema)] +pub enum FrameAspect { + #[serde(rename = "16:9")] + Wide, + #[serde(rename = "3:2")] + Photo, + #[serde(rename = "1:1")] + Square, + #[serde(rename = "4:5")] + Portrait, + #[serde(rename = "9:16")] + Tall, + #[serde(rename = "custom")] + Custom, +} + +#[derive(Debug, Deserialize, Serialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct RenderFrame { + /// Overlay aspect selection only; output dimensions require render.settings.set. + #[serde(default, deserialize_with = "super::types::present", skip_serializing_if = "Option::is_none")] + #[schemars(with = "FrameAspect")] + pub aspect: Option, + #[serde(default, deserialize_with = "super::types::present", skip_serializing_if = "Option::is_none")] + #[schemars(with = "bool")] + pub thirds: Option, + #[serde(default, deserialize_with = "super::types::present", skip_serializing_if = "Option::is_none")] + #[schemars(with = "bool")] + pub safe_area: Option, + #[serde(default, deserialize_with = "super::types::present", skip_serializing_if = "Option::is_none")] + #[schemars(with = "bool")] + pub centre_mark: Option, +} + #[cfg(test)] #[path = "view_navigation_tests.rs"] mod tests; diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index ee7e7bdf5..e6a47af22 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -1057,6 +1057,9 @@ impl SolveApp { && !matches!(id, "view.render_select" | "view.next_tab" | "view.previous_tab") && (self.session.selection != selected_before || matches!(id, "select.set" | "select.clear" | "select.same_look")) { + if self.session.selection.is_empty() && render_workspace::active(self) { + render_workspace::selection_editor(self, &render_workspace::RenderSelection::Nothing); + } self.render_workspace.view.selection = if self.session.selection.is_empty() { render_workspace::RenderSelection::Nothing } else { @@ -1112,6 +1115,9 @@ impl SolveApp { if id == "appearance.favorite" { render_workspace::assign::favorite_applied(self, v); } + if id == "view.render_frame" { + render_workspace::shot::apply_frame(self, v); + } if id == "view.render_select" { use render_workspace::RenderSelection; let selected = match v.get("kind").and_then(Value::as_str) { @@ -1125,6 +1131,7 @@ impl SolveApp { Some("shot") => RenderSelection::Shot(v.get("id").and_then(Value::as_str).unwrap_or_default().into()), _ => RenderSelection::Nothing, }; + render_workspace::selection_editor(self, &selected); self.render_workspace.view.selection = selected; } if id == "view.layout" { diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs index 7cc725e58..606057ba9 100644 --- a/crates/ui-egui/src/render_workspace.rs +++ b/crates/ui-egui/src/render_workspace.rs @@ -48,6 +48,9 @@ mod materials; #[path = "render_workspace_setups.rs"] mod setups; +#[path = "render_workspace_shot.rs"] +pub(crate) mod shot; + #[path = "render_workspace_shots.rs"] pub(crate) mod shots; @@ -277,10 +280,21 @@ pub enum RenderSelection { Check, } +/// Selection-driven homes introduced by E1/E7; remaining editors retain their adapters. +pub(crate) fn selection_editor(app: &mut SolveApp, selection: &RenderSelection) { + app.render_workspace.view.inspector.page = match selection { + RenderSelection::Nothing => inspector::Page::Scene, + RenderSelection::Shot(_) => inspector::Page::Camera, + RenderSelection::Output => inspector::Page::Output, + _ => return, + }; +} + /// Small per-document editor state; GPU uploads and host capabilities stay outside tabs. #[derive(Clone, Debug)] pub struct ViewState { pub(crate) assign: assign::State, + pub(crate) frame: shot::Frame, job_shot: Option, save_shot_name: Option, pub name: String, @@ -345,6 +359,7 @@ impl Default for ViewState { Self { assign: assign::State::default(), job_shot: None, + frame: Default::default(), save_shot_name: None, name: "Studio".into(), selection: RenderSelection::Nothing, @@ -584,6 +599,9 @@ pub fn enter(app: &mut SolveApp, render: bool) -> Result<(), String> { app.render_workspace.design_camera = Some((app.cam, app.ui.perspective)); app.ui.tab = "RENDER".into(); select_stage(app, app.render_workspace.view.stage.key()); + if app.render_workspace.view.selection == RenderSelection::Nothing { + selection_editor(app, &RenderSelection::Nothing); + } let scene = solidcraft_engine::product_scene::extract(&app.session).map_err(|e| e.to_string())?; if !scene.bounds.is_empty() { app.fit_bounds(scene.bounds); @@ -1835,8 +1853,10 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { show_result(app, ui); return; } - let rect = ui.max_rect(); - app.viewport.rect = Some(rect); + let viewport = ui.max_rect(); + app.viewport.rect = Some(viewport); + // Framing uses the output camera's own aspect, including navigation and picking. + let rect = shot::preview_rect(app, viewport).unwrap_or(viewport); crate::viewport::refresh_layout(app, ui.ctx()); let response = ui.interact(rect, ui.id().with("render_preview"), Sense::click_and_drag()); if !environment::ring_input(app, ui, rect, &response) { @@ -1881,7 +1901,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { app.viewport.hover = None; } let bg = app.render_workspace.view.draft.background; - ui.painter().rect_filled(rect, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2])); + ui.painter().rect_filled(viewport, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2])); let result = (|| -> Result<(), String> { if app.viewport.gpu.is_none() { return Err(crate::i18n::tr("render.error_gpu_preview").into()); @@ -1980,8 +2000,9 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { if let Err(error) = result { preview_error(app, ui, rect, &error); } - crate::viewport::axis_view(app, ui, rect); - crate::navigation_bar_view::show(app, ui, rect); + 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. @@ -2081,6 +2102,8 @@ pub(crate) fn start_interactive(app: &mut SolveApp, id: &str) -> bool { && app.render_workspace.view.selection == RenderSelection::Wear { let _ = app.run("view.render_select", json!({"kind":"nothing"})); + // Clearing semantic focus routes to Scene; retain the explicit Advanced destination. + app.render_workspace.view.inspector.page = inspector::Page::Appearance; } handled } diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs index f54b319a3..d3048d9c3 100644 --- a/crates/ui-egui/src/render_workspace_inspector.rs +++ b/crates/ui-egui/src/render_workspace_inspector.rs @@ -96,12 +96,10 @@ pub(super) struct View { pub page: Page, reveal: Option<&'static str>, pending: Option, + #[cfg(test)] shot_name: String, pub checked: Option, scene_info: Option, - ground_margin: f64, - ground_gap: f64, - ground_color: [f64; 3], appearance: Appearance, selection_appearance: selection_appearance::View, pub(super) resolution: Resolution, @@ -191,12 +189,10 @@ impl Default for View { page: Page::Scene, reveal: None, pending: None, + #[cfg(test)] shot_name: String::new(), checked: None, scene_info: None, - ground_margin: 1.0, - ground_gap: 0.1, - ground_color: [0.18; 3], appearance: Appearance::default(), selection_appearance: Default::default(), resolution: Resolution::default(), @@ -224,6 +220,7 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { let page = selected_page(app); let output = !wear && matches!(page, Page::Output | Page::Sampling | Page::Effects | Page::Diagnostics); let appearance_editor = !wear && page == Page::Appearance; + let standalone = !wear && (page == Page::Scene || (page == Page::Camera && super::shot::selected(app).is_some())); let selection_appearance = appearance_editor && !app.session.selection.is_empty(); let title = if wear { app.tr("render.wear_title").to_string() @@ -237,6 +234,8 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { _ => None, }) .unwrap_or_else(|| app.tr("render.inspector").to_owned()) + } else if standalone { + super::shot::selected(app).filter(|_| page == Page::Camera).map(str::to_owned).unwrap_or_else(|| app.tr("render.page_scene").to_string()) } else { app.tr(if page == Page::Diagnostics { "render.children.check" @@ -280,7 +279,7 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { } }, |ui| { - if !appearance_editor && !output { + if !appearance_editor && !output && !standalone { header(app, ui); ui_kit::Panel::pinned_footer(ui, "render_job_footer", 4, |ui| { ui.separator(); @@ -306,7 +305,7 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { setups::refresh_dirty(app); return; } - if !appearance_editor && !output { + if !appearance_editor && !output && !standalone { ui_kit::text(ui, app.tr(page.key()), ui_kit::Text::Heading(page.key())); } match page { @@ -315,13 +314,20 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { Page::Effects => super::effects::output_controls(app, ui), Page::Lighting => lighting_controls(app, ui), Page::Environment | Page::Background => super::environment::editor(app, ui), - Page::Camera => camera_controls(app, ui), + Page::Camera => { + if let Some(shot) = super::shot::selected(app).map(str::to_owned) { + super::shot::editor(app, ui, &shot); + } else { + camera_controls(app, ui); + } + } Page::Output => output_editor(app, ui), Page::Sampling => sampling_editor(app, ui), Page::Diagnostics => check_editor(app, ui), #[cfg(test)] Page::All => { ui_kit::text(ui, app.tr("render.all_controls_help"), ui_kit::Text::Note("render.all_controls_help")); + shot_controls(app, ui); camera_actions(app, ui); let title = app.tr("render.page_camera").to_string(); ui_kit::section(ui, "render_all_camera", &title, false, |ui| camera_controls(app, ui)); @@ -443,6 +449,9 @@ fn perform_action(app: &mut SolveApp, action: PendingAction) -> Result<(), Strin app.render_workspace.view.name = app.session.doc.render.setups.keys().next().cloned().unwrap_or_else(|| "Studio".into()); setups::load(app); } + if matches!(&app.render_workspace.view.selection, super::RenderSelection::Shot(selected) if selected == &name) { + app.run("view.render_select", json!({"kind":"nothing"}))?; + } } } Ok(()) @@ -498,53 +507,109 @@ fn scene_controls(app: &mut SolveApp, ui: &mut egui::Ui) { let label = app.tr("render.children.method").to_string(); ui_kit::row(ui, &label, |ui| super::method_dropdown(app, ui)); gpu_status(app, ui); - browse_button(app, ui, "native_scenes", "render.browse_native_scenes"); - browse_button(app, ui, "scenes", "render.browse_scene_specs"); - physical_stage_controls(app, ui); - shot_controls(app, ui); -} -fn physical_stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) { - let title = app.tr("render.passive_stage").to_string(); - reveal_section(app, ui, "render_ground_details"); - ui_kit::section(ui, "render_ground_details", &title, false, |ui| { - ui.label(app.tr("render.ground_margin")); - ui_kit::number_field(ui, &mut app.render_workspace.view.inspector.ground_margin, 0.0..=10.0, 0.05, " x"); - ui.label(app.tr("render.ground_gap")); - ui_kit::number_field(ui, &mut app.render_workspace.view.inspector.ground_gap, 0.0001..=1000.0, 0.01, " mm"); - let label = app.tr("render.ground_linear_rgb").to_string(); - vector(ui, &label, &mut app.render_workspace.view.inspector.ground_color, 0.0..=1.0, 0.01); - let saved = setups::snapshot(app); - if ui_kit::button( - ui, - app.tr("render.ground_apply"), - ui_kit::Button::Enabled(saved.is_ok() && app.render_workspace.view.method != ImageMethod::Raster), - ) - .clicked() - && let Ok(set) = saved - { - let v = &app.render_workspace.view.inspector; - let request = json!({"name":app.render_workspace.view.name,"set":set,"margin_fraction":v.ground_margin,"gap_mm":v.ground_gap,"reflectance_linear":v.ground_color,"replace_stage":true}); - library::review::command(app, "render.stage.ground", request); - } - ui_kit::text(ui, app.tr("render.physical_background_help"), ui_kit::Text::Note("render.physical_background_help")); - for (kind, key) in [("floor_wall", "render.physical_floor_wall"), ("cyclorama", "render.physical_cyclorama")] { - let set = setups::snapshot(app); - let button = - ui_kit::button(ui, app.tr(key), ui_kit::Button::Enabled(set.is_ok() && app.render_workspace.view.method != ImageMethod::Raster)); - crate::scenario::publish_target(&format!("render:stage-{kind}"), button.rect); - if button.clicked() - && let Ok(set) = set - { - let v = &app.render_workspace.view.inspector; - let p = json!({"name":app.render_workspace.view.name,"set":set,"kind":kind,"expected_revision":app.session.revision, - "replace_stage":true,"reflectance_linear":v.ground_color}); - library::review::command(app, "render.stage.backdrop", p); + let title = app.tr("render.scene_stages").to_string(); + ui_kit::section(ui, "render_scene_stages", &title, true, |ui| { + let view = &app.render_workspace.view; + let overrides = app.session.doc.render.setups.get(&view.name).map_or(0, |s| s.optics.len().saturating_add(s.surfaces.len())); + let looks = super::scene::groups(app).iter().filter(|g| g.look.is_some()).count(); + let look = crate::i18n::format("render.scene_look_summary", &[("looks", &looks.to_string()), ("overrides", &overrides.to_string())]); + let light = crate::i18n::format( + "render.scene_light_summary", + &[("environment", &super::scene::environment(app).0), ("lights", &super::scene::light_types(app).len().to_string())], + ); + let lens = if app.cam.fov > 0.0 { format!("{:.0}°", app.cam.fov.to_degrees()) } else { app.tr("render.stage_orthographic").to_string() }; + let aspect = super::shot::aspect_label(app, &view.draft); + let frame = format!("{} · {lens} · {aspect}", view.name); + let format = if view.studio.export_exr { "EXR" } else { "PNG" }; + let output = format!("{} × {} · {format} · {}", view.draft.width, view.draft.height, app.tr(view.method.label())); + for (stage, summary, icon) in [ + (super::Stage::Look, look, "appearance"), + (super::Stage::Light, light, "environment_map"), + (super::Stage::Frame, frame, "camera"), + (super::Stage::Output, output, "export"), + ] { + let response = ui_kit::tree_row( + ui, + ui.id().with(("scene_stage", stage.key())), + &ui_kit::Row { compact: true, label: app.tr(stage.label()), secondary: &summary, icon, ..Default::default() }, + ); + if let Some(rect) = response.rect { + crate::scenario::publish_target(&format!("render:scene:{}", stage.key()), rect); + } + if response.clicked { + scene_stage(app, stage); } } - library::stage_content(app, ui); + }); + let title = app.tr("render.scene_ready").to_string(); + ui_kit::section(ui, "render_scene_ready", &title, true, |ui| { + let state = match &app.render_workspace.view.inspector.checked { + Some(check) if check.current(app) && super::image_params(app).as_ref().ok() == Some(&check.request) => crate::i18n::format( + "render.scene_check_passed", + &[("notes", &check.reply.get("warnings").and_then(Value::as_array).map_or(0, Vec::len).to_string())], + ), + Some(_) => app.tr("render.scene_check_stale").to_string(), + None => app.tr("render.scene_check_unchecked").to_string(), + }; + ui.horizontal_wrapped(|ui| { + ui_kit::text(ui, &state, ui_kit::Text::Inline); + let response = ui_kit::button(ui, app.tr("render.scene_open_check"), ui_kit::Button::Normal); + crate::scenario::publish_target("render:scene:open-check", response.rect); + if response.clicked() { + app.start("render.status"); + } + }); + if app.render_workspace.view.method == ImageMethod::GpuRaytrace && !matches!(app.render_workspace.path_host, super::PathHost::Ready(_)) { + gpu_status(app, ui); + } else { + let state = super::ribbon::action_ready(app, "render.start"); + let text = state.err().unwrap_or_else(|| { + crate::i18n::format("render.scene_renderer_ready", &[("renderer", app.tr(app.render_workspace.view.method.label()))]) + }); + ui_kit::text(ui, &text, ui_kit::Text::Note("render:scene:renderer")); + } + ui.horizontal_wrapped(|ui| { + for (id, label, command, primary) in + [("check", "render.scene_check_now", "render.preflight", false), ("render", "render.frame_render_shot", "render.start", true)] + { + let ready = super::ribbon::action_ready(app, command); + let response = ui_kit::icon_label_action(ui, app.tr(label), None, ready.is_ok(), primary); + crate::scenario::publish_target(&format!("render:scene:{id}"), response.rect); + if let Err(reason) = ready { + response.clone().on_disabled_hover_text(reason); + } + if response.clicked() + && let Err(error) = super::ribbon::perform_job(app, command) + { + app.set_status(error, true); + } + } + }); + let label = crate::i18n::format("render.scene_all_shots", &[("count", &app.session.doc.render.setups.len().to_string())]); + let response = ui_kit::button(ui, &label, ui_kit::Button::Enabled(false)); + crate::scenario::publish_target("render:scene:all-shots", response.rect); + ui_kit::text(ui, app.tr("render.scene_batch_reason"), ui_kit::Text::Note("render.scene_batch_reason")); + }); + let title = app.tr("render.scene_reminders").to_string(); + ui_kit::section(ui, "render_scene_reminders", &title, true, |ui| { + ui_kit::text(ui, app.tr("render.scene_reminder"), ui_kit::Text::Note("render.scene_preserves_design")); }); } +fn scene_stage(app: &mut SolveApp, stage: super::Stage) { + let name = app.render_workspace.view.name.clone(); + let _ = app.run("view.render_stage", json!({"stage":stage.key()})); + let params = match stage { + super::Stage::Look => json!({"kind":"nothing"}), + super::Stage::Light => json!({"kind":"environment"}), + super::Stage::Frame if app.session.doc.render.setups.contains_key(&name) => json!({"kind":"shot","id":name}), + super::Stage::Frame => json!({"kind":"nothing"}), + super::Stage::Output => json!({"kind":"output"}), + }; + let _ = app.run("view.render_select", params); + app.render_workspace.view.inspector.page = stage.page(); +} +#[cfg(test)] fn shot_controls(app: &mut SolveApp, ui: &mut egui::Ui) { let title = app.tr("render.shot_manager").to_string(); reveal_section(app, ui, "render_shot_manager"); diff --git a/crates/ui-egui/src/render_workspace_inspector_tests.rs b/crates/ui-egui/src/render_workspace_inspector_tests.rs index ab2914bfa..9c19d9836 100644 --- a/crates/ui-egui/src/render_workspace_inspector_tests.rs +++ b/crates/ui-egui/src/render_workspace_inspector_tests.rs @@ -26,6 +26,232 @@ fn reveal_inspector_target(h: &mut Harness, target: &str) -> egui::Rect { } panic!("inspector target {target} is still clipped"); } + +fn ordered_sections(keys: &[&str], app: &SolveApp) { + let mut bottom = f32::NEG_INFINITY; + for key in keys { + let rect = crate::scenario::rect_of(&format!("dialog:section:{}", app.tr(key))).unwrap(); + assert!(rect.top() >= bottom, "{key} must follow the previous section"); + bottom = rect.bottom(); + } +} + +#[test] +fn render_workspace_shot_and_scene_widgets_fit_inspector_content_width() { + let mut h = fixture(); + setups::save(&mut h.app).unwrap(); + let name = h.app.render_workspace.view.name.clone(); + super::super::shot::choose_aspect(&mut h.app, &name, 0).unwrap(); + h.app.cam.target = solidcraft_engine::geom::Vec3::new(-18.0, 125.5, -18.0); + let ctx = crate::fonts::test_context(); + let mut textures = std::collections::HashMap::new(); + for width in [350.0, 320.0] { + for editor in ["scene", "raster", "cpu_raytrace", "gpu_path", "orthographic"] { + if editor != "scene" { + h.app.cam.fov = if editor == "orthographic" { 0.0 } else { 0.6 }; + let job = if editor == "orthographic" { "raster" } else { editor }; + let mut job = json!({"method":job}); + if editor == "gpu_path" { + job["options"] = json!({"lens":h.app.render_workspace.view.studio.lens}); + } + let patch = json!({"job":job,"camera":h.app.cam}); + super::super::shot::edit_settings(&mut h.app, &name, patch).unwrap(); + h.app.cam.yaw += 0.1; // Include the changed-camera banner and enabled Update/Revert. + } + let before = h.app.session.doc.to_json(); + let content = egui::Rect::from_min_size(egui::pos2(8.0, 8.0), egui::vec2(width, 1600.0)); + let mut widgets = Vec::new(); + for frame in 0..3 { + crate::scenario::clear_handles(); + let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(content.expand(8.0)), ..Default::default() }, |ui| { + ui.scope_builder(egui::UiBuilder::new().max_rect(content), |ui| { + ui.painter().rect_filled(content, 0.0, crate::theme::Tokens::get().dialog_body); + ui_kit::scope(ui, |ui| { + let preceding: std::collections::HashSet<_> = ctx.viewport(|vp| { + vp.this_pass.widgets.layers().flat_map(|(_, widgets)| widgets.iter().map(|widget| widget.id)).collect() + }); + if editor == "scene" { + scene_controls(&mut h.app, ui); + } else { + super::super::shot::editor(&mut h.app, ui, &name); + } + widgets = ctx.viewport(|vp| { + vp.this_pass + .widgets + .layers() + .flat_map(|(_, widgets)| widgets.iter().filter(|widget| !preceding.contains(&widget.id)).copied()) + .collect() + }); + }); + }); + }); + ui_kit::test_textures_update(&mut textures, &output.textures_delta); + output.textures_delta.clear(); + for shape in &output.shapes { + if let egui::Shape::Text(text) = &shape.shape + && [h.app.tr("render.perspective"), h.app.tr("render.stage_orthographic"), h.app.tr("render.shot_distance")] + .contains(&text.galley.text()) + { + assert!(!text.galley.elided, "{editor} at {width} pt: {} is truncated", text.galley.text()); + let rect = egui::Rect::from_min_size(text.pos, text.galley.size()); + assert!(shape.clip_rect.expand(1.0).contains_rect(rect), "{} is clipped: {rect:?}", text.galley.text()); + } + } + if frame == 2 + && width == 350.0 + && let Some(dir) = std::env::var_os("SOLIDCRAFT_SHOT_LAYOUT_EVIDENCE") + { + std::fs::create_dir_all(&dir).unwrap(); + ui_kit::test_raster(&ctx, output.shapes, output.pixels_per_point, content, &textures) + .save(std::path::Path::new(&dir).join(format!("{editor}.png"))) + .unwrap(); + } + } + assert!(widgets.len() > 10, "must inspect actual editor widgets"); + for widget in widgets { + assert!( + widget.rect.left() >= content.left() - 0.5 && widget.rect.right() <= content.right() + 0.5, + "{editor} at {width} pt: widget {:?} extends outside {content:?}: {:?}", + widget.id, + widget.rect + ); + } + if editor != "scene" { + let cells = crate::scenario::rects(&format!("dialog:widget:{}", h.app.tr("render.shot_target"))); + assert_eq!(cells.len(), 3); + assert!(cells.windows(2).all(|pair| (pair[0].1.width() - pair[1].1.width()).abs() < 0.5)); + } + assert_eq!(h.app.session.doc.to_json(), before, "layout must not edit saved intent"); + } + } +} + +#[test] +fn render_workspace_scene_overview_selection_order_links_and_readiness_are_read_only() { + let mut h = fixture(); + h.call("ui.resize", json!({"width":1440,"height":1600})); + setups::save(&mut h.app).unwrap(); + h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap(); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + h.frames(3); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Scene); + ordered_sections(&["render.scene_stages", "render.scene_ready", "render.scene_reminders"], &h.app); + let mut bottom = f32::NEG_INFINITY; + for id in ["look", "light", "frame", "output"] { + let rect = crate::scenario::rect_of(&format!("render:scene:{id}")).unwrap(); + assert!(rect.top() >= bottom); + bottom = rect.bottom(); + } + for id in ["open-check", "check", "render", "all-shots"] { + assert!(crate::scenario::rect_of(&format!("render:scene:{id}")).is_some()); + } + assert!(crate::scenario::rect_of("dialog:note:render.scene_batch_reason").is_some()); + h.step(&json!({"click":{"handle":"render:scene:frame"}})).unwrap(); + assert!(matches!(h.app.render_workspace.view.selection, super::super::RenderSelection::Shot(_))); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Camera); + h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap(); + h.frames(2); + h.step(&json!({"click":{"handle":"render:scene:output"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Output); + h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap(); + h.frames(2); + h.step(&json!({"click":{"handle":"render:scene:open-check"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Diagnostics); + assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Check); + assert!(crate::scenario::rect_of("render:check").is_some()); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.undo.len(), undo); + assert!(h.app.render_workspace.view.job.is_none()); +} + +#[test] +fn render_workspace_shot_e7_order_disabled_reasons_output_link_and_confirm_remove() { + let mut h = fixture(); + h.call("ui.resize", json!({"width":1600,"height":1800})); + setups::save(&mut h.app).unwrap(); + let name = h.app.render_workspace.view.name.clone(); + h.app.run("view.render_select", json!({"kind":"shot","id":name})).unwrap(); + let before = h.app.session.doc.to_json(); + h.frames(3); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Camera); + assert!(crate::scenario::rect_of("render:job-footer").is_none(), "Shot owns its actions"); + assert!(crate::scenario::rect_of("dialog:editor_footer").is_none(), "Appearance footer stays in Appearance"); + let inspector = crate::scenario::rect_of("render:inspector").unwrap(); + let header = crate::scenario::rect_of("render:inspector:header").unwrap(); + assert!(inspector.contains_rect(header)); + assert!(h.widget(&name).is_some(), "selected Shot names the inspector"); + ordered_sections(&["render.page_camera", "render.shot_lens", "render.shot_exposure_section", "render.stage_frame"], &h.app); + for key in ["render.shot_lens_gpu_reason", "render.shot_exposure_reason", "render.shot_selection_reason"] { + assert!(crate::scenario::rect_of(&format!("dialog:note:{key}")).is_some(), "{key}"); + } + for id in ["name", "update", "revert", "duplicate", "remove", "output", "distance", "look-selection"] { + assert!(crate::scenario::rect_of(&format!("render:shot:{id}")).is_some(), "{id}"); + } + assert!(crate::scenario::rect_of("render:shot:width").is_none(), "size belongs in Output"); + assert_eq!(h.app.session.doc.to_json(), before); + h.step(&json!({"click":{"handle":"render:shot:remove"}})).unwrap(); + assert!(confirmation_open(&h.app)); + assert_eq!(h.app.session.doc.to_json(), before); + h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap(); + assert!(!confirmation_open(&h.app)); + assert_eq!(h.app.session.doc.to_json(), before, "cancelling removal keeps the Shot"); + h.step(&json!({"click":{"handle":"render:shot:output"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, super::super::RenderSelection::Output); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Output); +} + +#[test] +fn render_workspace_shot_camera_controls_save_undo_and_refuse_hostile_values() { + let mut h = fixture(); + setups::save(&mut h.app).unwrap(); + let name = h.app.render_workspace.view.name.clone(); + let before = h.app.session.doc.to_json(); + let camera = solidcraft_engine::render::Camera { yaw: 0.7, roll: 0.2, distance: 123.0, ..h.app.cam }; + super::super::shot::set_camera(&mut h.app, &name, camera).unwrap(); + assert_eq!(h.app.cam, camera); + assert_eq!(h.app.session.doc.render.setups[&name].camera, camera); + h.app.run("edit.undo", json!({})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); + for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -1.0, 0.0, f64::MAX] { + let camera = solidcraft_engine::render::Camera { distance: value, ..camera }; + assert!(super::super::shot::set_camera(&mut h.app, &name, camera).is_err()); + assert_eq!(h.app.session.doc.to_json(), before); + } +} + +#[test] +fn render_workspace_shot_lens_saves_only_lens_and_orthographic_keeps_faded_controls() { + use solidcraft_engine::doc::render_settings::RenderJob; + let mut h = fixture(); + h.call("ui.resize", json!({"width":1600,"height":1800})); + let name = "Lens shot"; + let camera = solidcraft_engine::render::Camera { fov: 0.6, ..h.app.cam }; + h.app + .run("render.settings.set", json!({"name":name,"set":{"camera":camera,"job":{"method":"gpu_path","options":{"samples":128,"seed":42}}}})) + .unwrap(); + h.app.run("render.camera.set", json!({"camera":camera})).unwrap(); + h.app.follow_view_request(false); + h.app.run("view.render_select", json!({"kind":"shot","id":name})).unwrap(); + let before = h.app.session.doc.render.setups[name].clone(); + let undo = h.app.session.undo.len(); + h.frames(3); + h.step(&json!({"widget":h.app.tr("render.shot_dof")})).unwrap(); + let mut expected = before.clone(); + if let Some(RenderJob::GpuPath { options, .. }) = &mut expected.job { + options.lens = Some(h.app.render_workspace.view.studio.lens); + } + assert_eq!(h.app.session.doc.render.setups[name], expected); + assert_eq!(h.app.session.undo.len(), undo + 1); + h.app.run("edit.undo", json!({})).unwrap(); + assert_eq!(h.app.session.doc.render.setups[name], before); + h.app.cam.fov = 0.0; + h.frames(3); + for key in ["render.shot_fov_reason", "render.shot_lens_perspective_reason"] { + assert!(crate::scenario::rect_of(&format!("dialog:note:{key}")).is_some(), "{key}"); + } + assert_eq!(h.app.session.doc.render.setups[name], before, "opening must not change saved intent or method"); +} #[test] fn native_inspector_keeps_stage_actions_on_screen_and_output_has_no_pinned_footer() { for dark in [false, true] { @@ -48,6 +274,8 @@ fn native_inspector_keeps_stage_actions_on_screen_and_output_has_no_pinned_foote assert!(h.app.render_workspace.view.job.is_none()); assert!(h.app.render_workspace.view.completed.is_none()); if page == Page::Appearance { + let footer = crate::scenario::rect_of("dialog:editor_footer").unwrap(); + assert!(inspector.contains_rect(footer), "Appearance footer outside inspector: {inspector:?} {footer:?}"); assert!(crate::scenario::rect_of("render:job-footer").is_none()); continue; } @@ -56,15 +284,19 @@ fn native_inspector_keeps_stage_actions_on_screen_and_output_has_no_pinned_foote let bar = crate::scenario::rect_of("render:stage_bar").unwrap(); for name in ["render:stage:render.start", "render:stage:render.cancel"] { let action = crate::scenario::rect_of(name).unwrap(); - assert!(bar.contains_rect(action), "{name} outside stage bar"); + assert!(bar.contains_rect(action), "{name} outside stage bar: {bar:?} {action:?}"); + } + } else if page == Page::Scene { + let stages = crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr("render.scene_stages"))).unwrap(); + assert!(inspector.contains_rect(stages), "Scene stages outside inspector: {inspector:?} {stages:?}"); + assert!(crate::scenario::rect_of("render:job-footer").is_none()); + } else { + let footer = crate::scenario::rect_of("render:job-footer").unwrap(); + assert!(inspector.contains_rect(footer), "footer outside inspector at {page:?}: {inspector:?} {footer:?}"); + for name in ["render:check", "render:start", "render:cancel", "render:export"] { + let target = crate::scenario::rect_of(name).unwrap(); + assert!(footer.contains_rect(target), "{name} clipped at {page:?}"); } - continue; - } - let footer = crate::scenario::rect_of("render:job-footer").unwrap(); - assert!(inspector.contains_rect(footer), "footer outside inspector at {page:?}: {inspector:?} {footer:?}"); - for name in ["render:check", "render:start", "render:cancel", "render:export"] { - let target = crate::scenario::rect_of(name).unwrap(); - assert!(footer.contains_rect(target), "{name} clipped at {page:?}"); } } } @@ -572,10 +804,10 @@ fn contextual_scope_notes_wrap_with_native_tokens_instead_of_clipping() { h.frames(3); let rect = crate::scenario::rect_of("dialog:note:render.scene_preserves_design").unwrap(); let inspector = crate::scenario::rect_of("render:inspector").unwrap(); - let footer = crate::scenario::rect_of("render:job-footer").unwrap(); assert!(rect.height() > Tokens::get().font_small + Tokens::get().space_8, "long scope notice must have more than one line"); assert!(inspector.contains_rect(rect)); - assert!(rect.bottom() < footer.top()); + assert!(rect.bottom() < inspector.bottom()); + assert!(crate::scenario::rect_of("render:job-footer").is_none()); } #[test] @@ -628,6 +860,47 @@ fn native_composition_review_actions_are_visible_in_shared_dialog() { } } +#[test] +fn native_composition_review_actions_are_visible_before_auxiliary_resource_details() { + for dark in [false, true] { + let mut h = fixture(); + h.call("ui.set", json!({"dark":dark})); + super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace); + setups::save(&mut h.app).unwrap(); + library::open_category(&mut h.app, "native_scenes"); + h.frames(3); + let before = h.app.session.doc.to_json(); + let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()); + h.step(&json!({"click":{"handle":"render:light:NATIVE-STUDIO-002"}})).unwrap(); + let library = h.app.shell.workspace_panels.get("render:appearances").unwrap().0; + let review = crate::scenario::rect_of("render:light:review").unwrap(); + let note = crate::scenario::rect_of("catalog:footer").unwrap(); + assert!(library.contains_rect(review), "the review action must remain inside the library card: {library:?} {review:?}"); + assert!(review.bottom() <= note.top(), "the review action must precede supplementary prose"); + h.step(&json!({"click":{"handle":"render:light:review"}})).unwrap(); + h.frames(3); + let card = crate::scenario::rect_of("review:sphere").unwrap(); + let replaces = crate::scenario::rect_of("dialog:note:review:replaces").unwrap(); + let kept = crate::scenario::rect_of("dialog:note:review:kept").unwrap(); + let ack = crate::scenario::rect_of("render:review:acknowledge").unwrap(); + assert!(card.bottom() <= replaces.top()); + assert!(replaces.bottom() <= kept.top()); + assert!(kept.bottom() <= ack.top()); + let apply = crate::scenario::rect_of("dialog:ok").unwrap(); + assert!(ack.bottom() <= apply.top()); + let dialog = crate::scenario::rect_of("dialog:window").unwrap(); + for (name, rect) in [("acknowledge", ack), ("apply", apply)] { + assert!(dialog.contains_rect(rect), "{name} must remain inside the review dialog: {dialog:?} {rect:?}"); + assert!(h.ctx.content_rect().contains_rect(rect), "{name} must remain on screen: rect={rect:?}, dark={dark}"); + } + assert!(!h.app.render_workspace.view.library.review.as_ref().unwrap().acknowledged); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history); + assert!(h.app.render_workspace.view.job.is_none()); + assert!(h.app.render_workspace.view.completed.is_none()); + } +} + #[test] fn ribbon_navigation_reuses_inspector_and_preserves_exact_unsaved_intent() { let mut h = fixture(); @@ -986,7 +1259,9 @@ fn wear_selection_precedes_output_page_and_appearance_selection_chrome() { assert!(crate::scenario::rect_of("render:job-footer").is_none()); assert!(crate::scenario::rect_of("render:appearance:close").is_none()); h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap(); - // Select a body again to test recovery of the ordinary Appearance header. + // Clearing semantic focus opens Scene; choose Appearance to test its header recovery. + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Scene); + h.app.render_workspace.view.inspector.page = Page::Appearance; h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }]; h.frames(3); assert_header(&h, "Subject"); diff --git a/crates/ui-egui/src/render_workspace_library.rs b/crates/ui-egui/src/render_workspace_library.rs index c08f8052e..6e31e1d1f 100644 --- a/crates/ui-egui/src/render_workspace_library.rs +++ b/crates/ui-egui/src/render_workspace_library.rs @@ -531,7 +531,7 @@ pub(super) fn card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) { fill_height: true, compact: crate::render_ui::compact(app, bounds.width()), editor: false, - enabled: stage != super::Stage::Frame, + enabled: true, header_actions: (stage == super::Stage::Look).then_some(&mut actions as &mut dyn FnMut(&mut egui::Ui)), }, &mut side, @@ -545,11 +545,8 @@ pub(super) fn card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) { } }), super::Stage::Light => light_panel(app, ui), + super::Stage::Frame => super::shot::presets(app, ui), super::Stage::Output => super::inspector::size_presets(app, ui), - super::Stage::Frame => { - let reason = app.tr("render.frame_presets_pending"); - ui_kit::text(ui, reason, ui_kit::Text::Note("render:stage-presets-pending")); - } }, ); let look_tab = usize::from(mode == 2); @@ -579,7 +576,7 @@ fn stage_title(stage: super::Stage) -> &'static str { match stage { super::Stage::Look => "render.appearances", super::Stage::Light => "render.studios_environments", - super::Stage::Frame => "render.frame_presets", + super::Stage::Frame => "render.stage_frame", super::Stage::Output => "render.size_presets", } } @@ -1555,6 +1552,7 @@ pub(super) fn stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) { let title = app.tr("render.passive_stage").to_string(); ui_kit::section(ui, "render_passive_stage", &title, false, |ui| stage_content(app, ui)); } +#[cfg(test)] pub(super) fn stage_content(app: &mut SolveApp, ui: &mut egui::Ui) { ui_kit::text(ui, app.tr("render.passive_stage_help"), ui_kit::Text::Note("render.passive_stage_help")); let stage = &app.render_workspace.view.draft.stage; @@ -1704,6 +1702,10 @@ mod studio_browser_tests { // available under Advanced when no model target is selected. h.app.run("select.clear", json!({})).unwrap(); h.frames(3); + // Clearing model selection opens Scene overview; inspect the resource again. + h.step(&json!({"click":{"handle":format!("render:library:{id}")}})).unwrap(); + h.frames(3); + assert_eq!(h.app.render_workspace.view.inspector.page, super::super::inspector::Page::Appearance); h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr("render.inspector_advanced"))}})).unwrap(); h.frames(3); h.step(&json!({"widget":h.app.tr("render.library_favorite")})).unwrap(); @@ -1804,7 +1806,7 @@ mod studio_browser_tests { for (stage, key) in [ ("look", "render.appearances"), ("light", "render.studios_environments"), - ("frame", "render.frame_presets"), + ("frame", "render.stage_frame"), ("output", "render.size_presets"), ] { h.app.run("view.render_stage", json!({"stage":stage})).unwrap(); diff --git a/crates/ui-egui/src/render_workspace_library_review.rs b/crates/ui-egui/src/render_workspace_library_review.rs index 3d0c1ad6a..082dc3d6e 100644 --- a/crates/ui-egui/src/render_workspace_library_review.rs +++ b/crates/ui-egui/src/render_workspace_library_review.rs @@ -114,6 +114,7 @@ pub(in crate::render_workspace) fn light(app: &mut SolveApp, view: &View, id: &s } } +#[cfg(test)] pub(in crate::render_workspace) fn command(app: &mut SolveApp, id: &str, params: Value) { let result = open(app, "stage", app.tr("render.passive_stage").into(), Value::Null, Apply::Command { id: id.into(), params }); if let Err(error) = result { @@ -283,6 +284,7 @@ pub(in crate::render_workspace) struct Removal { revision: u64, document: Weak, } +#[cfg(test)] pub(in crate::render_workspace) fn remove(app: &mut SolveApp, command: &str, params: Value) { app.render_workspace.view.library.removal = Some(Removal { command: command.into(), params, revision: app.session.revision, document: Arc::downgrade(&app.session.doc) }); diff --git a/crates/ui-egui/src/render_workspace_shot.rs b/crates/ui-egui/src/render_workspace_shot.rs new file mode 100644 index 000000000..23a2f5711 --- /dev/null +++ b/crates/ui-egui/src/render_workspace_shot.rs @@ -0,0 +1,511 @@ +//! Standalone Shot editor and transient frame composition. Commands own every edit. +use super::{RenderSelection, Stage, inspector}; +use crate::{SolveApp, theme::Tokens, ui_kit}; +use egui::{Rect, pos2, vec2}; +use serde_json::{Value, json}; +use solidcraft_engine::doc::render_settings::{RenderSettings, RenderSetup}; + +#[derive(Clone, Debug, Default)] +pub(crate) struct Frame { + aspect: Option, + pub(super) guides: ui_kit::FrameGuides, + name: Option<(String, String)>, + exposure: Option<(String, f64, f64)>, +} + +pub(crate) fn apply_frame(app: &mut SolveApp, request: &Value) { + let frame = &mut app.render_workspace.view.frame; + if let Some(aspect) = request.get("aspect").and_then(Value::as_str) { + frame.aspect = Some(aspect.into()); + } + for (key, value) in + [("thirds", &mut frame.guides.thirds), ("safe_area", &mut frame.guides.safe_area), ("centre_mark", &mut frame.guides.centre_mark)] + { + if let Some(request) = request.get(key).and_then(Value::as_bool) { + *value = request; + } + } +} + +pub(super) fn selected(app: &SolveApp) -> Option<&str> { + match &app.render_workspace.view.selection { + RenderSelection::Shot(name) if app.session.doc.render.setups.contains_key(name) => Some(name), + _ => None, + } +} + +const ASPECTS: [(&str, u32, u32, &str); 6] = [ + ("16:9", 1920, 1080, "render.frame_wide"), + ("3:2", 1620, 1080, "render.frame_photo"), + ("1:1", 1080, 1080, "render.frame_square"), + ("4:5", 864, 1080, "render.frame_portrait"), + ("9:16", 1080, 1920, "render.frame_tall"), + ("custom", 0, 0, "render.frame_custom"), +]; + +fn target(app: &SolveApp) -> String { + selected(app).unwrap_or(&app.render_workspace.view.name).to_owned() +} + +fn setup(app: &SolveApp, name: &str) -> RenderSetup { + app.session.doc.render.setups.get(name).cloned().unwrap_or_else(|| app.render_workspace.view.draft.clone()) +} + +pub(super) fn aspect_label(app: &SolveApp, setup: &RenderSetup) -> String { + ASPECTS.get(aspect_index(app, setup)).map_or_else( + || app.tr("render.frame_custom").to_string(), + |(key, ..)| if *key == "custom" { app.tr("render.frame_custom").to_string() } else { (*key).into() }, + ) +} + +fn aspect_index(app: &SolveApp, setup: &RenderSetup) -> usize { + if let Some(aspect) = &app.render_workspace.view.frame.aspect + && let Some(index) = ASPECTS.iter().position(|(key, ..)| *key == aspect) + { + return index; + } + ASPECTS.iter().position(|(_, w, h, _)| *w > 0 && u64::from(setup.width) * u64::from(*h) == u64::from(setup.height) * u64::from(*w)).unwrap_or(5) +} + +/// Patch only the requested saved fields; unrelated live drafts and the live camera survive. +pub(super) fn edit_settings(app: &mut SolveApp, name: &str, patch: Value) -> Result<(), String> { + app.run("render.settings.set", json!({"name":name,"set":patch}))?; + if name == app.render_workspace.view.name { + let saved = setup(app, name); + let view = &mut app.render_workspace.view; + for draft in std::iter::once(&mut view.draft).chain(view.clean_setup.iter_mut()) { + if patch.get("width").is_some() { + draft.width = saved.width; + } + if patch.get("height").is_some() { + draft.height = saved.height; + } + if patch.get("exposure_ev").is_some() { + draft.exposure_ev = saved.exposure_ev; + } + if patch.get("job").is_some() { + draft.job = saved.job.clone(); + } + if patch.get("camera").is_some() { + draft.camera = saved.camera; + } + } + app.render_workspace.revision = app.session.revision; + } + Ok(()) +} + +pub(super) fn choose_aspect(app: &mut SolveApp, name: &str, index: usize) -> Result<(), String> { + let Some((aspect, width, height, _)) = ASPECTS.get(index) else { return Err(app.tr("render.frame_invalid_aspect").into()) }; + if *width > 0 { + edit_settings(app, name, json!({"width":width,"height":height}))?; + } + app.run("view.render_frame", json!({"aspect":aspect}))?; + Ok(()) +} + +fn result(app: &mut SolveApp, action: Result<(), String>) { + if let Err(error) = action { + app.set_status(error, true); + } +} + +fn guides(app: &mut SolveApp, ui: &mut egui::Ui, editor: bool) { + let current = app.render_workspace.view.frame.guides; + for (key, label, mut checked) in [ + ("thirds", if editor { "render.frame_rule_thirds" } else { "render.frame_thirds" }, current.thirds), + ("safe_area", "render.frame_safe_area", current.safe_area), + ("centre_mark", "render.frame_centre_mark", current.centre_mark), + ] { + let response = ui_kit::checkbox(ui, app.tr(label), &mut checked); + crate::scenario::publish_target(&format!("render:{}:{key}", if editor { "shot" } else { "frame" }), response.rect); + if response.changed() { + let _ = app.run("view.render_frame", json!({key:checked})); + } + } +} + +pub(super) fn presets(app: &mut SolveApp, ui: &mut egui::Ui) { + let name = target(app); + let current = setup(app, &name); + let selected = aspect_index(app, ¤t); + let title = app.tr("render.frame_aspect").to_string(); + ui_kit::section(ui, "render_frame_aspects", &title, true, |ui| { + let ids: Vec<_> = ASPECTS.iter().map(|(key, ..)| format!("render:frame:aspect:{key}")).collect(); + let tiles: Vec<_> = ASPECTS + .iter() + .enumerate() + .map(|(index, (key, w, h, _))| ui_kit::AspectTile { + id: ids.get(index).map(String::as_str).unwrap_or_default(), + label: if *key == "custom" { app.tr("render.frame_custom") } else { key }, + aspect: if *h == 0 { 1.5 } else { f64::from(*w) / f64::from(*h) }, + selected: index == selected, + }) + .collect(); + if let Some(index) = ui_kit::aspect_grid(ui, &tiles) { + let action = choose_aspect(app, &name, index); + result(app, action); + } + }); + let title = app.tr("render.frame_guides").to_string(); + ui_kit::section(ui, "render_frame_guides", &title, true, |ui| guides(app, ui, false)); +} + +pub(super) fn rename(app: &mut SolveApp, name: &str, new_name: &str) -> Result<(), String> { + app.run("render.shot.rename", json!({"name":name,"new_name":new_name,"expected_revision":app.session.revision}))?; + if app.render_workspace.view.name == name { + app.render_workspace.view.name = new_name.into(); + } + app.run("view.render_select", json!({"kind":"shot","id":new_name}))?; + Ok(()) +} + +pub(super) fn duplicate(app: &mut SolveApp, name: &str) -> Result<(), String> { + for number in 1..=32 { + let mut prefix = name.to_string(); + let mut destination = crate::i18n::format("render.frame_copy_name", &[("name", &prefix), ("number", &number.to_string())]); + while destination.len() > solidcraft_engine::doc::render_settings::MAX_SETUP_NAME_BYTES && prefix.pop().is_some() { + destination = crate::i18n::format("render.frame_copy_name", &[("name", &prefix), ("number", &number.to_string())]); + } + if !app.session.doc.render.setups.contains_key(&destination) { + app.run("render.shot.duplicate", json!({"name":name,"new_name":destination,"expected_revision":app.session.revision}))?; + return Ok(()); + } + } + Err(app.tr("render.frame_copy_limit").into()) +} + +pub(super) fn revert(app: &mut SolveApp, name: &str) -> Result<(), String> { + app.run("render.settings.apply", json!({"name":name}))?; + app.follow_view_request(false); + Ok(()) +} + +/// E7: saved camera, lens, exposure and frame in approved order. +pub(super) fn editor(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str) { + let Some(saved) = app.session.doc.render.setups.get(shot).cloned() else { return }; + if app.render_workspace.view.frame.name.as_ref().is_none_or(|(name, _)| name != shot) { + app.render_workspace.view.frame.name = Some((shot.into(), shot.into())); + } + let mut name = app.render_workspace.view.frame.name.as_ref().map(|(_, text)| text.clone()).unwrap_or_else(|| shot.into()); + let invalid = RenderSettings::validate_name(&name).is_err(); + let response = ui_kit::row(ui, app.tr("render.frame_name"), |ui| { + ui_kit::bounded_cell_editor(ui, ui.id().with(("shot_name", shot)), &mut name, "", invalid, 128) + }); + crate::scenario::publish_target("render:shot:name", response.rect); + let commit = response.lost_focus() || (response.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter))); + app.render_workspace.view.frame.name = Some((shot.into(), name.clone())); + if commit && name != shot { + let action = rename(app, shot, name.trim()); + result(app, action); + return; + } + let changed = super::shots::camera_modified(app, shot); + if changed { + ui_kit::banner(ui, ui_kit::AssistantTone::Warning, |ui| { + ui_kit::text(ui, app.tr("render.shots_camera_changed"), ui_kit::Text::Note("render.shots_camera_changed")); + }); + } + ui.horizontal_wrapped(|ui| { + let update = ui.add_enabled_ui(changed, |ui| ui_kit::primary_button(ui, app.tr("render.shots_update"))).inner; + crate::scenario::publish_target("render:shot:update", update.rect); + if update.clicked() { + let action = edit_settings(app, shot, json!({"camera":app.cam})); + result(app, action); + } + let response = ui_kit::button(ui, app.tr("render.shots_revert"), ui_kit::Button::Enabled(changed)); + crate::scenario::publish_target("render:shot:revert", response.rect); + if response.clicked() { + let action = revert(app, shot); + result(app, action); + } + for (id, icon, label, danger) in [("duplicate", "copy", "render.frame_duplicate", false), ("remove", "delete", "render.shot_remove", true)] { + let response = ui_kit::icon_action(ui, app.tr(label), icon, true, danger); + crate::scenario::publish_target(&format!("render:shot:{id}"), response.rect); + if response.clicked() { + if danger { + inspector::shot_row_action(app, shot.into(), "render.shot.remove"); + } else { + let action = duplicate(app, shot); + result(app, action); + } + } + } + }); + let title = app.tr("render.page_camera").to_string(); + ui_kit::section(ui, "render_shot_camera", &title, true, |ui| camera(app, ui, shot)); + let title = app.tr("render.shot_lens").to_string(); + ui_kit::section_method(ui, "render_shot_lens", &title, true, "GPU", |ui| lens(app, ui, shot, &saved)); + let title = app.tr("render.shot_exposure_section").to_string(); + ui_kit::section(ui, "render_shot_exposure", &title, true, |ui| exposure(app, ui, shot, &saved)); + let title = app.tr("render.stage_frame").to_string(); + ui_kit::section(ui, "render_shot_frame", &title, true, |ui| { + let index = aspect_index(app, &saved); + let mut chosen = None; + let labels: Vec<_> = ASPECTS.iter().map(|(_, _, _, key)| app.tr(key).to_string()).collect(); + ui_kit::row(ui, app.tr("render.frame_aspect"), |ui| { + let response = ui_kit::dropdown_menu(ui, "render_shot_aspect", labels.get(index).map(String::as_str).unwrap_or_default(), |ui| { + for (choice, label) in labels.iter().enumerate() { + if ui_kit::list_picker(ui, &format!("render:shot:aspect:{choice}"), label, choice == index).clicked() { + chosen = Some(choice); + ui.close(); + } + } + }); + crate::scenario::publish_target("render:shot:aspect", response.rect); + }); + if let Some(index) = chosen { + let action = choose_aspect(app, shot, index); + result(app, action); + } + guides(app, ui, true); + ui.horizontal_wrapped(|ui| { + ui_kit::text(ui, app.tr("render.shot_size"), ui_kit::Text::Inline); + ui_kit::text(ui, &format!("{} × {}", saved.width, saved.height), ui_kit::Text::Inline); + let response = ui_kit::button(ui, app.tr("render.shot_edit_output"), ui_kit::Button::Ghost); + crate::scenario::publish_target("render:shot:output", response.rect); + if response.clicked() { + let _ = app.run("view.render_select", json!({"kind":"output"})); + app.render_workspace.view.inspector.page = inspector::Page::Output; + } + }); + }); +} + +/// Controls save immediately; navigation alone keeps Update/Revert. +pub(super) fn set_camera(app: &mut SolveApp, shot: &str, camera: solidcraft_engine::render::Camera) -> Result<(), String> { + if !camera.is_valid() { + return Err(app.tr("render.shot_invalid_camera").into()); + } + edit_settings(app, shot, json!({"camera":camera}))?; + inspector::apply_camera_draft(app, camera) +} + +fn camera(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str) { + let mut camera = app.cam; + let mut projection = usize::from(camera.fov == 0.0); + // This short label can use the kit's base column, leaving both projection names visible. + if ui_kit::settings_form(ui, Tokens::get().form_label_width, |ui| { + ui_kit::row(ui, app.tr("render.frame_projection"), |ui| { + ui_kit::segmented( + ui, + &mut projection, + &[app.tr("render.perspective"), app.tr("render.stage_orthographic")], + ui_kit::Segments { compact: true, proportional: true, workspace_accent: true, ..Default::default() }, + ) + }) + }) { + camera.fov = if projection == 0 { 35f64.to_radians() } else { 0.0 }; + } + let mut fov = if projection == 0 { camera.fov.to_degrees() } else { 35.0 }; + ui.add_enabled_ui(projection == 0, |ui| { + let response = ui_kit::row(ui, app.tr("render.frame_fov"), |ui| { + ui_kit::slider(ui, &mut fov, 1.0..=150.0, ui_kit::Slider { format: |v| format!("{v:.0}°"), ..Default::default() }) + }); + if projection == 0 && response.changed() && (response.is_pointer_button_down_on() || response.has_focus()) { + camera.fov = fov.to_radians(); + } + }); + let bounds = crate::viewport::model_bounds(app); + let diagonal = bounds.diagonal(); + let size = if bounds.is_empty() || !diagonal.is_finite() { 1.0 } else { diagonal.max(0.000001) }; + let mut distance = camera.distance / size; + let suffix = app.tr("render.frame_distance_unit").to_owned(); + let response = ui_kit::row(ui, app.tr("render.shot_distance"), |ui| { + ui_kit::number_field(ui, &mut distance, (0.000001 / size)..=(1e9 / size), 0.01, &suffix) + }); + crate::scenario::publish_target("render:shot:distance", response.rect); + if response.changed() { + camera.distance = distance * size; + } + let mut target = [camera.target.x, camera.target.y, camera.target.z]; + ui_kit::row(ui, app.tr("render.shot_target"), |ui| { + ui_kit::number_fields(ui, &mut target, -1e9..=1e9, 0.1, ""); + }); + camera.target = solidcraft_engine::geom::Vec3::new(target[0], target[1], target[2]); + for (key, value) in [("camera.shot_yaw", &mut camera.yaw), ("camera.shot_pitch", &mut camera.pitch), ("camera.shot_roll", &mut camera.roll)] { + let mut degrees = value.to_degrees(); + if ui_kit::row(ui, app.tr(key), |ui| ui_kit::number_field(ui, &mut degrees, (-1e6f64).to_degrees()..=1e6f64.to_degrees(), 0.5, "°")).changed() + { + *value = degrees.to_radians(); + } + } + if camera != app.cam { + let action = set_camera(app, shot, camera); + result(app, action); + } + if projection != 0 { + ui_kit::text(ui, app.tr("render.shot_fov_reason"), ui_kit::Text::Note("render.shot_fov_reason")); + } + ui.horizontal_wrapped(|ui| { + if ui_kit::button(ui, app.tr("render.shot_frame_subject"), ui_kit::Button::Normal).clicked() { + let action = inspector::fit_subject(app).and_then(|()| set_camera(app, shot, app.cam)); + result(app, action); + } + let enabled = crate::viewport::selection_bounds(app).is_some(); + let response = ui_kit::button(ui, app.tr("render.shot_look_selection"), ui_kit::Button::Enabled(enabled)); + crate::scenario::publish_target("render:shot:look-selection", response.rect); + if response.clicked() { + let action = look_at_selection(app, shot); + result(app, action); + } + }); + if crate::viewport::selection_bounds(app).is_none() { + ui_kit::text(ui, app.tr("render.shot_selection_reason"), ui_kit::Text::Note("render.shot_selection_reason")); + } +} + +pub(super) fn look_at_selection(app: &mut SolveApp, shot: &str) -> Result<(), String> { + let bounds = crate::viewport::selection_bounds(app).ok_or_else(|| app.tr("render.shot_selection_reason").to_string())?; + set_camera(app, shot, solidcraft_engine::render::Camera { target: bounds.center(), ..app.cam }) +} + +fn lens(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str, saved: &RenderSetup) { + use solidcraft_engine::doc::render_settings::RenderJob; + let gpu = matches!(saved.job, Some(RenderJob::GpuPath { .. })); + let enabled = gpu && app.cam.fov > 0.0; + let lens = match &saved.job { + Some(RenderJob::GpuPath { options, .. }) => options.lens, + _ => None, + }; + let mut on = lens.is_some(); + let mut value = lens.unwrap_or(app.render_workspace.view.studio.lens); + let changed = ui + .add_enabled_ui(enabled, |ui| { + let mut changed = ui_kit::checkbox(ui, app.tr("render.shot_dof"), &mut on).changed(); + ui.add_enabled_ui(on, |ui| { + changed |= ui_kit::row(ui, app.tr("render.shot_aperture"), |ui| { + ui_kit::number_field(ui, &mut value.aperture_radius_mm, 0.0..=1e7, 0.1, " mm") + }) + .changed(); + changed |= ui_kit::row(ui, app.tr("render.shot_focus_distance"), |ui| { + ui_kit::number_field(ui, &mut value.focus_distance_mm, 1e-6..=1e9, 1.0, " mm") + }) + .changed(); + }); + changed + }) + .inner; + let reason = if !gpu { + Some("render.shot_lens_gpu_reason") + } else if !enabled { + Some("render.shot_lens_perspective_reason") + } else if !on { + Some("render.shot_lens_enable_reason") + } else { + None + }; + if let Some(key) = reason { + ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key)); + } + if changed && enabled { + let mut job = saved.job.clone(); + if let Some(solidcraft_engine::doc::render_settings::RenderJob::GpuPath { options, .. }) = &mut job { + options.lens = on.then_some(value); + } + let action = edit_settings(app, shot, json!({"job":job})); + if action.is_ok() && app.render_workspace.view.name == shot { + app.render_workspace.view.studio.lens_enabled = on; + app.render_workspace.view.studio.lens = value; + } + result(app, action); + } +} + +fn exposure(app: &mut SolveApp, ui: &mut egui::Ui, shot: &str, saved: &RenderSetup) { + let limit = if matches!(saved.job, Some(solidcraft_engine::doc::render_settings::RenderJob::CpuRaytrace { .. })) { 16.0 } else { 32.0 }; + let enabled = !matches!(saved.job, None | Some(solidcraft_engine::doc::render_settings::RenderJob::Raster { .. })); + if !enabled { + ui_kit::text(ui, app.tr("render.shot_exposure_reason"), ui_kit::Text::Note("render.shot_exposure_reason")); + } + ui.add_enabled_ui(enabled, |ui| { + if app.render_workspace.view.frame.exposure.as_ref().is_none_or(|(name, observed, _)| name != shot || *observed != saved.exposure_ev) { + app.render_workspace.view.frame.exposure = Some((shot.into(), saved.exposure_ev, saved.exposure_ev)); + } + let mut exposure = app.render_workspace.view.frame.exposure.as_ref().map_or(saved.exposure_ev, |(_, _, value)| *value); + let response = ui_kit::row(ui, app.tr("render.frame_exposure"), |ui| { + ui_kit::slider(ui, &mut exposure, -limit..=limit, ui_kit::Slider { format: |v| format!("{v:+.1} EV"), ..Default::default() }) + }); + crate::scenario::publish_target("render:shot:exposure", response.rect); + app.render_workspace.view.frame.exposure = Some((shot.into(), saved.exposure_ev, exposure)); + if exposure != saved.exposure_ev && !ui.input(|i| i.pointer.primary_down()) { + let action = edit_settings(app, shot, json!({"exposure_ev":exposure})); + if action.is_err() { + app.render_workspace.view.frame.exposure = None; + } + result(app, action); + } + }); +} + +/// Largest centred frame at an aspect. Reject invalid or unrepresentable geometry before arithmetic. +pub(super) fn frame_rect(aspect: f64, viewport: Rect) -> Option { + if !aspect.is_finite() || !(1e-6..=1e6).contains(&aspect) || !viewport.is_finite() || !viewport.is_positive() || viewport.size().max_elem() > 1e7 + { + return None; + } + let width = f64::from(viewport.width()).min(f64::from(viewport.height()) * aspect); + let height = width / aspect; + let frame = Rect::from_center_size(viewport.center(), vec2(width as f32, height as f32)); + (frame.is_finite() && frame.is_positive()).then_some(frame) +} + +pub(crate) fn overlay_visible(app: &SolveApp) -> bool { + !app.render_workspace.view.result + && (app.render_workspace.view.stage == Stage::Frame + || (app.render_workspace.view.inspector.page == inspector::Page::Camera && selected(app).is_some())) +} + +pub(crate) fn preview_rect(app: &SolveApp, viewport: Rect) -> Option { + if !overlay_visible(app) { + return None; + } + let saved = setup(app, &target(app)); + let index = aspect_index(app, &saved); + let aspect = ASPECTS + .get(index) + .filter(|(_, _, height, _)| *height > 0) + .map_or(f64::from(saved.width) / f64::from(saved.height), |(_, width, height, _)| f64::from(*width) / f64::from(*height)); + let free = crate::shell::workspace_content(app, crate::render_ui::canvas(app, viewport)); + frame_rect(aspect, free.shrink(Tokens::get().space_8)) +} + +pub(crate) fn overlay(app: &mut SolveApp, ui: &mut egui::Ui, viewport: Rect) { + if !overlay_visible(app) { + return; + } + let t = Tokens::get(); + let saved = setup(app, &target(app)); + let Some(frame) = preview_rect(app, viewport) else { return }; + ui_kit::frame_guides(ui, viewport, frame, app.render_workspace.view.frame.guides); + crate::scenario::publish_rect("render:frame:overlay", frame); + let index = aspect_index(app, &saved); + let aspect = ASPECTS.get(index).map(|(key, ..)| *key).unwrap_or("custom"); + let aspect = if aspect == "custom" { app.tr("render.frame_custom") } else { aspect }; + let label = format!("{aspect} · {} × {}", saved.width, saved.height); + ui_kit::Container::navigation_card( + ui.ctx(), + egui::Id::new("render_frame_size_chip"), + frame.left_top() + vec2(t.space_8, t.space_8), + egui::Align2::LEFT_TOP, + |ui| { + ui_kit::text(ui, &label, ui_kit::Text::Inline); + }, + ); + let lens = if app.cam.fov > 0.0 { + // Full-frame equivalent using the vertical 24 mm sensor dimension. + let mm = 12.0 / (app.cam.fov / 2.0).tan(); + crate::i18n::format("render.frame_lens", &[("fov", &format!("{:.0}", app.cam.fov.to_degrees())), ("mm", &format!("{mm:.0}"))]) + } else { + app.tr("render.stage_orthographic").to_string() + }; + ui_kit::Container::navigation_card( + ui.ctx(), + egui::Id::new("render_frame_lens_chip"), + pos2(frame.left() + t.space_8, frame.bottom() - t.space_8), + egui::Align2::LEFT_BOTTOM, + |ui| { + ui_kit::text(ui, &lens, ui_kit::Text::Inline); + }, + ); +} diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs index f370f6263..4cb30895f 100644 --- a/crates/ui-egui/src/render_workspace_tests.rs +++ b/crates/ui-egui/src/render_workspace_tests.rs @@ -281,6 +281,34 @@ fn environment_ring_fixture() -> Harness { h } +#[test] +fn render_workspace_frame_rect_fits_centres_and_refuses_hostile_sizes() { + let viewport = egui::Rect::from_min_size(egui::pos2(100.0, 40.0), egui::vec2(800.0, 600.0)); + for aspect in [16.0 / 9.0, 1.5, 1.0, 0.8, 9.0 / 16.0, 0.01, 100.0] { + let frame = shot::frame_rect(aspect, viewport).unwrap(); + assert!(viewport.contains_rect(frame)); + assert_eq!(frame.center(), viewport.center()); + assert!((f64::from(frame.width() / frame.height()) - aspect).abs() < 0.001); + assert!(frame.width() == viewport.width() || frame.height() == viewport.height()); + } + for aspect in [0.0, -1.0, f64::NAN, f64::INFINITY, f64::MAX, 1e-300] { + assert!(shot::frame_rect(aspect, viewport).is_none()); + } + for size in [egui::Vec2::ZERO, egui::vec2(0.0, 400.0), egui::vec2(f32::NAN, 10.0), egui::vec2(f32::MAX, f32::MAX), egui::vec2(-10.0, 20.0)] { + assert!(shot::frame_rect(1.5, egui::Rect::from_min_size(egui::Pos2::ZERO, size)).is_none()); + } +} + +fn frame_editor_fixture() -> Harness { + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1200})); + h.app.run("render.settings.set", json!({"name":"Hero","set":{"width":800,"height":600,"camera":h.app.cam}})).unwrap(); + enter(&mut h.app, true).unwrap(); + h.app.run("view.render_select", json!({"kind":"shot","id":"Hero"})).unwrap(); + h.app.run("view.render_stage", json!({"stage":"frame"})).unwrap(); + h +} + #[test] fn environment_ring_drag_is_one_undo_snaps_and_never_navigates_the_camera() { use egui::{Event, Modifiers, PointerButton}; @@ -499,6 +527,167 @@ fn environment_editor_hdr_header_reads_catalog_without_applying_or_saving() { } } +#[test] +fn render_workspace_frame_opening_editor_and_presets_never_mutates_or_starts_a_job() { + let mut h = frame_editor_fixture(); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + let camera = h.app.cam; + h.frames(4); + assert_eq!(h.app.cam, camera); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.undo.len(), undo); + assert!(h.app.render_workspace.view.job.is_none()); + assert!(crate::scenario::rect_of("render:shot:name").is_some()); + assert!(crate::scenario::rect_of("render:frame:aspect:16:9").is_some()); + assert!(crate::scenario::rect_of("render:frame:overlay").is_some()); + assert_eq!(shot::selected(&h.app), Some("Hero")); + h.step(&json!({"click":{"handle":"render:frame:thirds"}})).unwrap(); + assert!(h.app.render_workspace.view.frame.guides.thirds); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.undo.len(), undo); + let mut h = frame_editor_fixture(); + let camera = Camera { fov: 175f64.to_radians(), ..h.app.cam }; + inspector::apply_camera_draft(&mut h.app, camera).unwrap(); + h.frames(4); + assert_eq!(h.app.cam, camera, "opening must preserve valid FOVs outside the slider's usual editing range"); +} + +#[test] +fn render_workspace_frame_guides_are_transient_and_overlay_visibility_is_contextual() { + let mut h = frame_editor_fixture(); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + h.app.run("view.render_frame", json!({"aspect":"16:9","thirds":true,"safe_area":true,"centre_mark":true})).unwrap(); + assert!(shot::overlay_visible(&h.app)); + let viewport = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1000.0, 800.0)); + let frame = shot::preview_rect(&h.app, viewport).unwrap(); + assert!((frame.width() / frame.height() - 16.0 / 9.0).abs() < 0.001); + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + assert!(!shot::overlay_visible(&h.app)); + h.app.render_workspace.view.inspector.page = inspector::Page::Camera; + assert!(shot::overlay_visible(&h.app)); + h.app.render_workspace.view.result = true; + assert!(!shot::overlay_visible(&h.app)); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.doc.render.setups["Hero"].width, 800); + assert_eq!(h.app.session.undo.len(), undo); + assert!(h.app.render_workspace.view.frame.guides.thirds); + assert!(h.app.render_workspace.view.frame.guides.safe_area); + assert!(h.app.render_workspace.view.frame.guides.centre_mark); +} + +#[test] +fn render_workspace_frame_exposure_drag_is_one_saved_edit_and_undoes() { + let mut h = frame_editor_fixture(); + shot::edit_settings(&mut h.app, "Hero", json!({"job":{"method":"cpu_raytrace"}})).unwrap(); + h.call("ui.resize", json!({"width":1600,"height":1800})); + h.frames(4); + let track = crate::scenario::rect_of("dialog:slider_track:Exposure").unwrap(); + assert!(track.width() > 20.0, "exposure track: {track:?}"); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + let start = track.center(); + let end = egui::pos2(track.left() + track.width() * 0.75, track.center().y); + h.step(&json!({"drag":[[start.x,start.y],[end.x,end.y]],"steps":8})).unwrap(); + assert_ne!( + h.app.session.doc.render.setups["Hero"].exposure_ev, 0.0, + "track: {track:?}; state: {:?}; status: {:?}", + h.app.render_workspace.view.frame, h.app.status + ); + assert_eq!(h.app.session.undo.len(), undo + 1); + h.app.run("edit.undo", json!({})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); +} + +#[test] +fn render_workspace_scene_render_shot_captures_current_size_and_live_camera_without_saving() { + let mut h = frame_editor_fixture(); + h.app.run("solid.box", json!({"length":10,"width":20,"height":5})).unwrap(); + shot::edit_settings(&mut h.app, "Hero", json!({"width":16,"height":12})).unwrap(); + h.app.render_workspace.image_host = Some(solidcraft_engine::render::job::CpuHost::cooperative()); + sync_backend(&mut h.app); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + let camera = Camera { distance: 85.0, fov: 35f64.to_radians(), ..h.app.cam }; + inspector::apply_camera_draft(&mut h.app, camera).unwrap(); + h.app.run("view.render_frame", json!({"thirds":true,"safe_area":true,"centre_mark":true})).unwrap(); + h.app.render_workspace.view.name = "Hero".into(); + setups::load(&mut h.app); + ribbon::perform_job(&mut h.app, "render.start").unwrap(); + let job = h.app.render_workspace.view.job.unwrap(); + let handle = h.app.session.render_job_handle(job).unwrap(); + assert_eq!(h.app.render_workspace.view.job_shot.as_deref(), Some("Hero")); + let host = h.app.session.render_job_host().unwrap().clone(); + for _ in 0..128 { + host.pump(16384).unwrap(); + if handle.frame().unwrap().is_some() { + break; + } + } + let frame = handle.frame().unwrap().unwrap(); + assert_eq!((frame.info.width, frame.info.height), (16, 12)); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.undo.len(), undo); +} + +#[test] +fn render_workspace_frame_aspect_click_edits_only_selected_shot_size_once_and_undoes() { + let mut h = frame_editor_fixture(); + h.frames(4); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":"render:frame:aspect:16:9"}})).unwrap(); + let saved = &h.app.session.doc.render.setups["Hero"]; + assert_eq!((saved.width, saved.height), (1920, 1080)); + assert_eq!(h.app.session.undo.len(), undo + 1); + h.app.run("edit.undo", json!({})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); + for (index, expected) in [(1, (1620, 1080)), (2, (1080, 1080)), (3, (864, 1080)), (4, (1080, 1920))] { + let undo = h.app.session.undo.len(); + shot::choose_aspect(&mut h.app, "Hero", index).unwrap(); + let saved = &h.app.session.doc.render.setups["Hero"]; + assert_eq!((saved.width, saved.height), expected); + assert_eq!(h.app.session.undo.len(), undo + 1); + } + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + shot::choose_aspect(&mut h.app, "Hero", 5).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.undo.len(), undo); + assert!(shot::choose_aspect(&mut h.app, "Hero", usize::MAX).is_err()); +} + +#[test] +fn render_workspace_frame_shot_edits_revert_duplicate_and_rename_use_existing_commands() { + let mut h = frame_editor_fixture(); + let before = h.app.session.doc.render.setups["Hero"].clone(); + let camera = Camera { distance: before.camera.distance * 2.0, ..before.camera }; + inspector::apply_camera_draft(&mut h.app, camera).unwrap(); + let undo = h.app.session.undo.len(); + assert!(shots::camera_modified(&h.app, "Hero")); + shot::edit_settings(&mut h.app, "Hero", json!({"camera":camera})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + assert!(!shots::camera_modified(&h.app, "Hero")); + h.app.run("edit.undo", json!({})).unwrap(); + shot::revert(&mut h.app, "Hero").unwrap(); + assert_eq!(h.app.cam, before.camera); + shot::edit_settings(&mut h.app, "Hero", json!({"exposure_ev":1.5})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + shot::duplicate(&mut h.app, "Hero").unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 2); + let copied = h.app.session.doc.render.setups.iter().find(|(name, _)| name.as_str() != "Hero").unwrap().1; + assert_eq!(copied, &h.app.session.doc.render.setups["Hero"]); + shot::rename(&mut h.app, "Hero", "Renamed").unwrap(); + assert_eq!(shot::selected(&h.app), Some("Renamed")); + assert_eq!(h.app.session.undo.len(), undo + 3); + let before = h.app.session.doc.to_json(); + for patch in [json!({"width":0}), json!({"width":u32::MAX}), json!({"height":1e300}), json!({"exposure_ev":33}), json!({"exposure_ev":null})] { + assert!(shot::edit_settings(&mut h.app, "Renamed", patch).is_err()); + assert_eq!(h.app.session.doc.to_json(), before); + } +} + #[cfg(not(target_arch = "wasm32"))] mod async_path_host { use super::*; @@ -1088,12 +1277,13 @@ fn clicked_render_workspace_saves_one_setup_and_restores_design_view() { h.step(&json!({"click":[at.x,at.y]})).unwrap(); h.step(&json!({"click":{"handle":"menu:ui.workspace.render"}})).unwrap(); assert!(active(&h.app)); - let heading = h.app.tr("render.studio_title").to_string(); + let heading = h.app.tr("render.page_scene").to_string(); let perspective = h.app.tr("render.perspective").to_string(); let save = h.app.tr("render.save_setup").to_string(); let back = h.app.tr("render.return_design").to_string(); - h.step(&json!({"click":{"handle":"render:stage:frame"}})).unwrap(); assert!(h.widget(&heading).is_some(), "{language}"); + h.step(&json!({"click":{"handle":"render:scene:frame"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Camera); h.step(&json!({"widget":perspective})).unwrap(); assert!(!h.app.session.is_dirty(), "preview edits are staged"); h.step(&json!({"widget":save})).unwrap(); @@ -3344,7 +3534,7 @@ fn render_workspace_stage_commands_keep_registered_actions_without_a_ribbon() { assert!(crate::scenario::rect_of("tab:RENDER").is_none()); assert!(crate::scenario::rect_of("render:hud").is_none()); assert_eq!(h.app.render_workspace.view.stage, Stage::Look); - assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Appearance); + assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Scene); } #[test] @@ -3895,7 +4085,10 @@ fn assert_product_fits_canvas(app: &SolveApp) { #[test] fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() { - for layout in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] { + for (layout, page) in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] + .into_iter() + .flat_map(|layout| [inspector::Page::Scene, inspector::Page::Appearance].map(|page| (layout, page))) + { let mut h = Harness::new(); h.app.ui.layout = layout; h.call("ui.resize", json!({"width":1600,"height":1000})); @@ -3903,6 +4096,7 @@ fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() { h.frames(4); enter(&mut h.app, true).unwrap(); + h.app.render_workspace.view.inspector.page = page; h.frames(4); let viewport = h.app.viewport.rect.unwrap(); let history = crate::timeline::floating_rect(viewport); @@ -3943,8 +4137,10 @@ fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() { "render:tree:by-look" } else if key == "render:appearances" { "render:library-search" - } else { + } else if page == inspector::Page::Appearance { "dialog:editor_footer" + } else { + "render:scene:look" }) .unwrap(); if key == "render:browser" { @@ -4545,10 +4741,9 @@ fn render_workspace_browser_focus_covers_each_kind_without_design_edits() { assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Shot("Shot".into())); h.step(&json!({"click":{"handle":"render:tree:output"}})).unwrap(); assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Output); - let page = h.app.render_workspace.view.inspector.page; h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap(); assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Nothing); - assert_eq!(h.app.render_workspace.view.inspector.page, page, "focus alone does not dispatch Inspector editors"); + assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Scene); assert_eq!(h.app.session.revision, focused_revision, "semantic selection only refreshes the view when clearing object picks"); assert!(Arc::ptr_eq(&doc, &h.app.session.doc)); assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty())); diff --git a/crates/ui-egui/src/ui_kit/actions.rs b/crates/ui-egui/src/ui_kit/actions.rs index 7e453c0bd..23a87e415 100644 --- a/crates/ui-egui/src/ui_kit/actions.rs +++ b/crates/ui-egui/src/ui_kit/actions.rs @@ -580,6 +580,14 @@ pub(crate) fn icon_label_button(ui: &mut Ui, label: &str, icon: &str, enabled: b icon_label_presentation(ui, crate::i18n::tr_label(label), Some(icon), enabled, false, danger, false) } +/// Icon-only action with an accessible name and tooltip, using the shared action +/// geometry, enabled state and optional danger ink. Tokens: icon-label action tokens. +pub(crate) fn icon_action(ui: &mut Ui, label: &str, icon: &str, enabled: bool, danger: bool) -> Response { + let response = icon_label_button(ui, "", icon, enabled, danger).on_hover_text(label); + response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, enabled && ui.is_enabled(), label)); + response +} + /// Compact stage actions share the icon-label button's frame, typography and hit target. pub(super) fn icon_label_width(ui: &Ui, label: &str, icon: Option<&str>, primary: bool) -> f32 { let t = Tokens::get(); diff --git a/crates/ui-egui/src/ui_kit/fields.rs b/crates/ui-egui/src/ui_kit/fields.rs index 8e434be23..44dec1983 100644 --- a/crates/ui-egui/src/ui_kit/fields.rs +++ b/crates/ui-egui/src/ui_kit/fields.rs @@ -885,6 +885,34 @@ pub(crate) fn vector3_field(ui: &mut Ui, values: &mut [f64; 3], range: std::ops: changed } +/// Equal-width numeric cells within a shared `row`. Returns each field's response in order. +/// Tokens: `control_height`, inherited item spacing and number-field tokens. +pub(crate) fn number_fields( + ui: &mut Ui, + values: &mut [T], + range: std::ops::RangeInclusive, + speed: f64, + suffix: &str, +) -> Vec { + let gap = ui.spacing().item_spacing.x; + let width = dimension(ui.available_width() - gap * values.len().saturating_sub(1) as f32) / values.len().max(1) as f32; + values + .iter_mut() + .enumerate() + .map(|(index, value)| { + ui.push_id(index, |ui| { + ui.allocate_ui_with_layout(vec2(width, row_height()), egui::Layout::top_down_justified(egui::Align::LEFT), |ui| { + ui.spacing_mut().text_edit_width = width; + ui.spacing_mut().interact_size.x = width; + number_field(ui, value, range.clone(), speed, suffix) + }) + .inner + }) + .inner + }) + .collect() +} + /// Growing plain-text message editor; its parent owns scrolling and Enter routing. /// Tokens: control_fill, form_inset, font_label. Use text_area for bounded data input. #[cfg(any(not(target_arch = "wasm32"), test))] diff --git a/crates/ui-egui/src/ui_kit/framing.rs b/crates/ui-egui/src/ui_kit/framing.rs new file mode 100644 index 000000000..f37602b53 --- /dev/null +++ b/crates/ui-egui/src/ui_kit/framing.rs @@ -0,0 +1,112 @@ +//! Shared aspect choices and camera composition guides; no document or command authority. +use crate::{scenario, theme::Tokens}; +use egui::{Rect, Stroke, Ui, pos2, vec2}; + +pub(crate) struct AspectTile<'a> { + pub id: &'a str, + pub label: &'a str, + pub aspect: f64, + pub selected: bool, +} + +/// Three-column compact illustrated choices, using the same control surface as other choices. +pub(crate) fn aspect_grid(ui: &mut Ui, tiles: &[AspectTile<'_>]) -> Option { + let t = Tokens::get(); + let accent = crate::theme::TabAccent::current(ui.ctx()); + let mut clicked = None; + for (row, tiles) in tiles.chunks(3).enumerate() { + ui.columns(3, |columns| { + for (column, tile) in tiles.iter().enumerate() { + let Some(ui) = columns.get_mut(column) else { continue }; + let (rect, response) = ui.allocate_exact_size(vec2(ui.available_width(), t.control_height * 2.0 + t.space_8), egui::Sense::click()); + let fill = if tile.selected { + accent.soft + } else if response.hovered() { + t.hover + } else { + t.control_fill + }; + let ink = if tile.selected { accent.ink } else { t.form_ink }; + ui.painter().rect_filled(rect, t.control_radius, fill); + ui.painter().rect_stroke( + rect, + t.control_radius, + t.control_border_stroke(if tile.selected { accent.ink } else { t.control_border }), + egui::StrokeKind::Inside, + ); + let available = vec2((rect.width() - t.space_16).max(0.0), t.control_height); + let aspect = if tile.aspect.is_finite() && tile.aspect > 0.0 { tile.aspect as f32 } else { 1.0 }; + let width = available.x.min(available.y * aspect); + let size = vec2(width, width / aspect); + let glyph = Rect::from_center_size(pos2(rect.center().x, rect.top() + t.space_8 + available.y / 2.0), size); + ui.painter().rect_stroke(glyph, 0, Stroke::new(1.0, ink), egui::StrokeKind::Inside); + ui.painter().text( + pos2(rect.center().x, rect.bottom() - t.space_8), + egui::Align2::CENTER_BOTTOM, + tile.label, + egui::FontId::proportional(t.font_small), + ink, + ); + response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Button, ui.is_enabled(), tile.selected, tile.label)); + scenario::publish_target(tile.id, rect); + if response.clicked() { + clicked = Some(row * 3 + column); + } + } + }); + } + clicked +} + +#[derive(Clone, Copy, Debug, Default)] +pub(crate) struct FrameGuides { + pub thirds: bool, + pub safe_area: bool, + pub centre_mark: bool, +} + +/// Pure viewport decoration; callers keep this out of image renderers and result canvases. +pub(crate) fn frame_guides(ui: &Ui, viewport: Rect, frame: Rect, guides: FrameGuides) { + if !viewport.is_finite() || !frame.is_finite() || !viewport.is_positive() || !frame.is_positive() { + return; + } + let t = Tokens::get(); + let painter = ui.painter().with_clip_rect(viewport); + let mask = t.app_bar.gamma_multiply(0.45); + for outside in [ + Rect::from_min_max(viewport.min, pos2(viewport.right(), frame.top())), + Rect::from_min_max(pos2(viewport.left(), frame.bottom()), viewport.max), + Rect::from_min_max(pos2(viewport.left(), frame.top()), frame.left_bottom()), + Rect::from_min_max(frame.right_top(), pos2(viewport.right(), frame.bottom())), + ] { + if outside.is_positive() { + painter.rect_filled(outside, 0, mask); + } + } + let stroke = Stroke::new(1.0, t.form_ink.gamma_multiply(0.65)); + painter.rect_stroke(frame, 0, stroke, egui::StrokeKind::Inside); + let guide = Stroke::new(1.0, t.form_ink.gamma_multiply(0.3)); + if guides.thirds { + for fraction in [1.0 / 3.0, 2.0 / 3.0] { + painter.vline(frame.left() + frame.width() * fraction, frame.y_range(), guide); + painter.hline(frame.x_range(), frame.top() + frame.height() * fraction, guide); + } + } + if guides.safe_area { + let safe = frame.shrink2(frame.size() * 0.05); + for [a, b] in [ + [safe.left_top(), safe.right_top()], + [safe.right_top(), safe.right_bottom()], + [safe.right_bottom(), safe.left_bottom()], + [safe.left_bottom(), safe.left_top()], + ] { + let dash = t.space_4.max(a.distance(b) / 256.0); + painter.extend(egui::Shape::dashed_line(&[a, b], guide, dash, dash)); + } + } + if guides.centre_mark { + let c = frame.center(); + painter.line_segment([c - vec2(t.space_8, 0.0), c + vec2(t.space_8, 0.0)], stroke); + painter.line_segment([c - vec2(0.0, t.space_8), c + vec2(0.0, t.space_8)], stroke); + } +} diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs index 55af8f328..a9d2dbbef 100644 --- a/crates/ui-egui/src/ui_kit/gallery.rs +++ b/crates/ui-egui/src/ui_kit/gallery.rs @@ -153,6 +153,24 @@ const ELEMENTS: &[Element] = &[ checkbox(ui, "Reduce noise", &mut state.checked); }); }), + element!("icon_action", |ui, _| { + icon_action(ui, "Duplicate", "copy", true, false); + icon_action(ui, "Remove", "delete", true, true); + }), + element!("aspect_grid", |ui, _| { + aspect_grid( + ui, + &[ + AspectTile { id: "gallery:aspect:wide", label: "16:9", aspect: 16.0 / 9.0, selected: true }, + AspectTile { id: "gallery:aspect:square", label: "1:1", aspect: 1.0, selected: false }, + AspectTile { id: "gallery:aspect:tall", label: "9:16", aspect: 9.0 / 16.0, selected: false }, + ], + ); + }), + element!("frame_guides", |ui, _| { + 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!("tree_row_rect", |ui, _| { for (index, row) in [ Row { label: "Objects", ..Default::default() }, @@ -1058,6 +1076,11 @@ const ELEMENTS: &[Element] = &[ element!("number_field", |ui, _| { number_field(ui, &mut 3_u32, 1..=200, 1.0, ""); }), + element!("number_fields", |ui, _| { + row(ui, "Target", |ui| { + number_fields(ui, &mut [-18.0, 125.5, -18.0], -1e9..=1e9, 0.1, ""); + }); + }), element!("slider_percent", |ui, _| { slider(ui, &mut 1.0, 0.5..=2.5, Slider { step: Some(0.05), format: |v| format!("{:.0} %", v * 100.0), ..Default::default() }); }), @@ -1866,6 +1889,7 @@ fn gallery_covers_every_inline_element() { "color.rs", "disclosure.rs", "fields.rs", + "framing.rs", "layout.rs", "look_chain.rs", "menu.rs", diff --git a/crates/ui-egui/src/ui_kit/mod.rs b/crates/ui-egui/src/ui_kit/mod.rs index f57d010db..6aa617938 100644 --- a/crates/ui-egui/src/ui_kit/mod.rs +++ b/crates/ui-egui/src/ui_kit/mod.rs @@ -13,6 +13,7 @@ mod disclosure; mod drag; mod fields; mod file_view; +mod framing; mod history; mod layout; mod look_chain; @@ -60,6 +61,7 @@ pub(crate) use drag::*; pub use fields::cell_editor; pub(crate) use fields::*; pub(crate) use file_view::{FileView, RecentRow, RecoveryMessage, SampleCard}; +pub(crate) use framing::*; pub(crate) use history::*; pub(crate) use layout::*; pub use look_chain::{LookStep, look_chain}; diff --git a/crates/ui-egui/src/ui_kit_guard_tests.rs b/crates/ui-egui/src/ui_kit_guard_tests.rs index fa2901b5f..f040e36af 100644 --- a/crates/ui-egui/src/ui_kit_guard_tests.rs +++ b/crates/ui-egui/src/ui_kit_guard_tests.rs @@ -848,7 +848,10 @@ fn parsed_frame_violations(ast: &syn::File) -> Vec { fn visit_expr_path(&mut self, expr: &'ast syn::ExprPath) { let names: Vec<_> = expr.path.segments.iter().map(|s| s.ident.to_string()).collect(); if !names.iter().any(|s| s == "ui_kit") - && names.iter().any(|s| matches!(s.as_str(), "Frame" | "Window" | "Modal" | "shell_card" | "dock_frame") || self.aliases.contains(s)) + && names.iter().enumerate().any(|(index, s)| { + matches!(s.as_str(), "shell_card" | "dock_frame") + || (index + 1 < names.len() && (matches!(s.as_str(), "Frame" | "Window" | "Modal") || self.aliases.contains(s))) + }) { self.found.push(names.join("::")); } @@ -901,6 +904,7 @@ fn window_guard_rejects_frames_aliases_and_native_windows_but_accepts_kit_compos r#" use egui::{Frame as Card, Window as Popup, Modal as Alert}; fn raw(ui: &mut Ui) { + let _stage = super::Stage::Frame; Card::NONE.show(ui, |_| {}); egui::Frame::group(ui.style()); Popup::new("Title"); Alert::new(id); diff --git a/docs/render-shot-scene.md b/docs/render-shot-scene.md new file mode 100644 index 000000000..5ad13e5e9 --- /dev/null +++ b/docs/render-shot-scene.md @@ -0,0 +1,47 @@ +# Scene overview and Shot editor + +The Scene overview replaces the old Scene page. Entering Render with no selection, +clearing the selection, or selecting nothing opens Scene. Selecting a saved shot +opens its Shot editor; the other editors retain their existing adapters during the +selection-based Inspector migration. + +Scene follows E1: Stages (Look, Light, Frame, Output), Ready to render, Reminders. +Each stage row summarises current state and navigates through the view commands. +Look opens the object/appearance stage, Light selects Environment, Frame selects +the current saved shot, and Output selects Output. Check now and Render shot use +the same request and command adapters as the stage bar. Open Check opens the +existing diagnostics editor because this branch has no Check selection kind. +The check summary distinguishes unchecked, current and stale results. Renderer +setup progress, failures, unavailable hosts and offline reasons remain visible. +All shots shows the saved-shot count and stays faded with the unavailable queue +reason; it never silently starts an individual render. + +Shot follows E7: Name; changed-camera banner and Update/Revert/duplicate/remove; +Camera; Lens (GPU); Exposure; Frame. Camera contains projection, FOV, distance in +subject-size units, target XYZ, yaw/pitch/roll, Frame subject and Look at selection. +Camera controls save through render.settings.set and apply through render.camera.set; +navigation alone leaves the camera changed banner until Update shot or Revert. +Remove always uses the shared confirmation and checks for stale document state. + +Lens values are saved to the selected shot's GPU job while retaining its other +options. Depth of field needs GPU path tracing and perspective; aperture and focus +distance remain visible when disabled. Raster exposure and orthographic FOV stay +faded with reasons. Changing to orthographic while saved depth of field is enabled +is rejected by the existing settings validation; disable depth of field first. +Frame retains aspect presets and transient composition guides. Size is read-only; +Edit in Output selects Output, the home of image dimensions. + +These two editors use the shared workspace header without the old setup form, +page switcher or pinned job footer. Explicit native-studio resource reviews remain +in the library card, keeping Scene limited to orientation and readiness. The +shared section_method component supplies method badges, with a gallery sample. +New copy is in assets/locales/pending/render-shot-scene.json for en, ja, zh, de, ko. + +The Shot Target uses the shared number_fields row cells with equal widths. The +Projection row uses the kit's base label column to leave room for both full +projection labels, and the distance label is shortened to Distance. Layout +regression coverage checks every editor widget at 350 and 320 points of content +width, including disabled controls, equal Target cells and untruncated labels. + +Validation uses headless egui harnesses and focused render tests. No running-app +visual review or GPU-device verification is claimed by this change. diff --git a/docs/render-workspace.md b/docs/render-workspace.md index e8d53d9fb..e664a8f97 100644 --- a/docs/render-workspace.md +++ b/docs/render-workspace.md @@ -455,6 +455,20 @@ that pending request. Hover uses the shared tooltip with the object and look nam ## Browser scene focus +The existing Camera Inspector page shows a standalone Shot editor when the Browser selection +is a saved shot. Opening it leaves the live camera and saved design unchanged. Camera fields +use `render.camera.set`; Update shot saves that camera and Revert restores the saved camera. +Name, output dimensions and exposure use the existing undoable shot/settings commands. +Distance is shown as a multiple of the visible subject's bounding-box diagonal (one millimetre +for an empty scene). The lens chip uses the camera's vertical FOV and a 24 mm sensor height. + +Frame's floating panel offers five aspect presets and Custom, plus composition guides. +Clicking a preset saves its output dimensions in one undo step; Custom preserves dimensions. +`view.render_frame` independently validates and echoes transient aspect/guide preferences; +headless calls never edit a design. Guides are per-document UI state, never saved in design JSON. +The frame and its size/lens chips appear only in Frame or the Shot editor. Product preview, +navigation and picking use the fitted frame aspect; image jobs and the Result canvas omit guides. + The shared Browser lists Environment (with its source), Lights, saved Shots, Objects and Output (with image dimensions and format). Shots **+** opens the existing Shots manager; Lights **+**, Solo and Mute remain faded with an explicit diff --git a/docs/ui-kit.md b/docs/ui-kit.md index 4e274b966..8f0fb555a 100644 --- a/docs/ui-kit.md +++ b/docs/ui-kit.md @@ -134,6 +134,11 @@ input and introduce no repaint timer. ## Elements +`aspect_grid` composes three-column `AspectTile` choices with token-sized aspect glyphs, +selection tint and stable targets. `frame_guides` paints a bounded viewport mask, outline, +thirds, a 90% safe area and a centre mark from `FrameGuides`. These are viewport decorations; +callers exclude them from exported images and result canvases. + Module names below describe implementation locations, not caller import paths. Every inline element/variant has one entry in the light/dark `gallery::ELEMENTS` table. Panel/Window/Confirm compositions also have dedicated geometry and interaction tests. @@ -156,6 +161,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera | `figure_rows`, `FigureSlot` | A caller-painted figure in the label column beside a stack of captioned expression fields (the Hole dialog's section); the caller gets each field's rect and hover/focus state to draw leaders and light the part it sizes. Fields keep their `dialog: