SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Render shot editor: camera and frame controls, aspect presets, guides and frame overlay (#6281) (#7232)
Nathan Daned2fcab84322b
diff --git a/assets/locales/pending/render-frame.json b/assets/locales/pending/render-frame.jsonnew file mode 100644index 0000000000..15d455f8e6--- /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.jsonnew file mode 100644index 0000000000..10070dea04--- /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.rsindex 76855512d5..a835981456 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.rsindex ca384f2f4e..30d8ff7119 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::<RenderFocus>).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::<crate::schema::view_navigation::RenderFrame>)+ .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::<RenderBrowserRequest>)@@ -298,6 +303,17 @@ fn render_browser(_s: &mut Session, p: &Value) -> Result<Value> {serde_json::to_value(request).map_err(|e| bad("view.render_browser", e.to_string()))}+static RENDER_FRAME_CONTRACT: crate::schema::TypedContract<crate::schema::view_navigation::RenderFrame> = crate::schema::TypedContract::new();++fn render_frame(_s: &mut Session, p: &Value) -> Result<Value> {+ 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<Value> {#[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.rsindex a16c668607..39a60f8ab8 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<FrameAspect>,+ #[serde(default, deserialize_with = "super::types::present", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "bool")]+ pub thirds: Option<bool>,+ #[serde(default, deserialize_with = "super::types::present", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "bool")]+ pub safe_area: Option<bool>,+ #[serde(default, deserialize_with = "super::types::present", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "bool")]+ pub centre_mark: Option<bool>,+}+#[cfg(test)]#[path = "view_navigation_tests.rs"]mod tests;diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex ee7e7bdf53..e6a47af224 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.rsindex 7cc725e58d..606057ba91 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<String>,save_shot_name: Option<String>,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.rsindex f54b319a3b..d3048d9c37 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<Pending>,+ #[cfg(test)]shot_name: String,pub checked: Option<Review>,scene_info: Option<Review>,- 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<(), Strinapp.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);+ 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);+ }}- 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_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"));}- library::stage_content(app, ui);+ 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.rsindex ab2914bfa1..9c19d9836c 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_footeassert!(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_footelet 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.rsindex c08f8052e1..6e31e1d1fc 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.rsindex 3d0c1ad6a5..082dc3d6e2 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<Document>,}+#[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.rsnew file mode 100644index 0000000000..23a2f57119--- /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<String>,+ 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<Rect> {+ 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<Rect> {+ 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.rsindex f370f6263a..4cb30895fc 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.rsindex 7e453c0bd2..23a87e4152 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: bicon_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.rsindex 8e434be23e..44dec19835 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<T: egui::emath::Numeric>(+ ui: &mut Ui,+ values: &mut [T],+ range: std::ops::RangeInclusive<T>,+ speed: f64,+ suffix: &str,+) -> Vec<Response> {+ 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.rsnew file mode 100644index 0000000000..f37602b532--- /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<usize> {+ 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.rsindex 55af8f3281..a9d2dbbefa 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.rsindex f57d010db6..6aa6179385 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.rsindex fa2901b5f9..f040e36af0 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<String> {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_composr#"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.mdnew file mode 100644index 0000000000..5ad13e5e90--- /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.mdindex e8d53d9fb3..e664a8f97b 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 theexisting Shots manager; Lights **+**, Solo and Mute remain faded with an explicitdiff --git a/docs/ui-kit.md b/docs/ui-kit.mdindex 4e274b9666..8f0fb555ad 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:<label>` handles; the block publishes `dialog:figure:<id>` and its picture `dialog:figure_picture:<id>` | `control_height`, `form_label_width`, `font_small`, `form_dim`, `space_2/4`, label gap || `linear_color_field` | Linear RGB swatch with precise channel fields; clips only the preview to display gamut and preserves HDR values until edited | `control_height`, `space_4`, shared colour popover || `section`, `section_count`, `section_method`, `search_fold`, `divider` | Persisted small-caps disclosure with chevron, optional count or method tag and trailing hairline; `search_fold` is that row for shortcut matches during Preferences search, closed until opened; full-width rule | `control_height`, `dialog_rule`, `font_caption`, tracking, spacing |+| `icon_action` | Icon-only action with an accessible name, tooltip, enabled state and danger variant | Shared icon-label action geometry and ink tokens || `list_row` | Picked item with a remove target | `control_height`, `font_label`, icon/spacing tokens || `text`, `Text` | Hint, note, report, inline or cell text; see variants below | `font_small/label`, `text/dim/error`, `control_height`, `space_4` || `text_lines` | Virtualized read-only licence/report lines, horizontal overflow | `font_small`, `text`, `control_height` |@@ -174,6 +180,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera| `value_pair` | Paired captions/expressions; optional independent field names | row/field tokens, `space_8` || `fraction_field`, `scalar_field`, `mixed_scalar_field` | Locale-aware bounded dimensionless values; scalar fields fill their control column; the mixed variant accepts a translated placeholder | form control/font tokens || `number_field` | Integer/decimal field with caller range, drag speed and suffix | form control/font tokens |+| `number_fields` | N numeric cells sharing a row's remaining width equally, including gaps; returns each field response in order | `control_height`, inherited item spacing, number-field tokens || `length_field`, `angle_field` | Length in design units, angle in degrees | form control/font tokens || `slider` + `Slider` options | One token-painted track/thumb over native slider/value interaction; optional step, caller formatting, whole-step manipulation and hidden value editor | `control_height`, `space_24/8/4/2`, form control/font tokens || `placement_field` | Stable focus ID; drawing tool owns Enter/Tab validation and completion | `control_fill`, `font_body`, `text`, `control_height`, spacing |@@ -444,6 +451,10 @@ the kit. The source guard scans both trees without an allowance table; the gallecovers continuous, percent/stepped, integer/no-editor and disabled states in both themes.Numeric fields use the existing kit `scalar_field`, `length_field`, `angle_field`or `number_field` rather than constructing a raw `egui::DragValue` at a caller.+For a numeric tuple, call `number_fields(ui, &mut values, range, speed, suffix)`+inside `row`. It divides the remaining control width equally after reserving the+inter-cell gaps, and keeps each cell's editor width and native input minimum local+to that cell. An empty slice draws nothing; responses follow the input order.Parameters retains its bounded header drag offset while the manager is open,including frames without a regular feature dialog. The shared Panel bound reserves