Skip to content

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.json
new file mode 100644
index 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.json
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<(), Strin
app.render_workspace.view.name = app.session.doc.render.setups.keys().next().cloned().unwrap_or_else(|| "Studio".into());
setups::load(app);
}
+ if matches!(&app.render_workspace.view.selection, super::RenderSelection::Shot(selected) if selected == &name) {
+ app.run("view.render_select", json!({"kind":"nothing"}))?;
+ }
}
}
Ok(())
@@ -498,53 +507,109 @@ fn scene_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
let label = app.tr("render.children.method").to_string();
ui_kit::row(ui, &label, |ui| super::method_dropdown(app, ui));
gpu_status(app, ui);
- browse_button(app, ui, "native_scenes", "render.browse_native_scenes");
- browse_button(app, ui, "scenes", "render.browse_scene_specs");
- physical_stage_controls(app, ui);
- shot_controls(app, ui);
-}
-fn physical_stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- let title = app.tr("render.passive_stage").to_string();
- reveal_section(app, ui, "render_ground_details");
- ui_kit::section(ui, "render_ground_details", &title, false, |ui| {
- ui.label(app.tr("render.ground_margin"));
- ui_kit::number_field(ui, &mut app.render_workspace.view.inspector.ground_margin, 0.0..=10.0, 0.05, " x");
- ui.label(app.tr("render.ground_gap"));
- ui_kit::number_field(ui, &mut app.render_workspace.view.inspector.ground_gap, 0.0001..=1000.0, 0.01, " mm");
- let label = app.tr("render.ground_linear_rgb").to_string();
- vector(ui, &label, &mut app.render_workspace.view.inspector.ground_color, 0.0..=1.0, 0.01);
- let saved = setups::snapshot(app);
- if ui_kit::button(
- ui,
- app.tr("render.ground_apply"),
- ui_kit::Button::Enabled(saved.is_ok() && app.render_workspace.view.method != ImageMethod::Raster),
- )
- .clicked()
- && let Ok(set) = saved
- {
- let v = &app.render_workspace.view.inspector;
- let request = json!({"name":app.render_workspace.view.name,"set":set,"margin_fraction":v.ground_margin,"gap_mm":v.ground_gap,"reflectance_linear":v.ground_color,"replace_stage":true});
- library::review::command(app, "render.stage.ground", request);
+ 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.rs
index 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_foote
assert!(h.app.render_workspace.view.job.is_none());
assert!(h.app.render_workspace.view.completed.is_none());
if page == Page::Appearance {
+ let footer = crate::scenario::rect_of("dialog:editor_footer").unwrap();
+ assert!(inspector.contains_rect(footer), "Appearance footer outside inspector: {inspector:?} {footer:?}");
assert!(crate::scenario::rect_of("render:job-footer").is_none());
continue;
}
@@ -56,15 +284,19 @@ fn native_inspector_keeps_stage_actions_on_screen_and_output_has_no_pinned_foote
let bar = crate::scenario::rect_of("render:stage_bar").unwrap();
for name in ["render:stage:render.start", "render:stage:render.cancel"] {
let action = crate::scenario::rect_of(name).unwrap();
- assert!(bar.contains_rect(action), "{name} outside stage bar");
+ assert!(bar.contains_rect(action), "{name} outside stage bar: {bar:?} {action:?}");
+ }
+ } else if page == Page::Scene {
+ let stages = crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr("render.scene_stages"))).unwrap();
+ assert!(inspector.contains_rect(stages), "Scene stages outside inspector: {inspector:?} {stages:?}");
+ assert!(crate::scenario::rect_of("render:job-footer").is_none());
+ } else {
+ let footer = crate::scenario::rect_of("render:job-footer").unwrap();
+ assert!(inspector.contains_rect(footer), "footer outside inspector at {page:?}: {inspector:?} {footer:?}");
+ for name in ["render:check", "render:start", "render:cancel", "render:export"] {
+ let target = crate::scenario::rect_of(name).unwrap();
+ assert!(footer.contains_rect(target), "{name} clipped at {page:?}");
}
- continue;
- }
- let footer = crate::scenario::rect_of("render:job-footer").unwrap();
- assert!(inspector.contains_rect(footer), "footer outside inspector at {page:?}: {inspector:?} {footer:?}");
- for name in ["render:check", "render:start", "render:cancel", "render:export"] {
- let target = crate::scenario::rect_of(name).unwrap();
- assert!(footer.contains_rect(target), "{name} clipped at {page:?}");
}
}
}
@@ -572,10 +804,10 @@ fn contextual_scope_notes_wrap_with_native_tokens_instead_of_clipping() {
h.frames(3);
let rect = crate::scenario::rect_of("dialog:note:render.scene_preserves_design").unwrap();
let inspector = crate::scenario::rect_of("render:inspector").unwrap();
- let footer = crate::scenario::rect_of("render:job-footer").unwrap();
assert!(rect.height() > Tokens::get().font_small + Tokens::get().space_8, "long scope notice must have more than one line");
assert!(inspector.contains_rect(rect));
- assert!(rect.bottom() < footer.top());
+ assert!(rect.bottom() < inspector.bottom());
+ assert!(crate::scenario::rect_of("render:job-footer").is_none());
}
#[test]
@@ -628,6 +860,47 @@ fn native_composition_review_actions_are_visible_in_shared_dialog() {
}
}
+#[test]
+fn native_composition_review_actions_are_visible_before_auxiliary_resource_details() {
+ for dark in [false, true] {
+ let mut h = fixture();
+ h.call("ui.set", json!({"dark":dark}));
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ setups::save(&mut h.app).unwrap();
+ library::open_category(&mut h.app, "native_scenes");
+ h.frames(3);
+ let before = h.app.session.doc.to_json();
+ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len());
+ h.step(&json!({"click":{"handle":"render:light:NATIVE-STUDIO-002"}})).unwrap();
+ let library = h.app.shell.workspace_panels.get("render:appearances").unwrap().0;
+ let review = crate::scenario::rect_of("render:light:review").unwrap();
+ let note = crate::scenario::rect_of("catalog:footer").unwrap();
+ assert!(library.contains_rect(review), "the review action must remain inside the library card: {library:?} {review:?}");
+ assert!(review.bottom() <= note.top(), "the review action must precede supplementary prose");
+ h.step(&json!({"click":{"handle":"render:light:review"}})).unwrap();
+ h.frames(3);
+ let card = crate::scenario::rect_of("review:sphere").unwrap();
+ let replaces = crate::scenario::rect_of("dialog:note:review:replaces").unwrap();
+ let kept = crate::scenario::rect_of("dialog:note:review:kept").unwrap();
+ let ack = crate::scenario::rect_of("render:review:acknowledge").unwrap();
+ assert!(card.bottom() <= replaces.top());
+ assert!(replaces.bottom() <= kept.top());
+ assert!(kept.bottom() <= ack.top());
+ let apply = crate::scenario::rect_of("dialog:ok").unwrap();
+ assert!(ack.bottom() <= apply.top());
+ let dialog = crate::scenario::rect_of("dialog:window").unwrap();
+ for (name, rect) in [("acknowledge", ack), ("apply", apply)] {
+ assert!(dialog.contains_rect(rect), "{name} must remain inside the review dialog: {dialog:?} {rect:?}");
+ assert!(h.ctx.content_rect().contains_rect(rect), "{name} must remain on screen: rect={rect:?}, dark={dark}");
+ }
+ assert!(!h.app.render_workspace.view.library.review.as_ref().unwrap().acknowledged);
+ assert_eq!(h.app.session.doc.to_json(), before);
+ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history);
+ assert!(h.app.render_workspace.view.job.is_none());
+ assert!(h.app.render_workspace.view.completed.is_none());
+ }
+}
+
#[test]
fn ribbon_navigation_reuses_inspector_and_preserves_exact_unsaved_intent() {
let mut h = fixture();
@@ -986,7 +1259,9 @@ fn wear_selection_precedes_output_page_and_appearance_selection_chrome() {
assert!(crate::scenario::rect_of("render:job-footer").is_none());
assert!(crate::scenario::rect_of("render:appearance:close").is_none());
h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap();
- // Select a body again to test recovery of the ordinary Appearance header.
+ // Clearing semantic focus opens Scene; choose Appearance to test its header recovery.
+ assert_eq!(h.app.render_workspace.view.inspector.page, Page::Scene);
+ h.app.render_workspace.view.inspector.page = Page::Appearance;
h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: "Subject".into() }];
h.frames(3);
assert_header(&h, "Subject");
diff --git a/crates/ui-egui/src/render_workspace_library.rs b/crates/ui-egui/src/render_workspace_library.rs
index 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.rs
index 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.rs
new file mode 100644
index 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, &current);
+ 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.rs
index 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.rs
index 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: b
icon_label_presentation(ui, crate::i18n::tr_label(label), Some(icon), enabled, false, danger, false)
}
+/// Icon-only action with an accessible name and tooltip, using the shared action
+/// geometry, enabled state and optional danger ink. Tokens: icon-label action tokens.
+pub(crate) fn icon_action(ui: &mut Ui, label: &str, icon: &str, enabled: bool, danger: bool) -> Response {
+ let response = icon_label_button(ui, "", icon, enabled, danger).on_hover_text(label);
+ response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, enabled && ui.is_enabled(), label));
+ response
+}
+
/// Compact stage actions share the icon-label button's frame, typography and hit target.
pub(super) fn icon_label_width(ui: &Ui, label: &str, icon: Option<&str>, primary: bool) -> f32 {
let t = Tokens::get();
diff --git a/crates/ui-egui/src/ui_kit/fields.rs b/crates/ui-egui/src/ui_kit/fields.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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_compos
r#"
use egui::{Frame as Card, Window as Popup, Modal as Alert};
fn raw(ui: &mut Ui) {
+ let _stage = super::Stage::Frame;
Card::NONE.show(ui, |_| {});
egui::Frame::group(ui.style());
Popup::new("Title"); Alert::new(id);
diff --git a/docs/render-shot-scene.md b/docs/render-shot-scene.md
new file mode 100644
index 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.md
index 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 the
existing Shots manager; Lights **+**, Solo and Mute remain faded with an explicit
diff --git a/docs/ui-kit.md b/docs/ui-kit.md
index 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 galle
covers 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