Render shot editor: camera and frame controls, aspect presets, guides and frame overlay (#6281) (#7232)

* Render shot editor: camera and frame controls, aspect presets, guides and the frame overlay

* Render shot: Shot editor and Scene overview to the approved design

* Distinguish Render stage variants from native window frames

* fix: restore library inspection after clearing shot selection

* test: follow the merged Output Check navigation

* test: inspect Check without requiring a preflight result

* test: cancel Shot removal through its shared dialog action

* fix: remove obsolete Inspector stage form after editor integration

* fix: preserve Appearance Advanced when clearing Wear focus

* test: expect the dedicated Check editor from Scene overview
This commit is contained in:
Nathan Dane authored and GitHub committed 2026-10-29 07:03:24 +00:00
1 parent c7a1cee357
commit d2fcab8432
22 files changed
+2064 -82

No files matched your search

+226
View File
@@ -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"
}
}
@@ -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"
}
}
@@ -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() {
+53
View File
@@ -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() {
@@ -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;
+7
View File
@@ -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" {
+28 -5
View File
@@ -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
}
+116 -51
View File
@@ -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);
}
ui_kit::text(ui, app.tr("render.physical_background_help"), ui_kit::Text::Note("render.physical_background_help"));
for (kind, key) in [("floor_wall", "render.physical_floor_wall"), ("cyclorama", "render.physical_cyclorama")] {
let set = setups::snapshot(app);
let button =
ui_kit::button(ui, app.tr(key), ui_kit::Button::Enabled(set.is_ok() && app.render_workspace.view.method != ImageMethod::Raster));
crate::scenario::publish_target(&format!("render:stage-{kind}"), button.rect);
if button.clicked()
&& let Ok(set) = set
{
let v = &app.render_workspace.view.inspector;
let p = json!({"name":app.render_workspace.view.name,"set":set,"kind":kind,"expected_revision":app.session.revision,
"replace_stage":true,"reflectance_linear":v.ground_color});
library::review::command(app, "render.stage.backdrop", p);
let title = app.tr("render.scene_stages").to_string();
ui_kit::section(ui, "render_scene_stages", &title, true, |ui| {
let view = &app.render_workspace.view;
let overrides = app.session.doc.render.setups.get(&view.name).map_or(0, |s| s.optics.len().saturating_add(s.surfaces.len()));
let looks = super::scene::groups(app).iter().filter(|g| g.look.is_some()).count();
let look = crate::i18n::format("render.scene_look_summary", &[("looks", &looks.to_string()), ("overrides", &overrides.to_string())]);
let light = crate::i18n::format(
"render.scene_light_summary",
&[("environment", &super::scene::environment(app).0), ("lights", &super::scene::light_types(app).len().to_string())],
);
let lens = if app.cam.fov > 0.0 { format!("{:.0}°", app.cam.fov.to_degrees()) } else { app.tr("render.stage_orthographic").to_string() };
let aspect = super::shot::aspect_label(app, &view.draft);
let frame = format!("{} · {lens} · {aspect}", view.name);
let format = if view.studio.export_exr { "EXR" } else { "PNG" };
let output = format!("{} × {} · {format} · {}", view.draft.width, view.draft.height, app.tr(view.method.label()));
for (stage, summary, icon) in [
(super::Stage::Look, look, "appearance"),
(super::Stage::Light, light, "environment_map"),
(super::Stage::Frame, frame, "camera"),
(super::Stage::Output, output, "export"),
] {
let response = ui_kit::tree_row(
ui,
ui.id().with(("scene_stage", stage.key())),
&ui_kit::Row { compact: true, label: app.tr(stage.label()), secondary: &summary, icon, ..Default::default() },
);
if let Some(rect) = response.rect {
crate::scenario::publish_target(&format!("render:scene:{}", stage.key()), rect);
}
if response.clicked {
scene_stage(app, stage);
}
}
library::stage_content(app, ui);
});
let title = app.tr("render.scene_ready").to_string();
ui_kit::section(ui, "render_scene_ready", &title, true, |ui| {
let state = match &app.render_workspace.view.inspector.checked {
Some(check) if check.current(app) && super::image_params(app).as_ref().ok() == Some(&check.request) => crate::i18n::format(
"render.scene_check_passed",
&[("notes", &check.reply.get("warnings").and_then(Value::as_array).map_or(0, Vec::len).to_string())],
),
Some(_) => app.tr("render.scene_check_stale").to_string(),
None => app.tr("render.scene_check_unchecked").to_string(),
};
ui.horizontal_wrapped(|ui| {
ui_kit::text(ui, &state, ui_kit::Text::Inline);
let response = ui_kit::button(ui, app.tr("render.scene_open_check"), ui_kit::Button::Normal);
crate::scenario::publish_target("render:scene:open-check", response.rect);
if response.clicked() {
app.start("render.status");
}
});
if app.render_workspace.view.method == ImageMethod::GpuRaytrace && !matches!(app.render_workspace.path_host, super::PathHost::Ready(_)) {
gpu_status(app, ui);
} else {
let state = super::ribbon::action_ready(app, "render.start");
let text = state.err().unwrap_or_else(|| {
crate::i18n::format("render.scene_renderer_ready", &[("renderer", app.tr(app.render_workspace.view.method.label()))])
});
ui_kit::text(ui, &text, ui_kit::Text::Note("render:scene:renderer"));
}
ui.horizontal_wrapped(|ui| {
for (id, label, command, primary) in
[("check", "render.scene_check_now", "render.preflight", false), ("render", "render.frame_render_shot", "render.start", true)]
{
let ready = super::ribbon::action_ready(app, command);
let response = ui_kit::icon_label_action(ui, app.tr(label), None, ready.is_ok(), primary);
crate::scenario::publish_target(&format!("render:scene:{id}"), response.rect);
if let Err(reason) = ready {
response.clone().on_disabled_hover_text(reason);
}
if response.clicked()
&& let Err(error) = super::ribbon::perform_job(app, command)
{
app.set_status(error, true);
}
}
});
let label = crate::i18n::format("render.scene_all_shots", &[("count", &app.session.doc.render.setups.len().to_string())]);
let response = ui_kit::button(ui, &label, ui_kit::Button::Enabled(false));
crate::scenario::publish_target("render:scene:all-shots", response.rect);
ui_kit::text(ui, app.tr("render.scene_batch_reason"), ui_kit::Text::Note("render.scene_batch_reason"));
});
let title = app.tr("render.scene_reminders").to_string();
ui_kit::section(ui, "render_scene_reminders", &title, true, |ui| {
ui_kit::text(ui, app.tr("render.scene_reminder"), ui_kit::Text::Note("render.scene_preserves_design"));
});
}
fn scene_stage(app: &mut SolveApp, stage: super::Stage) {
let name = app.render_workspace.view.name.clone();
let _ = app.run("view.render_stage", json!({"stage":stage.key()}));
let params = match stage {
super::Stage::Look => json!({"kind":"nothing"}),
super::Stage::Light => json!({"kind":"environment"}),
super::Stage::Frame if app.session.doc.render.setups.contains_key(&name) => json!({"kind":"shot","id":name}),
super::Stage::Frame => json!({"kind":"nothing"}),
super::Stage::Output => json!({"kind":"output"}),
};
let _ = app.run("view.render_select", params);
app.render_workspace.view.inspector.page = stage.page();
}
#[cfg(test)]
fn shot_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
let title = app.tr("render.shot_manager").to_string();
reveal_section(app, ui, "render_shot_manager");
@@ -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");
@@ -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();
@@ -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) });
+511
View File
@@ -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);
},
);
}
+202 -7
View File
@@ -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()));
+8
View File
@@ -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();
+28
View File
@@ -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))]
+112
View File
@@ -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);
}
}
+24
View File
@@ -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",
+2
View File
@@ -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};
+5 -1
View File
@@ -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);
+47
View File
@@ -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.
+14
View File
@@ -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
+11
View File
@@ -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