Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Render output: Output editor, size presets, Check list, Copy, progress pill and result viewer (#6281) (#6433)

Nathan Dane85a60c1af620
diff --git a/assets/locales/pending/render-output-gpu-help.json b/assets/locales/pending/render-output-gpu-help.json
new file mode 100644
index 0000000000..00fd8f684e
--- /dev/null
+++ b/assets/locales/pending/render-output-gpu-help.json
@@ -0,0 +1,8 @@
+{
+ "de": {
+ "render.effects_gpu_only": "Diese Effekte erfordern GPU-Pfadverfolgung. Ein Seitenwechsel schaltet den Renderer niemals automatisch um."
+ },
+ "ko": {
+ "render.effects_gpu_only": "이 효과를 사용하려면 GPU 경로 추적이 필요합니다. 페이지를 바꿔도 렌더러는 자동으로 전환되지 않습니다."
+ }
+}
diff --git a/assets/locales/pending/render-output-viewer.json b/assets/locales/pending/render-output-viewer.json
new file mode 100644
index 0000000000..f221c07610
--- /dev/null
+++ b/assets/locales/pending/render-output-viewer.json
@@ -0,0 +1,394 @@
+{
+ "en": {
+ "cmd.render_lights_add": "Add Light",
+ "cmd.render_output_size": "Set Render Output Size",
+ "cmd.render_result_close": "Close Render Image",
+ "cmd.render_result_copy": "Copy Render Image",
+ "cmd.render_result_view": "View Render Image",
+ "render.check_opaque": "Transparency: opaque surfaces only; background alpha is supported.",
+ "render.check_sorted_alpha": "Transparency: sorted alpha approximation.",
+ "render.check_transmission": "Transparency: physical transmission.",
+ "render.output_advanced": "Advanced",
+ "render.output_backend_ready": "Ready",
+ "render.output_check": "Check",
+ "render.output_check_help": "Run Check to review this request without starting a render.",
+ "render.output_check_summary": "Check · Notes: {count}",
+ "render.output_copy": "Copy",
+ "render.output_destination": "Destination",
+ "render.output_destination_help": "Choose the destination file when exporting the completed image.",
+ "render.output_dimensions": "Size",
+ "render.output_effects": "Effects",
+ "render.output_export": "Export PNG…",
+ "render.output_exr_unavailable": "EXR output setup is unavailable here. Linear EXR export requires a completed GPU image with a retained linear master.",
+ "render.output_fit": "Fit",
+ "render.output_format": "Format",
+ "render.output_image": "Image",
+ "render.output_largest": "{width} × {height} max",
+ "render.output_presets_help": "Format, quality and the Check list are in the Output editor.",
+ "render.output_quality": "Quality",
+ "render.output_quality_waiting": "waiting for the quality contract",
+ "render.output_ready": "Ready to render",
+ "render.output_size_ok": "Size OK · {width} × {height} px",
+ "render.output_view_image": "View image",
+ "render.quality_balanced": "Balanced",
+ "render.quality_custom": "Custom",
+ "render.quality_draft": "Draft",
+ "render.quality_high": "High",
+ "render.radial_assign": "Assign Appearance",
+ "render.radial_compare": "Compare",
+ "render.radial_fit": "Fit Product",
+ "render.radial_save": "Save Shot",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "Custom…",
+ "render.size_preview": "Preview",
+ "render.size_square": "Square",
+ "render.state_completed": "Completed image",
+ "render.state_in_progress": "Image in progress",
+ "render.state_model": "Model Preview",
+ "render.wait_add_light": "not supported yet: named light creation"
+ },
+ "de": {
+ "cmd.render_lights_add": "Licht hinzufügen",
+ "cmd.render_output_size": "Render-Ausgabegröße festlegen",
+ "cmd.render_result_close": "Renderbild schließen",
+ "cmd.render_result_copy": "Renderbild kopieren",
+ "cmd.render_result_view": "Renderbild anzeigen",
+ "render.check_opaque": "Transparenz: nur undurchsichtige Oberflächen; Hintergrund-Alpha wird unterstützt.",
+ "render.check_sorted_alpha": "Transparenz: Näherung mit sortiertem Alpha.",
+ "render.check_transmission": "Transparenz: physikalische Transmission.",
+ "render.output_advanced": "Erweitert",
+ "render.output_backend_ready": "Bereit",
+ "render.output_check": "Prüfen",
+ "render.output_check_help": "Prüfen bewertet diese Anfrage, ohne einen Renderauftrag zu starten.",
+ "render.output_check_summary": "Prüfen · Hinweise: {count}",
+ "render.output_copy": "Kopieren",
+ "render.output_destination": "Ziel",
+ "render.output_destination_help": "Die Zieldatei wird beim Exportieren des fertigen Bildes gewählt.",
+ "render.output_dimensions": "Größe",
+ "render.output_effects": "Effekte",
+ "render.output_export": "PNG exportieren…",
+ "render.output_exr_unavailable": "EXR-Ausgabeeinstellungen sind hier nicht verfügbar. Linearer EXR-Export erfordert ein fertiges GPU-Bild mit gespeichertem linearem Original.",
+ "render.output_fit": "Einpassen",
+ "render.output_format": "Format",
+ "render.output_image": "Bild",
+ "render.output_largest": "{width} × {height} max.",
+ "render.output_presets_help": "Format, Qualität und Prüfliste befinden sich im Ausgabeeditor.",
+ "render.output_quality": "Qualität",
+ "render.output_quality_waiting": "Qualitätsdefinition steht noch aus",
+ "render.output_ready": "Bereit zum Rendern",
+ "render.output_size_ok": "Größe OK · {width} × {height} px",
+ "render.output_view_image": "Bild anzeigen",
+ "render.quality_balanced": "Ausgewogen",
+ "render.quality_custom": "Benutzerdefiniert",
+ "render.quality_draft": "Entwurf",
+ "render.quality_high": "Hoch",
+ "render.radial_assign": "Erscheinungsbild zuweisen",
+ "render.radial_compare": "Vergleichen",
+ "render.radial_fit": "Produkt einpassen",
+ "render.radial_save": "Aufnahme speichern",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "Benutzerdefiniert…",
+ "render.size_preview": "Vorschau",
+ "render.size_square": "Quadrat",
+ "render.state_completed": "Fertiges Bild",
+ "render.state_in_progress": "Bild in Bearbeitung",
+ "render.state_model": "Modellvorschau",
+ "render.wait_add_light": "Noch nicht unterstützt: benannte Lichtquellen erstellen"
+ },
+ "ja": {
+ "cmd.render_lights_add": "ライトを追加",
+ "cmd.render_output_size": "レンダー出力サイズを設定",
+ "cmd.render_result_close": "レンダー画像を閉じる",
+ "cmd.render_result_copy": "レンダー画像をコピー",
+ "cmd.render_result_view": "レンダー画像を表示",
+ "render.check_opaque": "透明度:不透明サーフェスのみ。背景アルファに対応。",
+ "render.check_sorted_alpha": "透明度:ソート済みアルファによる近似。",
+ "render.check_transmission": "透明度:物理透過。",
+ "render.output_advanced": "詳細設定",
+ "render.output_backend_ready": "準備完了",
+ "render.output_check": "チェック",
+ "render.output_check_help": "チェックを実行すると、レンダーを開始せずにリクエストを確認できます。",
+ "render.output_check_summary": "チェック · {count}件の注意",
+ "render.output_copy": "コピー",
+ "render.output_destination": "保存先",
+ "render.output_destination_help": "完了した画像をエクスポートするときに保存先ファイルを選択します。",
+ "render.output_dimensions": "サイズ",
+ "render.output_effects": "エフェクト",
+ "render.output_export": "PNGを書き出す…",
+ "render.output_exr_unavailable": "ここではEXR出力設定を利用できません。リニアEXR書き出しには、リニアマスターを保持した完成GPU画像が必要です。",
+ "render.output_fit": "全体表示",
+ "render.output_format": "形式",
+ "render.output_image": "画像",
+ "render.output_largest": "{width} × {height} 最大",
+ "render.output_presets_help": "形式、品質、チェックリストは出力エディターにあります。",
+ "render.output_quality": "品質",
+ "render.output_quality_waiting": "品質仕様の確定待ち",
+ "render.output_ready": "レンダーの準備完了",
+ "render.output_size_ok": "サイズOK · {width} × {height} px",
+ "render.output_view_image": "画像を表示",
+ "render.quality_balanced": "バランス",
+ "render.quality_custom": "カスタム",
+ "render.quality_draft": "ドラフト",
+ "render.quality_high": "高品質",
+ "render.radial_assign": "外観を割り当て",
+ "render.radial_compare": "比較",
+ "render.radial_fit": "製品をフィット",
+ "render.radial_save": "ショットを保存",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "カスタム…",
+ "render.size_preview": "プレビュー",
+ "render.size_square": "正方形",
+ "render.state_completed": "完成画像",
+ "render.state_in_progress": "画像を生成中",
+ "render.state_model": "モデルプレビュー",
+ "render.wait_add_light": "未対応:名前付きライトの作成"
+ },
+ "zh": {
+ "cmd.render_lights_add": "添加灯光",
+ "cmd.render_output_size": "设置渲染输出尺寸",
+ "cmd.render_result_close": "关闭渲染图像",
+ "cmd.render_result_copy": "复制渲染图像",
+ "cmd.render_result_view": "查看渲染图像",
+ "render.check_opaque": "透明度:仅不透明表面;支持背景 Alpha。",
+ "render.check_sorted_alpha": "透明度:排序 Alpha 近似。",
+ "render.check_transmission": "透明度:物理透射。",
+ "render.output_advanced": "高级",
+ "render.output_backend_ready": "就绪",
+ "render.output_check": "检查",
+ "render.output_check_help": "运行检查可审查此请求,而不启动渲染。",
+ "render.output_check_summary": "检查 · {count} 条提示",
+ "render.output_copy": "复制",
+ "render.output_destination": "目标位置",
+ "render.output_destination_help": "导出已完成的图像时选择目标文件。",
+ "render.output_dimensions": "尺寸",
+ "render.output_effects": "效果",
+ "render.output_export": "导出 PNG…",
+ "render.output_exr_unavailable": "此处无法设置 EXR 输出。线性 EXR 导出需要保留线性母版的已完成 GPU 图像。",
+ "render.output_fit": "适合窗口",
+ "render.output_format": "格式",
+ "render.output_image": "图像",
+ "render.output_largest": "{width} × {height} 最大",
+ "render.output_presets_help": "格式、质量和检查列表位于输出编辑器中。",
+ "render.output_quality": "质量",
+ "render.output_quality_waiting": "等待质量约定",
+ "render.output_ready": "已就绪,可渲染",
+ "render.output_size_ok": "尺寸正常 · {width} × {height} px",
+ "render.output_view_image": "查看图像",
+ "render.quality_balanced": "均衡",
+ "render.quality_custom": "自定义",
+ "render.quality_draft": "草稿",
+ "render.quality_high": "高",
+ "render.radial_assign": "指定外观",
+ "render.radial_compare": "比较",
+ "render.radial_fit": "适配产品",
+ "render.radial_save": "保存镜头",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "自定义…",
+ "render.size_preview": "预览",
+ "render.size_square": "正方形",
+ "render.state_completed": "已完成图像",
+ "render.state_in_progress": "图像生成中",
+ "render.state_model": "模型预览",
+ "render.wait_add_light": "尚不支持:创建命名灯光"
+ },
+ "ko": {
+ "cmd.render_lights_add": "조명 추가",
+ "cmd.render_output_size": "렌더 출력 크기 설정",
+ "cmd.render_result_close": "렌더 이미지 닫기",
+ "cmd.render_result_copy": "렌더 이미지 복사",
+ "cmd.render_result_view": "렌더 이미지 보기",
+ "render.check_opaque": "투명도: 불투명 표면만 지원하며 배경 알파를 지원합니다.",
+ "render.check_sorted_alpha": "투명도: 정렬된 알파 근사.",
+ "render.check_transmission": "투명도: 물리적 투과.",
+ "render.output_advanced": "고급",
+ "render.output_backend_ready": "준비 완료",
+ "render.output_check": "확인",
+ "render.output_check_help": "확인을 실행하면 렌더링을 시작하지 않고 요청을 검토합니다.",
+ "render.output_check_summary": "검사 · 참고 {count}개",
+ "render.output_copy": "복사",
+ "render.output_destination": "저장 위치",
+ "render.output_destination_help": "완성된 이미지를 내보낼 때 대상 파일을 선택합니다.",
+ "render.output_dimensions": "크기",
+ "render.output_effects": "효과",
+ "render.output_export": "PNG 내보내기…",
+ "render.output_exr_unavailable": "여기서는 EXR 출력을 설정할 수 없습니다. 선형 EXR 내보내기에는 선형 원본을 보관한 완료된 GPU 이미지가 필요합니다.",
+ "render.output_fit": "맞춤",
+ "render.output_format": "형식",
+ "render.output_image": "이미지",
+ "render.output_largest": "{width} × {height} 최대",
+ "render.output_presets_help": "형식, 품질 및 검사 목록은 출력 편집기에 있습니다.",
+ "render.output_quality": "품질",
+ "render.output_quality_waiting": "품질 규약 대기 중",
+ "render.output_ready": "렌더링 준비 완료",
+ "render.output_size_ok": "크기 정상 · {width} × {height} px",
+ "render.output_view_image": "이미지 보기",
+ "render.quality_balanced": "균형",
+ "render.quality_custom": "사용자 지정",
+ "render.quality_draft": "초안",
+ "render.quality_high": "높음",
+ "render.radial_assign": "외관 지정",
+ "render.radial_compare": "비교",
+ "render.radial_fit": "제품 맞추기",
+ "render.radial_save": "샷 저장",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "사용자 지정…",
+ "render.size_preview": "미리보기",
+ "render.size_square": "정사각형",
+ "render.state_completed": "완료된 이미지",
+ "render.state_in_progress": "이미지 생성 중",
+ "render.state_model": "모델 미리보기",
+ "render.wait_add_light": "아직 지원되지 않음: 이름이 있는 조명 만들기"
+ },
+ "ar": {
+ "cmd.render_lights_add": "إضافة ضوء تصيير",
+ "cmd.render_output_size": "ضبط حجم مخرجات التصيير",
+ "cmd.render_result_close": "إغلاق صورة التصيير",
+ "cmd.render_result_copy": "نسخ صورة التصيير",
+ "cmd.render_result_view": "عرض صورة التصيير",
+ "render.check_opaque": "الشفافية: أسطح معتمة فقط؛ ألفا الخلفية مدعومة.",
+ "render.check_sorted_alpha": "الشفافية: تقريب ألفا مرتّب.",
+ "render.check_transmission": "الشفافية: نفاذية فيزيائية.",
+ "render.output_advanced": "متقدم",
+ "render.output_backend_ready": "جاهز",
+ "render.output_check": "فحص",
+ "render.output_check_help": "شغّل الفحص لمراجعة هذا الطلب دون بدء التصيير.",
+ "render.output_check_summary": "فحص · ملاحظات: {count}",
+ "render.output_copy": "نسخ",
+ "render.output_destination": "الوجهة",
+ "render.output_destination_help": "اختر ملف الوجهة عند تصدير الصورة المكتملة.",
+ "render.output_dimensions": "الحجم",
+ "render.output_effects": "المؤثرات",
+ "render.output_export": "تصدير PNG…",
+ "render.output_exr_unavailable": "إعداد مخرجات EXR غير متاح هنا. تصدير EXR الخطي يتطلب صورة GPU مكتملة بنسخة رئيسية خطية محتفظ بها.",
+ "render.output_fit": "ملاءمة",
+ "render.output_format": "الصيغة",
+ "render.output_image": "الصورة",
+ "render.output_largest": "الأقصى {width} × {height}",
+ "render.output_presets_help": "الصيغة والجودة وقائمة الفحص في محرر المخرجات.",
+ "render.output_quality": "الجودة",
+ "render.output_quality_waiting": "بانتظار عقد الجودة",
+ "render.output_ready": "جاهز للتصيير",
+ "render.output_size_ok": "الحجم مناسب · {width} × {height} بكسل",
+ "render.output_view_image": "عرض الصورة",
+ "render.quality_balanced": "متوازن",
+ "render.quality_custom": "مخصص",
+ "render.quality_draft": "مسودة",
+ "render.quality_high": "عالية",
+ "render.radial_assign": "تعيين مظهر",
+ "render.radial_compare": "مقارنة",
+ "render.radial_fit": "ملاءمة المنتج",
+ "render.radial_save": "حفظ اللقطة",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "مخصص…",
+ "render.size_preview": "معاينة",
+ "render.size_square": "مربع",
+ "render.state_completed": "صورة مكتملة",
+ "render.state_in_progress": "صورة قيد الإنجاز",
+ "render.state_model": "معاينة النموذج",
+ "render.wait_add_light": "غير مدعوم بعد: إنشاء الأضواء المسمّاة"
+ },
+ "he": {
+ "cmd.render_lights_add": "הוסף אור רינדור",
+ "cmd.render_output_size": "הגדר גודל פלט רינדור",
+ "cmd.render_result_close": "סגור תמונת רינדור",
+ "cmd.render_result_copy": "העתק תמונת רינדור",
+ "cmd.render_result_view": "הצג תמונת רינדור",
+ "render.check_opaque": "שקיפות: משטחים אטומים בלבד; אלפא של הרקע נתמכת.",
+ "render.check_sorted_alpha": "שקיפות: קירוב אלפא ממוין.",
+ "render.check_transmission": "שקיפות: מעבר אור פיזיקלי.",
+ "render.output_advanced": "מתקדם",
+ "render.output_backend_ready": "מוכן",
+ "render.output_check": "בדיקה",
+ "render.output_check_help": "הפעל בדיקה כדי לסקור בקשה זו בלי להתחיל רינדור.",
+ "render.output_check_summary": "בדיקה · הערות: {count}",
+ "render.output_copy": "העתק",
+ "render.output_destination": "יעד",
+ "render.output_destination_help": "בחר את קובץ היעד בעת ייצוא התמונה שהושלמה.",
+ "render.output_dimensions": "גודל",
+ "render.output_effects": "אפקטים",
+ "render.output_export": "ייצא PNG…",
+ "render.output_exr_unavailable": "הגדרת פלט EXR אינה זמינה כאן. ייצוא EXR לינארי דורש תמונת GPU שהושלמה עם מאסטר לינארי שנשמר.",
+ "render.output_fit": "התאם",
+ "render.output_format": "פורמט",
+ "render.output_image": "תמונה",
+ "render.output_largest": "מקס׳ {width} × {height}",
+ "render.output_presets_help": "פורמט, איכות ורשימת הבדיקה נמצאים בעורך הפלט.",
+ "render.output_quality": "איכות",
+ "render.output_quality_waiting": "ממתין לחוזה האיכות",
+ "render.output_ready": "מוכן לרינדור",
+ "render.output_size_ok": "הגודל תקין · {width} × {height} פיקסלים",
+ "render.output_view_image": "הצג תמונה",
+ "render.quality_balanced": "מאוזן",
+ "render.quality_custom": "מותאם",
+ "render.quality_draft": "טיוטה",
+ "render.quality_high": "גבוהה",
+ "render.radial_assign": "הקצה מראה",
+ "render.radial_compare": "השוואה",
+ "render.radial_fit": "התאם מוצר",
+ "render.radial_save": "שמור צילום",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "מותאם…",
+ "render.size_preview": "תצוגה מקדימה",
+ "render.size_square": "ריבוע",
+ "render.state_completed": "תמונה שהושלמה",
+ "render.state_in_progress": "תמונה בתהליך",
+ "render.state_model": "תצוגת מודל",
+ "render.wait_add_light": "לא נתמך עדיין: יצירת אורות בעלי שם"
+ },
+ "vi": {
+ "cmd.render_lights_add": "Thêm đèn kết xuất",
+ "cmd.render_output_size": "Đặt kích thước đầu ra kết xuất",
+ "cmd.render_result_close": "Đóng ảnh kết xuất",
+ "cmd.render_result_copy": "Sao chép ảnh kết xuất",
+ "cmd.render_result_view": "Xem ảnh kết xuất",
+ "render.check_opaque": "Độ trong suốt: chỉ bề mặt đục; hỗ trợ alpha của phông nền.",
+ "render.check_sorted_alpha": "Độ trong suốt: xấp xỉ alpha có sắp thứ tự.",
+ "render.check_transmission": "Độ trong suốt: truyền sáng vật lý.",
+ "render.output_advanced": "Nâng cao",
+ "render.output_backend_ready": "Sẵn sàng",
+ "render.output_check": "Kiểm tra",
+ "render.output_check_help": "Chạy Kiểm tra để xem lại yêu cầu này mà không bắt đầu kết xuất.",
+ "render.output_check_summary": "Kiểm tra · Ghi chú: {count}",
+ "render.output_copy": "Sao chép",
+ "render.output_destination": "Đích",
+ "render.output_destination_help": "Chọn tệp đích khi xuất ảnh đã hoàn tất.",
+ "render.output_dimensions": "Kích thước",
+ "render.output_effects": "Hiệu ứng",
+ "render.output_export": "Xuất PNG…",
+ "render.output_exr_unavailable": "Thiết lập đầu ra EXR không khả dụng ở đây. Xuất EXR tuyến tính cần ảnh GPU đã hoàn tất với bản gốc tuyến tính được giữ lại.",
+ "render.output_fit": "Vừa khít",
+ "render.output_format": "Định dạng",
+ "render.output_image": "Ảnh",
+ "render.output_largest": "Tối đa {width} × {height}",
+ "render.output_presets_help": "Định dạng, chất lượng và danh sách Kiểm tra nằm trong trình chỉnh Đầu ra.",
+ "render.output_quality": "Chất lượng",
+ "render.output_quality_waiting": "đang chờ hợp đồng chất lượng",
+ "render.output_ready": "Sẵn sàng kết xuất",
+ "render.output_size_ok": "Kích thước ổn · {width} × {height} px",
+ "render.output_view_image": "Xem ảnh",
+ "render.quality_balanced": "Cân bằng",
+ "render.quality_custom": "Tùy chỉnh",
+ "render.quality_draft": "Bản nháp",
+ "render.quality_high": "Cao",
+ "render.radial_assign": "Gán diện mạo",
+ "render.radial_compare": "So sánh",
+ "render.radial_fit": "Vừa sản phẩm",
+ "render.radial_save": "Lưu cảnh chụp",
+ "render.result_actual": "100%",
+ "render.size_4k": "4K",
+ "render.size_custom": "Tùy chỉnh…",
+ "render.size_preview": "Xem trước",
+ "render.size_square": "Vuông",
+ "render.state_completed": "Ảnh đã hoàn tất",
+ "render.state_in_progress": "Ảnh đang tạo",
+ "render.state_model": "Xem trước mô hình",
+ "render.wait_add_light": "chưa hỗ trợ: tạo đèn có tên"
+ }
+}
diff --git a/crates/engine/src/cmd/render.rs b/crates/engine/src/cmd/render.rs
index 7586235fe7..91caaba51d 100644
--- a/crates/engine/src/cmd/render.rs
+++ b/crates/engine/src/cmd/render.rs
@@ -95,12 +95,14 @@ CommandSpec::new("render.settings.capture_hdr", "Save Render Settings with HDR",
.params("name, set: typed CPU/GPU setup patch with hdr/environment unset; path: scoped HDR; expected_sha256?: digest returned by render.hdr.inspect (changed sources refuse); rotation_rad?:0, intensity?:1; samples?:1/4/16/64 for CPU only (default16); assume_linear_srgb?:false for GPU only. Captures immutable bytes and saves resource plus setup atomically in one undo, without a host; returns name/setup/resource metadata, never source bytes"),
CommandSpec::new("render.preflight", "Check Render Request", jobs::preflight).icon("inspect").noundo().doc_only()
.params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace may accompany it. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; no area/LED, anisotropy or dielectrics in this initial mode. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16/64 for the whole strip, default16. At most8directional+8punctual+4rectangle/LED sources; shared area N. See docs/render-light-union.md. transparent_background?: false; replace?: false. With progressive:true, raytrace instead accepts GPU dielectrics/clear_coats/textures; environment instead accepts tagged hdr/embedded_hdr/sky with rotation_rad/intensity; file hdr supports expected_sha256, embedded_hdr uses a document resource digest. See docs/render-hdr-resources.md. GPU lens, studio lighting, tone_map, denoise, bounded finishing/backdrop and linear_exr retention are also available. GPU adaptive?: {pilot_samples:16..256,min_samples:16..samples,relative_error:0..1,absolute_error:0.000001..1000000,coverage_error:0.001..0.25} allocates independent production budgets; pilots are discarded, not a certified error guarantee. transmission_samples?:1|2|4 stratifies the first Fresnel branch with extra path cost. volume?:{min_mm:[x,y,z],max_mm:[x,y,z],extinction_per_mm:0..1000,scattering_albedo:[r,g,b],anisotropy:-0.95..0.95} is one finite homogeneous world-mm medium; active media require explicit lighting/environment and refuse glass, denoise and multiple transmission strata. These fields also persist in GPU job.options. See docs/render-materials/TRANSPORT-MASTER-BATCH-2026-10-23.md; see docs/render-transmission.md, render-environment.md, render-runtime-textures.md, render-thin-lens.md, render-studio-lighting.md and render-denoise.md. Optional CPU raytracing requires a raytrace-cpu build and native host, checked before scene capture. Stale geometry is rejected. See docs/render-jobs.md"),
-CommandSpec::new("render.start", "Render Image", jobs::start).noundo().doc_only().at("RENDER", "IMAGE").icon("render_image")
+CommandSpec::new("render.start", "Render Image", jobs::start).key("R").noundo().doc_only().at("RENDER", "IMAGE").icon("render_image")
.params("Same request as render.preflight. Captures an immutable product scene and queues a bounded image job. Returns its session-scoped job identity, captured scene_generation and progress. Does not change the design. See docs/render-jobs.md"),
CommandSpec::new("render.status", "Render Progress", jobs::status).icon("list").noundo().doc_only()
.params("job: {session, serial, generation}. Non-blocking progress, error, optional CPU preview metadata {frame_sequence,samples_per_pixel,frame}, and completed frame metadata, optional sampling allocation/work counts and retained-master presentation provenance; no image bytes and no rendering in this call. Preview is separate from the exportable final image."),
CommandSpec::new("render.cancel", "Cancel Render", jobs::cancel).icon("delete").noundo().doc_only()
.params("job: {session, serial, generation}. Requests cooperative cancellation; completed jobs remain completed. Late cancelled frames cannot be published."),
+CommandSpec::new("render.result.copy", "Copy Render Image", jobs::copy).icon("copy").noundo().doc_only()
+ .params("job: completed JobId. Validates the retained PNG for app clipboard copying (max 4096 per side, 4194304 pixels); headless returns frame metadata only. Never copies a provisional image or starts a job."),
CommandSpec::new("render.export", "Export Render Image", jobs::export).icon("export").noundo().doc_only()
.params("job: {session, serial, generation}, path: destination matching format?: png (default) or exr, overwrite?: false. EXR requires an opt-in raw linear master retained by that completed GPU job; never converts PNG pixels. Exports a retained completed image atomically; an existing destination is preserved on failure. See docs/render-jobs.md"),
CommandSpec::new("render.backends", "Render Backends", backends).icon("list")
diff --git a/crates/engine/src/cmd/render/job_tests.rs b/crates/engine/src/cmd/render/job_tests.rs
index b534d34381..32c14c78c9 100644
--- a/crates/engine/src/cmd/render/job_tests.rs
+++ b/crates/engine/src/cmd/render/job_tests.rs
@@ -1197,3 +1197,22 @@ fn a_setup_saved_with_exposure_renders_and_names_the_controls_it_leaves_out() {
let id: JobId = serde_json::from_value(started["job"].clone()).unwrap();
assert_eq!(s.execute("render.status", &json!({"job":id})).unwrap()["progress"]["phase"], "completed");
}
+
+#[test]
+fn output_viewer_copy_validates_completed_job_without_mutation_or_pixel_payloads() {
+ let (mut s, host) = session();
+ let job = start(&mut s);
+ assert!(s.execute("render.result.copy", &json!({"job":job})).is_err());
+ finish(&host);
+ let document = s.doc.clone();
+ let before = (s.revision, s.undo.len(), s.redo.len(), host.admitted_bytes());
+ let copied = s.execute("render.result.copy", &json!({"job":job})).unwrap();
+ assert_eq!(copied["frame"]["job"], json!(job));
+ assert_eq!(copied["frame"]["width"], 16);
+ assert!(copied.get("png").is_none());
+ for params in [json!({}), json!(null), json!({"job":job,"extra":true}), json!({"job":{"session":0,"serial":0,"generation":0}})] {
+ assert!(s.execute("render.result.copy", &params).is_err());
+ }
+ assert!(Arc::ptr_eq(&document, &s.doc));
+ assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), host.admitted_bytes()));
+}
diff --git a/crates/engine/src/cmd/render/jobs.rs b/crates/engine/src/cmd/render/jobs.rs
index 93932c9d22..8d38c05b0c 100644
--- a/crates/engine/src/cmd/render/jobs.rs
+++ b/crates/engine/src/cmd/render/jobs.rs
@@ -706,6 +706,22 @@ pub(super) fn pin(s: &mut Session, params: &Value) -> Result<Value> {
Ok(json!({"frame":s.render_jobs.pin(input.job).map_err(job_error)?}))
}
+pub(super) fn copy(s: &mut Session, params: &Value) -> Result<Value> {
+ let input: Job = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.copy", e.to_string()))?;
+ let frame = s
+ .render_jobs
+ .handle(input.job)
+ .map_err(job_error)?
+ .frame()
+ .map_err(job_error)?
+ .ok_or_else(|| bad("render.result.copy", "render has no completed image"))?;
+ let size = (u64::from(frame.info.width), u64::from(frame.info.height));
+ if solidcraft_render::RenderLimits::default().fit(size.0, size.1, None) != Some(size) {
+ return Err(bad("render.result.copy", "clipboard image exceeds 4096 per side or 4194304 pixels; export the PNG instead"));
+ }
+ Ok(json!({"frame":frame.info}))
+}
+
pub(super) fn cancel(s: &mut Session, params: &Value) -> Result<Value> {
let input: Job = serde_json::from_value(params.clone()).map_err(|e| bad("render.cancel", e.to_string()))?;
let status = s.render_jobs.status(input.job).map_err(job_error)?;
diff --git a/crates/engine/src/cmd/render_ui.rs b/crates/engine/src/cmd/render_ui.rs
index 148c75380c..167cef2ef0 100644
--- a/crates/engine/src/cmd/render_ui.rs
+++ b/crates/engine/src/cmd/render_ui.rs
@@ -1,5 +1,8 @@
//! Planned Render interactions, with explicit non-mutating refusals.
use super::CommandSpec;
+use crate::{Result, Session, params::bad};
+use serde::Deserialize;
+use serde_json::{Value, json};
macro_rules! waiting {
($id:literal, $label:literal, $tab:literal, $panel:literal, $icon:literal, $reason:literal) => {
@@ -15,6 +18,23 @@ macro_rules! waiting {
}
pub static COMMANDS: &[CommandSpec] = &[
+ CommandSpec::new("render.output.size", "Set Render Output Size", output_size)
+ .icon("settings")
+ .noundo()
+ .doc_only()
+ .params("width, height: 1..16384; custom?: bool. Validated Render output draft request; headless echo only, no design edits or job."),
+ CommandSpec::new("render.result.view", "View Render Image", result_view)
+ .icon("render_image")
+ .noundo()
+ .doc_only()
+ .params("view: model|image|fit|actual. Validated result canvas request; headless echo only, never starts a job."),
+ CommandSpec::new("render.result.close", "Close Render Image", close_result)
+ .icon("close")
+ .key("Escape")
+ .noundo()
+ .doc_only()
+ .params("No parameters. Return to Model Preview; headless echo only, never cancels a job."),
+ waiting!("render.lights.add", "Add Light", "RENDER SCENE", "LIGHTS", "render_scene", "named light creation"),
waiting!("appearance.paint", "Paint Appearance", "RENDER APPEARANCE", "APPEARANCE", "appearance", "product picking and appearance painting"),
waiting!("appearance.pick_up", "Pick Up Appearance", "RENDER APPEARANCE", "APPEARANCE", "select", "product picking and appearance sampling"),
waiting!("render.lights.solo", "Solo Light", "RENDER SCENE", "LIGHTS", "render_scene", "light visibility and solo controls"),
@@ -26,6 +46,7 @@ pub static COMMANDS: &[CommandSpec] = &[
#[test]
fn render_workspace_planned_commands_refuse_without_mutation() {
use serde_json::{Value, json};
+ assert!(super::find_command("appearance.replace").is_some_and(|command| command.planned.is_none()));
let mut session = crate::Session::default();
session.execute("render.settings.set", &json!({"name":"Studio","set":{"width":800}})).unwrap();
session.execute("render.settings.set", &json!({"name":"Studio","set":{"width":900}})).unwrap();
@@ -33,7 +54,9 @@ fn render_workspace_planned_commands_refuse_without_mutation() {
let document = session.doc.clone();
let before = (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty());
for command in COMMANDS {
- assert!(command.planned.is_some());
+ if command.planned.is_none() {
+ continue;
+ }
assert!(!command.info(&session).enabled);
for params in [json!({}), Value::Null, json!([]), json!({"target":1e300,"name":"hostile"})] {
let error = session.execute(command.id, &params).unwrap_err().to_string();
@@ -43,3 +66,74 @@ fn render_workspace_planned_commands_refuse_without_mutation() {
}
}
}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct OutputSize {
+ width: u32,
+ height: u32,
+ #[serde(default)]
+ custom: bool,
+}
+fn output_size(_: &mut Session, params: &Value) -> Result<Value> {
+ let input: OutputSize = serde_json::from_value(params.clone()).map_err(|e| bad("render.output.size", e.to_string()))?;
+ if !(1..=16384).contains(&input.width) || !(1..=16384).contains(&input.height) {
+ return Err(bad("render.output.size", "dimensions must be in 1..16384"));
+ }
+ let mut reply = json!({"width":input.width,"height":input.height});
+ if input.custom {
+ reply["custom"] = json!(true);
+ }
+ Ok(reply)
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ResultView {
+ view: String,
+}
+fn result_view(_: &mut Session, params: &Value) -> Result<Value> {
+ let input: ResultView = serde_json::from_value(params.clone()).map_err(|e| bad("render.result.view", e.to_string()))?;
+ if !matches!(input.view.as_str(), "model" | "image" | "fit" | "actual") {
+ return Err(bad("render.result.view", "view must be model, image, fit or actual"));
+ }
+ Ok(json!({"view":input.view}))
+}
+fn close_result(_: &mut Session, params: &Value) -> Result<Value> {
+ if !params.as_object().is_some_and(|p| p.is_empty()) {
+ return Err(bad("render.result.close", "expected no parameters"));
+ }
+ Ok(json!({"view":"model"}))
+}
+
+#[cfg(test)]
+#[test]
+fn output_viewer_requests_are_validated_headless_echoes() {
+ let mut s = Session::default();
+ let document = s.doc.clone();
+ let before = (s.revision, s.undo.len(), s.evaluations);
+ for size in [json!({"width":1280,"height":720}), json!({"width":1920,"height":1080})] {
+ assert_eq!(s.execute("render.output.size", &size).unwrap(), size);
+ }
+ let custom = json!({"width":1920,"height":1080,"custom":true});
+ assert_eq!(s.execute("render.output.size", &custom).unwrap(), custom);
+ assert!(s.execute("render.output.size", &json!({"width":1920,"height":1080,"custom":"yes"})).is_err());
+ for view in ["model", "image", "fit", "actual"] {
+ let request = json!({"view":view});
+ assert_eq!(s.execute("render.result.view", &request).unwrap(), request);
+ }
+ assert_eq!(s.execute("render.result.close", &json!({})).unwrap(), json!({"view":"model"}));
+ for request in
+ [json!(null), json!({}), json!({"width":0,"height":1}), json!({"width":u64::MAX,"height":1}), json!({"width":1,"height":1,"extra":true})]
+ {
+ assert!(s.execute("render.output.size", &request).is_err());
+ }
+ for request in [json!(null), json!({"view":"unknown"}), json!({"view":"image","extra":true})] {
+ assert!(s.execute("render.result.view", &request).is_err());
+ // Session normalizes null parameters to an empty object for no-argument commands.
+ if request.is_object() {
+ assert!(s.execute("render.result.close", &request).is_err());
+ }
+ }
+ assert!(std::sync::Arc::ptr_eq(&document, &s.doc));
+ assert_eq!(before, (s.revision, s.undo.len(), s.evaluations));
+}
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index b957917b7c..7104609bc1 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -740,6 +740,66 @@ mod tests {
}
}
+ #[test]
+ fn output_viewer_labels_exist_in_all_required_catalogs() {
+ for language in ["en", "de", "ja", "ko", "zh"] {
+ let locale = Locale::for_language(language);
+ for key in [
+ "cmd.render_output_size",
+ "cmd.render_result_view",
+ "cmd.render_result_close",
+ "cmd.render_result_copy",
+ "cmd.render_lights_add",
+ "render.output_destination",
+ "render.output_destination_help",
+ "render.output_backend_ready",
+ "render.output_dimensions",
+ "render.output_effects",
+ "render.output_advanced",
+ "render.output_copy",
+ "render.output_fit",
+ "render.output_export",
+ "render.output_view_image",
+ "render.effects_gpu_only",
+ "render.output_image",
+ "render.output_check_summary",
+ "render.output_presets_help",
+ "render.size_preview",
+ "render.size_full_hd",
+ "render.size_4k",
+ "render.size_square",
+ "render.size_custom",
+ "render.output_format",
+ "render.output_exr_unavailable",
+ "render.output_largest",
+ "render.output_quality",
+ "render.output_quality_waiting",
+ "render.quality_draft",
+ "render.quality_balanced",
+ "render.quality_high",
+ "render.quality_custom",
+ "render.output_check",
+ "render.output_check_help",
+ "render.output_ready",
+ "render.output_size_ok",
+ "render.check_transmission",
+ "render.check_opaque",
+ "render.check_sorted_alpha",
+ "render.state_model",
+ "render.state_in_progress",
+ "render.state_completed",
+ "render.result_actual",
+ "render.radial_assign",
+ "render.radial_save",
+ "render.radial_fit",
+ "render.radial_compare",
+ "render.wait_add_light",
+ ] {
+ assert!(locale.0.messages().contains_key(key), "{language}: {key}");
+ }
+ }
+ }
+
/// The mouse mapping picker shows its preset's help through `tr_label`, which the guard above
/// can't see: the text sits in a struct field, not in a call. Each one must be the English text
/// of its preset's catalog message, or it stays English in every locale.
diff --git a/crates/ui-egui/src/keymap.rs b/crates/ui-egui/src/keymap.rs
index 9715412261..35fc0cf6fd 100644
--- a/crates/ui-egui/src/keymap.rs
+++ b/crates/ui-egui/src/keymap.rs
@@ -322,12 +322,16 @@ pub fn commands_for(app: &SolveApp, key: &str) -> Vec<&'static str> {
/// other tabs), or everywhere (commands on no tab: undo, views, files).
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Scope {
+ Render,
Sketch,
Model,
Everywhere,
}
fn scope(id: &str) -> Scope {
+ if id.starts_with("render.") {
+ return Scope::Render;
+ }
match solidcraft_engine::find_command(id).map(|c| c.tab) {
Some("SKETCH") => Scope::Sketch,
Some("") | None => Scope::Everywhere,
@@ -345,9 +349,21 @@ fn clash(a: &str, b: &str) -> bool {
/// The enabled command a key press runs, if any: one of the mode the view is in (a sketch tool
/// while a sketch is open, a model command otherwise) before any other.
pub fn command_for(app: &SolveApp, key: &str) -> Option<&'static str> {
- let here = if app.session.active_sketch.is_some() { Scope::Sketch } else { Scope::Model };
- let enabled: Vec<&'static str> =
- commands_for(app, key).into_iter().filter(|id| solidcraft_engine::find_command(id).is_some_and(|c| c.info(&app.session).enabled)).collect();
+ let here = if crate::render_workspace::active(app) {
+ Scope::Render
+ } else if app.session.active_sketch.is_some() {
+ Scope::Sketch
+ } else {
+ Scope::Model
+ };
+ let enabled: Vec<&'static str> = commands_for(app, key)
+ .into_iter()
+ .filter(|id| {
+ (scope(id) != Scope::Render || here == Scope::Render)
+ && (here != Scope::Render || scope(id) != Scope::Sketch)
+ && solidcraft_engine::find_command(id).is_some_and(|c| crate::render_workspace::interactive_command_info(app, c).enabled)
+ })
+ .collect();
enabled.iter().find(|id| scope(id) == here).or(enabled.first()).copied()
}
@@ -392,7 +408,7 @@ fn variant_for_key(app: &SolveApp, id: &'static str) -> &'static str {
/// Outside a sketch: the SKETCH-tab command bound to `key` that a new sketch would start. Not
/// Normal/Construction (a mode of the drawing in progress) nor the Finish Sketch panel.
fn sketch_tool_for(app: &SolveApp, key: &str) -> Option<&'static str> {
- if app.session.active_sketch.is_some() {
+ if app.session.active_sketch.is_some() || crate::render_workspace::active(app) {
return None;
}
commands_for(app, key).into_iter().find(|id| {
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 848e7e3d4c..b429274276 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -1024,7 +1024,10 @@ impl SolveApp {
}
let t0 = now_ms();
let selected_before = self.session.selection.clone();
- let r = self.session.execute(id, &params).map_err(|e| e.to_string());
+ let r = self.session.execute(id, &params).map_err(|e| e.to_string()).and_then(|reply| {
+ render_workspace::apply_command(self, id, &reply)?;
+ Ok(reply)
+ });
self.big_operation |= now_ms() - t0 >= recovery_ui::BIG_OPERATION_MS;
let done = self.command_completed(id, r);
// Render focus already applies its semantic selection after clearing object picks.
diff --git a/crates/ui-egui/src/mouse_gesture.rs b/crates/ui-egui/src/mouse_gesture.rs
index cc2758dfe5..9c7ffcaa52 100644
--- a/crates/ui-egui/src/mouse_gesture.rs
+++ b/crates/ui-egui/src/mouse_gesture.rs
@@ -69,7 +69,16 @@ const SURFACE: [&str; 8] = ["repeat", "delete", "surface.extrude", "surface.loft
const SHEET_METAL: [&str; 8] = ["repeat", "delete", "sheet.flange", "sheet.hem", "sketch.create", "sheet.fold", "undo", "sheet.flat_pattern"];
const PLASTIC: [&str; 8] = ["repeat", "delete", "plastic.boss", "plastic.lip", "sketch.create", "plastic.snap_fit", "undo", "plastic.rest"];
const MESH: [&str; 8] = ["repeat", "delete", "file.save_mesh", "inspect.measure", "inspect.section", "solid.move", "undo", "inspect.interference"];
-const RENDER: [&str; 8] = ["render.start", "render.scene", "ui.fit", "ui.home", "ui.workspace.design", "repeat", "undo", "ui.clear"];
+const RENDER: [&str; 8] = [
+ "render.start",
+ "appearance.assign",
+ "render.lights.add",
+ "render.settings.set",
+ "render.camera.fit",
+ "render.compare",
+ "ui.workspace.design",
+ "undo",
+];
impl Studio {
pub(crate) const ALL: [Studio; 7] =
@@ -167,6 +176,17 @@ pub(crate) fn item(app: &SolveApp, id: &str) -> Option<Item> {
}),
"delete" => Some(act("ui.delete", "Delete", "delete").key("Del").on(!app.session.selection.is_empty())),
"undo" => Some(cmd(app, "edit.undo", "Undo").on(!app.session.undo.is_empty())),
+ _ if crate::render_workspace::active(app)
+ && matches!(id, "appearance.assign" | "render.settings.set" | "render.camera.fit" | "render.compare") =>
+ {
+ let key = match id {
+ "appearance.assign" => "render.radial_assign",
+ "render.settings.set" => "render.radial_save",
+ "render.camera.fit" => "render.radial_fit",
+ _ => "render.radial_compare",
+ };
+ Some(cmd(app, id, app.tr(key)))
+ }
_ => match ACTIONS.iter().find(|(i, _, _)| *i == id) {
Some((i, label, icon)) => Some(act(i, label, icon)),
None => solidcraft_engine::find_command(id).map(|spec| cmd(app, spec.id, short(spec.label))),
@@ -1085,7 +1105,9 @@ mod tests {
assert!(catalog.iter().all(|(id, label)| label_of(id).as_deref() == Some(label.as_str())));
for studio in Studio::ALL {
for id in studio.defaults() {
- assert!(catalog.iter().any(|(i, _)| i == id), "{studio:?}: `{id}` is not offered in the editor");
+ // Shipped rings also contain planned actions and Render editors without toolbar destinations.
+ let offered = solidcraft_engine::find_command(id).is_none_or(|spec| spec.planned.is_none() && !spec.tab.is_empty());
+ assert_eq!(catalog.iter().any(|(i, _)| i == id), offered, "{studio:?}: `{id}` must follow the catalog's toolbar-tool policy");
}
}
}
diff --git a/crates/ui-egui/src/render_ui/mod.rs b/crates/ui-egui/src/render_ui/mod.rs
index 2b5a6be228..4848e55911 100644
--- a/crates/ui-egui/src/render_ui/mod.rs
+++ b/crates/ui-egui/src/render_ui/mod.rs
@@ -166,16 +166,7 @@ fn stage_tools(app: &mut SolveApp, ui: &mut egui::Ui) {
}
}
}
- Stage::Output => {
- ui.add_enabled_ui(false, |ui| {
- let (size, format) = crate::render_workspace::output_summary(app);
- ui_kit::button(ui, size, ui_kit::Button::Normal);
- ui_kit::button(ui, format, ui_kit::Button::Normal);
- })
- .response
- .on_disabled_hover_text(app.tr("render.output_tools_inspector"));
- ui_kit::text(ui, app.tr("render.output_tools_inspector"), ui_kit::Text::Inline);
- }
+ Stage::Output => crate::render_workspace::output_stage_tools(app, ui),
}
}
@@ -185,10 +176,19 @@ pub(crate) fn overlays(app: &mut SolveApp, ui: &mut egui::Ui) {
dock_chip(app, ui, "render:focus:exit", "render.exit_focus", "view.render_focus", serde_json::json!({"on":false}));
}
let Some(viewport) = app.viewport.rect else { return };
- let free = canvas(app, viewport);
+ let free = canvas(app, ui.max_rect());
if !free.is_positive() {
return;
}
+ if crate::render_workspace::job_busy(app) {
+ let pill = Container::navigation_card(ui.ctx(), egui::Id::new("sc_render_progress"), free.center_top(), egui::Align2::CENTER_TOP, |ui| {
+ crate::render_workspace::progress_pill(app, ui);
+ });
+ crate::shell::register_panel(app, "render:progress-pill", Some(pill.response.rect), None);
+ crate::scenario::publish_rect("render:progress-pill", pill.response.rect);
+ } else {
+ crate::shell::register_panel(app, "render:progress-pill", None, None);
+ }
crate::navigation_bar_view::show(app, ui, viewport);
if !focused(app) {
shots_pill(app, ui, free);
diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs
index 17aced7543..b609b6f0bb 100644
--- a/crates/ui-egui/src/render_workspace.rs
+++ b/crates/ui-egui/src/render_workspace.rs
@@ -86,6 +86,7 @@ pub struct State {
image: Option<(solidcraft_engine::render::job::JobId, Result<egui::TextureHandle, String>)>,
image_info: Option<solidcraft_engine::render::job::FrameInfo>,
preview_image: Option<PreviewImage>,
+ clipboard_image: Option<egui::ColorImage>,
}
/// Provisional pixels are never an export source and never replace the retained final image.
@@ -384,6 +385,7 @@ impl Default for State {
image: None,
image_info: None,
preview_image: None,
+ clipboard_image: None,
}
}
}
@@ -498,6 +500,9 @@ pub fn sync_backend(app: &mut SolveApp) {
/// Cooperative work belongs to the frame loop, never to a status/control request. Keep
/// scheduling frames even after leaving Render so a browser job can finish in Design.
pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {
+ if let Some(image) = app.render_workspace.clipboard_image.take() {
+ ctx.copy_image(image);
+ }
if matches!(app.render_workspace.path_host, PathHost::Preparing(..)) {
// Poll even in Design or an idle window, without continuously redrawing.
ctx.request_repaint_after(std::time::Duration::from_millis(100));
@@ -509,6 +514,9 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {
Err(e) => app.set_status(e.to_string(), true),
}
}
+ if app.render_workspace.view.job.is_some() {
+ cache_render_images(app, ctx);
+ }
}
pub fn reset_document(app: &mut SolveApp) {
@@ -625,6 +633,13 @@ pub(crate) fn output_summary(app: &SolveApp) -> (String, &'static str) {
(format!("{} × {}", view.draft.width, view.draft.height), if view.studio.export_exr { "EXR" } else { "PNG" })
}
+pub(crate) fn job_busy(app: &SolveApp) -> bool {
+ ribbon::busy(app)
+}
+pub(crate) fn output_stage_tools(app: &mut SolveApp, ui: &mut egui::Ui) {
+ inspector::stage_tools(app, ui);
+}
+
pub(crate) fn job_ready(app: &SolveApp, id: &str) -> Result<(), String> {
ribbon::action_ready(app, id)
}
@@ -849,21 +864,18 @@ fn image_edit_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
let result = app.tr("render.result_title").to_string();
let mut selected = usize::from(app.render_workspace.view.result);
if crate::ui_kit::segmented(ui, &mut selected, &[&preview, &result], crate::ui_kit::Segments { compact: true, ..Default::default() }) {
- app.render_workspace.view.result = selected == 1;
- app.cancel_view_animation();
- app.viewport.key_hold = None;
- app.viewport.orbit_free = None;
+ let _ = app.run("render.result.view", json!({"view":if selected == 1 {"image"} else {"model"}}));
}
if app.render_workspace.view.result {
ui.horizontal(|ui| {
if crate::ui_kit::button(ui, app.tr("render.result_fit"), crate::ui_kit::Button::Normal).clicked() {
- fit_result(app);
+ let _ = app.run("render.result.view", json!({"view":"fit"}));
}
if crate::ui_kit::button(ui, crate::i18n::tr("render.result_actual_size"), crate::ui_kit::Button::Enabled(!reduced_display(app)))
.on_hover_text(app.tr("render.result_actual_help"))
.clicked()
{
- app.render_workspace.view.result_scale = ResultScale::Actual;
+ let _ = app.run("render.result.view", json!({"view":"actual"}));
}
});
ui.small(app.tr("render.result_navigation"));
@@ -1069,6 +1081,7 @@ fn job_controls(app: &mut SolveApp, ui: &mut egui::Ui, compact: bool) {
/// Decode each published sequence once. Provisional textures stay separate from the last
/// final image, so cancellation or a failed pass cannot change the export target.
+#[cfg(test)]
fn completed_image(app: &mut SolveApp, ui: &mut egui::Ui) {
cache_render_images(app, ui.ctx());
if let Some(display) = displayed_image(app) {
@@ -1082,10 +1095,7 @@ fn completed_image(app: &mut SolveApp, ui: &mut egui::Ui) {
.on_hover_text(app.tr("render.result_open"))
.clicked()
{
- app.render_workspace.view.result = true;
- app.cancel_view_animation();
- app.viewport.key_hold = None;
- app.viewport.orbit_free = None;
+ let _ = app.run("render.result.view", json!({"view":"image"}));
}
}
Err(error) => {
@@ -1318,22 +1328,79 @@ fn result_rect(camera: Camera, size: [u32; 2], canvas: egui::Rect) -> egui::Rect
egui::Rect::from_center_size(center, egui::vec2((f64::from(size[0]) * scale) as f32, (f64::from(size[1]) * scale) as f32))
}
+fn result_actions(app: &mut SolveApp, ui: &mut egui::Ui) {
+ for (view, key) in [("model", "render.state_model"), ("fit", "render.output_fit"), ("actual", "render.result_actual")] {
+ let enabled = view != "actual" || !reduced_display(app);
+ if crate::ui_kit::button(ui, app.tr(key), crate::ui_kit::Button::Enabled(enabled)).clicked() {
+ let _ = app.run("render.result.view", json!({"view":view}));
+ }
+ }
+ let copy = crate::ui_kit::button(
+ ui,
+ app.tr("render.output_copy"),
+ crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.result.copy").is_ok()),
+ );
+ crate::scenario::publish_target("render:result-copy", copy.rect);
+ if copy.clicked() {
+ app.start("render.result.copy");
+ }
+ let export =
+ crate::ui_kit::button(ui, studio::export_label(app), crate::ui_kit::Button::Enabled(ribbon::action_ready(app, "render.export").is_ok()));
+ crate::scenario::publish_target("render:result-export", export.rect);
+ if export.clicked() {
+ app.start("render.export");
+ }
+ let close = crate::ui_kit::StageBar::icon_action(ui, "close", app.tr("cmd.render_result_close"));
+ crate::scenario::publish_target("render:result-close", close.rect);
+ if close.clicked() {
+ app.start("render.result.close");
+ }
+}
+
fn show_result(app: &mut SolveApp, ui: &mut egui::Ui) {
cache_render_images(app, ui.ctx());
let t = Tokens::get();
ui.painter().rect_filled(ui.max_rect(), 0.0, t.viewport_bottom);
+ // The floating shell paints after this canvas. Keep image actions in its free
+ // content area so neither ribbon nor Browser can cover their hit targets.
+ let mut free = crate::render_ui::canvas(app, ui.max_rect());
+ if ribbon::busy(app) {
+ free = crate::ui_kit::Container::below_navigation_row(free);
+ }
+ let mut content = ui.new_child(egui::UiBuilder::new().max_rect(free).id_salt("render_result_content"));
+ let ui = &mut content;
let Some((info, preview)) = displayed_image(app).map(|display| (display.info.clone(), display.preview.cloned())) else {
let message = match &app.render_workspace.image {
Some((_, Err(error))) => error.clone(),
+ _ if ribbon::busy(app) => app.tr("render.state_in_progress").to_string(),
_ => app.tr("render.result_empty").to_string(),
};
+ crate::ui_kit::Container::navigation_contents(ui, |ui| {
+ ui.horizontal_wrapped(|ui| {
+ crate::ui_kit::text(
+ ui,
+ app.tr(if ribbon::busy(app) { "render.state_in_progress" } else { "render.result_title" }),
+ crate::ui_kit::Text::Inline,
+ );
+ result_actions(app, ui);
+ });
+ });
+ let canvas = ui.available_rect_before_wrap();
ui.centered_and_justified(|ui| {
ui.add(egui::Label::new(egui::RichText::new(message).size(t.font_heading).color(t.text)).wrap());
});
- app.viewport.rect = None;
+ app.viewport.rect = Some(canvas);
return;
};
- egui::Frame::NONE.fill(t.panel).inner_margin(t.space_8).show(ui, |ui| {
+ crate::ui_kit::Container::navigation_contents(ui, |ui| {
+ ui.horizontal_wrapped(|ui| {
+ crate::ui_kit::text(
+ ui,
+ app.tr(if preview.is_some() { "render.state_in_progress" } else { "render.state_completed" }),
+ crate::ui_kit::Text::Inline,
+ );
+ result_actions(app, ui);
+ });
if let Some(preview) = &preview {
ui.colored_label(
t.warning,
@@ -1827,6 +1894,78 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
crate::navigation_bar_view::show(app, ui, rect);
}
+/// Apply validated UI requests after the same registry call used by automation.
+pub(crate) fn apply_command(app: &mut SolveApp, id: &str, reply: &serde_json::Value) -> Result<(), String> {
+ match id {
+ "render.output.size" => {
+ let width = reply["width"].as_u64().and_then(|v| u32::try_from(v).ok()).ok_or("invalid output width")?;
+ let height = reply["height"].as_u64().and_then(|v| u32::try_from(v).ok()).ok_or("invalid output height")?;
+ if cpu::image_limits(app).fit(u64::from(width), u64::from(height), None) != Some((u64::from(width), u64::from(height))) {
+ return Err(app.tr("render.output_over_budget").into());
+ }
+ app.render_workspace.view.inspector.resolution.custom = reply["custom"].as_bool().unwrap_or(false);
+ app.render_workspace.view.draft.width = width;
+ app.render_workspace.view.draft.height = height;
+ app.render_workspace.view.dirty = true;
+ }
+ "render.result.view" | "render.result.close" => {
+ let view = reply["view"].as_str().ok_or("invalid result view")?;
+ if view == "actual" && reduced_display(app) {
+ return Err(app.tr("render.result_reduced_display").into());
+ }
+ app.render_workspace.view.result = view != "model";
+ match view {
+ "fit" => fit_result(app),
+ "actual" => app.render_workspace.view.result_scale = ResultScale::Actual,
+ _ => {}
+ }
+ app.cancel_view_animation();
+ app.viewport.nav = None;
+ app.viewport.key_hold = None;
+ app.viewport.orbit_free = None;
+ }
+ "render.result.copy" => {
+ let job = serde_json::from_value(reply["frame"]["job"].clone()).map_err(|e| e.to_string())?;
+ let frame = app
+ .session
+ .render_job_handle(job)
+ .map_err(|e| e.to_string())?
+ .frame()
+ .map_err(|e| e.to_string())?
+ .ok_or_else(|| app.tr("render.ribbon_no_result").to_string())?;
+ let image = decode_render_image(frame.png(), frame.info.width, frame.info.height, RenderLimits::default(), 4096)?;
+ app.render_workspace.clipboard_image = Some(image);
+ }
+ _ => {}
+ }
+ Ok(())
+}
+
+pub(crate) fn progress_pill(app: &mut SolveApp, ui: &mut egui::Ui) -> bool {
+ if !ribbon::busy(app) {
+ return false;
+ }
+ let Some(job) = app.render_workspace.view.job else { return false };
+ let Ok(status) = app.session.execute("render.status", &json!({"job":job})) else { return false };
+ let phase = status["progress"]["phase"].as_str().unwrap_or("unknown");
+ if !matches!(phase, "queued" | "preparing" | "running" | "encoding" | "cancelling") {
+ return false;
+ }
+ let done = status["progress"]["done"].as_u64().unwrap_or(0);
+ let total = status["progress"]["total"].as_u64().unwrap_or(1).max(1);
+ let fraction = (done as f64 / total as f64).clamp(0.0, 1.0) as f32;
+ let phase_key = format!("render.image_{phase}");
+ let name = app.render_workspace.view.job_shot.as_ref().unwrap_or(&app.render_workspace.view.name).clone();
+ let cancel =
+ crate::ui_kit::progress_action(ui, &format!("{name} · {} · {:.0}%", app.tr(&phase_key), fraction * 100.0), fraction, app.tr_label("Cancel"));
+ crate::scenario::publish_target("render:progress-cancel", cancel.rect);
+ if cancel.clicked() {
+ app.start("render.cancel");
+ }
+ ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));
+ true
+}
+
pub(crate) fn interactive_command_info(app: &SolveApp, command: &solidcraft_engine::CommandSpec) -> solidcraft_engine::CommandInfo {
let mut info = ribbon::command_info(app, command);
// A drawing tool on the SKETCH tab kept shown outside a sketch starts one (#7904).
diff --git a/crates/ui-egui/src/render_workspace_effects.rs b/crates/ui-egui/src/render_workspace_effects.rs
index d5ca7cd113..d4d66ddbb2 100644
--- a/crates/ui-egui/src/render_workspace_effects.rs
+++ b/crates/ui-egui/src/render_workspace_effects.rs
@@ -196,6 +196,7 @@ pub(super) fn presentation_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
if !gpu(app, ui) {
return;
}
+ studio::tone_controls(app, ui);
note(app, ui, "render.effects_help");
let mut editor = std::mem::take(&mut app.render_workspace.view.inspector.effects);
let before = app.render_workspace.view.studio.finishing;
diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs
index 67d4386d00..d5620a1224 100644
--- a/crates/ui-egui/src/render_workspace_inspector.rs
+++ b/crates/ui-egui/src/render_workspace_inspector.rs
@@ -104,13 +104,14 @@ pub(super) struct View {
replace_ground: bool,
appearance: Appearance,
selection_appearance: selection_appearance::View,
- resolution: Resolution,
+ pub(super) resolution: Resolution,
}
/// Editor-only coupling. The fixed rational anchor prevents repeated rounded
/// edits drifting; external preset/shot changes deliberately establish a new anchor.
#[derive(Clone, Debug, Default)]
-struct Resolution {
+pub(super) struct Resolution {
locked: bool,
+ pub(super) custom: bool,
anchor: Option<[u32; 2]>,
observed: Option<[u32; 2]>,
rejected: bool,
@@ -232,7 +233,9 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
let bounds = crate::shell::panel_bounds(app, ui.available_rect_before_wrap());
let mut side = app.preferences.render_inspector_side.clone();
let mut width = app.preferences.render_inspector_width;
- let appearance_editor = app.render_workspace.view.inspector.page == Page::Appearance;
+ let output = app.render_workspace.view.inspector.page == Page::Output || app.render_workspace.view.selection == super::RenderSelection::Output;
+ let page = if output { Page::Output } else { app.render_workspace.view.inspector.page };
+ let appearance_editor = page == Page::Appearance;
let selection_appearance = appearance_editor && !app.session.selection.is_empty();
let title = if selection_appearance {
app.session
@@ -245,9 +248,9 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
})
.unwrap_or_else(|| app.tr("render.inspector").to_owned())
} else {
- app.tr("render.studio_title").to_string()
+ app.tr(if output { "render.page_output" } else { "render.studio_title" }).to_string()
};
- let icon = if selection_appearance { "body" } else { app.render_workspace.view.inspector.page.icon() };
+ let icon = if selection_appearance { "body" } else { page.icon() };
let scope = selection_appearance::scope_label(app).to_owned();
let header_action = std::cell::Cell::new(None);
let content = ui_kit::Panel::workspace_with_header(
@@ -274,7 +277,7 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
}
},
|ui| {
- if !appearance_editor {
+ if !appearance_editor && !output {
header(app, ui);
ui_kit::Panel::pinned_footer(ui, "render_job_footer", 4, |ui| {
ui.separator();
@@ -290,34 +293,37 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
if appearance_editor {
ui_kit::Panel::editor_footer(ui, "render_appearance_footer", |ui| selection_appearance::footer(app, ui));
}
- let page = app.render_workspace.view.inspector.page;
- egui::ScrollArea::vertical().id_salt(("render_inspector", page.handle(), app.docs.active)).auto_shrink([false, false]).show(ui, |ui| {
- if !appearance_editor {
- ui_kit::text(ui, app.tr(page.key()), ui_kit::Text::Heading(page.key()));
- }
- match page {
- Page::Scene => scene_controls(app, ui),
- Page::Appearance => appearance_controls(app, ui),
- Page::Effects => super::effects::presentation_controls(app, ui),
- Page::Lighting => lighting_controls(app, ui),
- Page::Environment => environment_controls(app, ui),
- Page::Background => background_controls(app, ui),
- Page::Camera => camera_controls(app, ui),
- Page::Output => output_controls(app, ui),
- Page::Diagnostics => diagnostics(app, ui),
- #[cfg(test)]
- Page::All => {
- ui_kit::text(ui, app.tr("render.all_controls_help"), ui_kit::Text::Note("render.all_controls_help"));
- 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));
- let title = app.tr("render.page_aging").to_string();
- ui_kit::section(ui, "render_all_aging", &title, false, |ui| super::effects::aging_controls(app, ui));
- super::image_edit_controls(app, ui);
+ egui::ScrollArea::vertical()
+ .max_width(ui.available_width())
+ .id_salt(("render_inspector", page.handle(), app.docs.active))
+ .auto_shrink([false, false])
+ .show(ui, |ui| {
+ if !appearance_editor && !output {
+ ui_kit::text(ui, app.tr(page.key()), ui_kit::Text::Heading(page.key()));
}
- }
- setups::refresh_dirty(app);
- });
+ match page {
+ Page::Scene => scene_controls(app, ui),
+ Page::Appearance => appearance_controls(app, ui),
+ Page::Effects => super::effects::presentation_controls(app, ui),
+ Page::Lighting => lighting_controls(app, ui),
+ Page::Environment => environment_controls(app, ui),
+ Page::Background => background_controls(app, ui),
+ Page::Camera => camera_controls(app, ui),
+ Page::Output => output_editor(app, ui),
+ Page::Diagnostics => diagnostics(app, ui),
+ #[cfg(test)]
+ Page::All => {
+ ui_kit::text(ui, app.tr("render.all_controls_help"), ui_kit::Text::Note("render.all_controls_help"));
+ 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));
+ let title = app.tr("render.page_aging").to_string();
+ ui_kit::section(ui, "render_all_aging", &title, false, |ui| super::effects::aging_controls(app, ui));
+ super::image_edit_controls(app, ui);
+ }
+ }
+ setups::refresh_dirty(app);
+ });
},
);
match header_action.get() {
@@ -382,10 +388,7 @@ fn header(app: &mut SolveApp, ui: &mut egui::Ui) {
let labels = [app.tr("render.result_preview").to_string(), app.tr("render.result_title").to_string()];
let mut value = usize::from(app.render_workspace.view.result);
if ui_kit::segmented(ui, &mut value, &labels.iter().map(String::as_str).collect::<Vec<_>>(), Default::default()) {
- app.render_workspace.view.result = value == 1;
- app.cancel_view_animation();
- app.viewport.key_hold = None;
- app.viewport.orbit_free = None;
+ let _ = app.run("render.result.view", json!({"view":if value == 1 {"image"} else {"model"}}));
}
}
}
@@ -756,10 +759,53 @@ fn camera_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
}
}
}
+fn output_editor(app: &mut SolveApp, ui: &mut egui::Ui) {
+ for (id, key, draw) in [
+ ("render_output_image", "render.output_image", output_controls as fn(&mut SolveApp, &mut egui::Ui)),
+ ("render_output_effects", "render.output_effects", super::effects::presentation_controls),
+ ("render_output_check", "render.output_check", check_controls),
+ ] {
+ reveal_section(app, ui, id);
+ let title = app.tr(key).to_string();
+ ui_kit::section(ui, id, &title, id != "render_output_effects", |ui| draw(app, ui));
+ }
+}
+fn check_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
+ let ready = super::ribbon::action_ready(app, "render.preflight");
+ let check = ui_kit::button(ui, app.tr("render.output_check"), ui_kit::Button::Enabled(ready.is_ok()));
+ crate::scenario::publish_target("render:check", check.rect);
+ if check.clicked() {
+ app.start("render.preflight");
+ }
+ if let Err(reason) = ready {
+ check.on_disabled_hover_text(reason);
+ }
+ output_check(app, ui);
+ let title = app.tr("cmd.render_backends").to_string();
+ ui_kit::section(ui, "render_output_backends", &title, false, |ui| {
+ gpu_status(app, ui);
+ let backend = app.session.render_backend();
+ ui_kit::text(ui, &backend.label, ui_kit::Text::Inline);
+ for executor in backend.executors.iter().take(16) {
+ let status = match &executor.availability {
+ super::Availability::Available => app.tr("render.output_backend_ready"),
+ super::Availability::Unavailable { reason } => reason,
+ };
+ let label = format!("{} · {status}", executor.id.as_str());
+ ui_kit::text(ui, &label, ui_kit::Text::Report(executor.id.as_str(), false));
+ }
+ if let Some(job) = app.render_workspace.view.job
+ && let Ok(status) = app.session.execute("render.status", &json!({"job":job}))
+ && let Some(phase) = status["progress"]["phase"].as_str()
+ {
+ ui_kit::text(ui, app.tr(&format!("render.image_{phase}")), ui_kit::Text::Inline);
+ }
+ });
+ let title = app.tr("render.page_diagnostics").to_string();
+ ui_kit::section(ui, "render_output_diagnostics", &title, false, |ui| diagnostics(app, ui));
+}
+
fn output_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- studio::export_controls(app, ui);
- super::method_selector(app, ui);
- gpu_status(app, ui);
let side = match app.render_workspace.view.method {
ImageMethod::CpuRaytrace => 16384,
ImageMethod::GpuRaytrace => 8192,
@@ -769,11 +815,8 @@ fn output_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
app.render_workspace.view.inspector.resolution.observe(before);
let mut width = before[0];
let mut height = before[1];
- let label = app.tr("render.image_width").to_string();
- let w = ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut width, 1..=side, 1.0, " px"));
+ let [w, h] = ui_kit::number_pair(ui, app.tr("render.output_dimensions"), [&mut width, &mut height], 1..=side, 1.0, "");
crate::scenario::publish_target("render:output-width", w.rect);
- let label = app.tr("render.image_height").to_string();
- let h = ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut height, 1..=side, 1.0, " px"));
crate::scenario::publish_target("render:output-height", h.rect);
let edit = if w.changed() {
Some((0, width))
@@ -784,53 +827,65 @@ fn output_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
};
if let Some((axis, value)) = edit
&& let Some([width, height]) = app.render_workspace.view.inspector.resolution.edit(before, axis, value, side)
+ && let Err(error) = app.run("render.output.size", json!({"width":width,"height":height,"custom":true}))
{
- app.render_workspace.view.draft.width = width;
- app.render_workspace.view.draft.height = height;
- }
- let label = app.tr("render.output_lock_ratio").to_string();
- let lock = ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.inspector.resolution.locked);
- crate::scenario::publish_target("render:aspect-lock", lock.rect);
- let swap = ui_kit::button(ui, app.tr("render.output_swap_orientation"), ui_kit::Button::Normal);
- crate::scenario::publish_target("render:swap-size", swap.rect);
- if swap.clicked() {
- let draft = &mut app.render_workspace.view.draft;
- std::mem::swap(&mut draft.width, &mut draft.height);
- app.render_workspace.view.inspector.resolution.observe([draft.width, draft.height]);
+ app.render_workspace.view.inspector.resolution.observe(before);
+ app.render_workspace.view.inspector.resolution.rejected = true;
+ app.set_status(error, true);
}
if app.render_workspace.view.inspector.resolution.rejected {
ui_kit::text(ui, app.tr("render.output_ratio_refused"), ui_kit::Text::Error("render.output_ratio_refused"));
}
- ui.horizontal_wrapped(|ui| {
- for (label, width, height) in [
- (crate::i18n::tr("render.size_hd"), 1280, 720),
- (crate::i18n::tr("render.size_full_hd"), 1920, 1080),
- (crate::i18n::tr("render.size_4k_uhd"), 3840, 2160),
- ] {
- if ui_kit::button(ui, label, ui_kit::Button::Normal).clicked() {
- app.render_workspace.view.draft.width = width;
- app.render_workspace.view.draft.height = height;
- }
- }
- });
+ let largest = largest_output(app);
+ let (w, h) = largest.map_or_else(|| ("—".to_string(), "—".to_string()), |(w, h)| (w.to_string(), h.to_string()));
+ let largest_label = crate::i18n::format("render.output_largest", &[("width", &w), ("height", &h)]);
+ for choices in [
+ ("720", crate::i18n::tr("render.size_hd").to_string(), Some((1280, 720))),
+ ("1080", crate::i18n::tr("render.size_full_hd").to_string(), Some((1920, 1080))),
+ ("4k", crate::i18n::tr("render.size_4k_uhd").to_string(), Some((3840, 2160))),
+ ("largest", largest_label, largest),
+ ]
+ .chunks(2)
+ {
+ ui_kit::catalog_scope(ui, |ui| {
+ ui.horizontal_wrapped(|ui| {
+ for (key, label, size) in choices {
+ let allowed = size.filter(|&(w, h)| cpu::image_limits(app).fit(w, h, None) == Some((w, h)));
+ let response = ui
+ .add_enabled_ui(allowed.is_some(), |ui| {
+ ui_kit::choice_chip(ui, key, label, *size == Some((u64::from(before[0]), u64::from(before[1]))))
+ })
+ .inner;
+ crate::scenario::publish_target(&format!("render:size:{key}"), response.rect);
+ if response.on_disabled_hover_text(app.tr("render.output_over_budget")).clicked()
+ && let Some((w, h)) = allowed
+ {
+ let _ = app.run("render.output.size", json!({"width":w,"height":h}));
+ }
+ }
+ })
+ });
+ }
+ studio::export_controls(app, ui);
+ ui_kit::text(ui, app.tr("render.output_quality"), ui_kit::Text::Inline);
+ quality_choices(app, ui);
+ ui.scope(|ui| super::method_selector(app, ui)).response.on_hover_text(app.tr("render.method_limit_raster"));
let size = (u64::from(app.render_workspace.view.draft.width), u64::from(app.render_workspace.view.draft.height));
if cpu::image_limits(app).fit(size.0, size.1, None) != Some(size) {
ui_kit::text(ui, app.tr("render.output_over_budget"), ui_kit::Text::Error("render.output_over_budget"));
}
match app.render_workspace.view.method {
ImageMethod::GpuRaytrace => {
+ super::transport::sampling_controls(app, ui);
let label = app.tr("render.image_samples").to_string();
ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.samples, 1..=4096, 1.0, ""));
let label = app.tr("render.gpu_depth").to_string();
ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.max_depth, 1..=16, 1.0, ""));
let label = app.tr("render.gpu_seed").to_string();
ui_kit::row(ui, &label, |ui| ui_kit::number_field(ui, &mut app.render_workspace.view.seed, 0..=u32::MAX, 1.0, ""));
- studio::finishing_controls(app, ui);
}
ImageMethod::CpuRaytrace => super::cpu_sampling_controls(app, ui),
- ImageMethod::Raster => {
- ui_kit::text(ui, app.tr("render.method_limit_raster"), ui_kit::Text::Note("render.method_limit_raster"));
- }
+ ImageMethod::Raster => {}
}
if app.render_workspace.view.method != ImageMethod::Raster {
let label = app.tr("render.image_exposure").to_string();
@@ -838,13 +893,173 @@ fn output_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
}
let label = app.tr("render.image_transparent").to_string();
ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.transparent);
- ui_kit::text(ui, app.tr("render.output_format_status"), ui_kit::Text::Note("render.output_format_status"));
+
let label = app.tr("render.image_overwrite").to_string();
ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.overwrite);
- browse_button(app, ui, "quality", "render.browse_quality");
- library::inspect_kinds(app, ui, &["quality"]);
- super::completed_image(app, ui);
- ui_kit::text(ui, app.tr("render.adaptive_pending"), ui_kit::Text::Note("render.adaptive_pending"));
+ let label = app.tr("render.output_destination").to_string();
+ let export = ui_kit::row(ui, &label, |ui| {
+ ui_kit::button(ui, studio::export_label(app), ui_kit::Button::Enabled(super::ribbon::action_ready(app, "render.export").is_ok()))
+ });
+ if export.on_hover_text(app.tr("render.output_destination_help")).clicked() {
+ app.start("render.export");
+ }
+ if app.render_workspace.view.completed.is_some() && ui_kit::button(ui, app.tr("render.output_view_image"), ui_kit::Button::Normal).clicked() {
+ let _ = app.run("render.result.view", json!({"view":"image"}));
+ }
+ reveal_section(app, ui, "render_output_advanced");
+ let title = app.tr("render.output_advanced").to_string();
+ ui_kit::section(ui, "render_output_advanced", &title, false, |ui| {
+ let label = app.tr("render.output_lock_ratio").to_string();
+ let lock = ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.inspector.resolution.locked);
+ crate::scenario::publish_target("render:aspect-lock", lock.rect);
+ let swap = ui_kit::button(ui, app.tr("render.output_swap_orientation"), ui_kit::Button::Normal);
+ crate::scenario::publish_target("render:swap-size", swap.rect);
+ if swap.clicked() {
+ let _ = app.run("render.output.size", json!({"width":before[1],"height":before[0],"custom":true}));
+ let draft = &app.render_workspace.view.draft;
+ app.render_workspace.view.inspector.resolution.observe([draft.width, draft.height]);
+ }
+ ui_kit::text(ui, app.tr("render.output_format_status"), ui_kit::Text::Note("render.output_format_status"));
+ browse_button(app, ui, "quality", "render.browse_quality");
+ library::inspect_kinds(app, ui, &["quality"]);
+ ui_kit::text(ui, app.tr("render.adaptive_pending"), ui_kit::Text::Note("render.adaptive_pending"));
+ });
+}
+
+/// Fit an oversized same-aspect candidate, since fit deliberately never upscales.
+pub(super) fn largest_output(app: &SolveApp) -> Option<(u64, u64)> {
+ let limits = cpu::image_limits(app);
+ let draft = &app.render_workspace.view.draft;
+ limits.fit(u64::from(draft.width).checked_mul(limits.max_dimension)?, u64::from(draft.height).checked_mul(limits.max_dimension)?, None)
+}
+pub(super) fn quality_choices(app: &SolveApp, ui: &mut egui::Ui) {
+ let reason = app.tr("render.output_quality_waiting");
+ let labels = ["render.quality_draft", "render.quality_balanced", "render.quality_high", "render.quality_custom"].map(|key| app.tr(key));
+ let mut quality = 3;
+ ui_kit::segmented(
+ ui,
+ &mut quality,
+ &labels,
+ ui_kit::Segments {
+ workspace_accent: true,
+ intrinsic: true,
+ compact: true,
+ disabled_reasons: &[Some(reason), Some(reason), Some(reason), None],
+ ..Default::default()
+ },
+ );
+}
+pub(super) fn check_summary(app: &SolveApp) -> String {
+ 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) => {
+ let count = check.reply["warnings"].as_array().map_or(0, Vec::len)
+ + usize::from(check.reply["transparency"].as_str().is_some_and(|value| value != "physical_transmission"));
+ return crate::i18n::format("render.output_check_summary", &[("count", &count.to_string())]);
+ }
+ Some(_) => "render.studio_needs_review",
+ None => return app.tr("render.output_check").into(),
+ };
+ format!("{} · {}", app.tr("render.output_check"), app.tr(state))
+}
+
+const SIZE_PRESETS: [(&str, &str, Option<(u32, u32)>); 5] = [
+ ("720", "render.size_preview", Some((1280, 720))),
+ ("1080", "render.size_full_hd", Some((1920, 1080))),
+ ("4k", "render.size_4k", Some((3840, 2160))),
+ ("square", "render.size_square", Some((2048, 2048))),
+ ("custom", "render.size_custom", None),
+];
+fn choose_size(app: &mut SolveApp, size: Option<(u32, u32)>) {
+ let custom = size.is_none();
+ let (width, height) = size.unwrap_or((app.render_workspace.view.draft.width, app.render_workspace.view.draft.height));
+ if let Err(error) = app.run("render.output.size", json!({"width":width,"height":height,"custom":custom})) {
+ app.set_status(error, true);
+ } else if custom {
+ let _ = app.run("view.render_select", json!({"kind":"output"}));
+ reveal(app, "render_output_image");
+ }
+}
+pub(super) fn size_presets(app: &mut SolveApp, ui: &mut egui::Ui) {
+ ui_kit::scope(ui, |ui| {
+ let current = (app.render_workspace.view.draft.width, app.render_workspace.view.draft.height);
+ let custom = app.render_workspace.view.inspector.resolution.custom || !SIZE_PRESETS.iter().any(|(_, _, size)| *size == Some(current));
+ for (key, label, size) in SIZE_PRESETS {
+ let summary = size.map_or_else(String::new, |(w, h)| format!("{w} × {h}"));
+ let enabled =
+ size.is_none_or(|(w, h)| cpu::image_limits(app).fit(u64::from(w), u64::from(h), None) == Some((u64::from(w), u64::from(h))));
+ let response = ui
+ .add_enabled_ui(enabled, |ui| {
+ ui_kit::settings_choice_row(
+ ui,
+ &ui_kit::SettingsChoice {
+ key: &format!("render:preset:{key}"),
+ title: app.tr(label),
+ summary: &summary,
+ detail: app.tr(label),
+ },
+ if size.is_none() { custom } else { !custom && size == Some(current) },
+ )
+ })
+ .inner;
+ if response.on_disabled_hover_text(app.tr("render.output_over_budget")).clicked() {
+ choose_size(app, size);
+ }
+ }
+ ui_kit::text(ui, app.tr("render.output_presets_help"), ui_kit::Text::Note("render.output_presets_help"));
+ });
+}
+pub(super) fn stage_tools(app: &mut SolveApp, ui: &mut egui::Ui) {
+ let (size, _) = super::output_summary(app);
+ let dropdown = ui_kit::compact_dropdown_menu(ui, "render_stage_size", &size, |ui| {
+ for (key, label, size) in SIZE_PRESETS {
+ let enabled =
+ size.is_none_or(|(w, h)| cpu::image_limits(app).fit(u64::from(w), u64::from(h), None) == Some((u64::from(w), u64::from(h))));
+ let response = ui.add_enabled_ui(enabled, |ui| ui_kit::list_picker(ui, key, app.tr(label), false)).inner;
+ crate::scenario::publish_target(&format!("render:stage:size:{key}"), response.rect);
+ if response.on_disabled_hover_text(app.tr("render.output_over_budget")).clicked() {
+ choose_size(app, size);
+ ui.close();
+ }
+ }
+ });
+ crate::scenario::publish_target("render:stage:size", dropdown.rect);
+ studio::format_choices(app, ui);
+ quality_choices(app, ui);
+ let summary = check_summary(app);
+ let response = ui_kit::choice_chip(ui, "render_stage_check", &summary, false).on_hover_text(app.tr("render.output_check_help"));
+ crate::scenario::publish_target("render:stage:check", response.rect);
+ if response.clicked() {
+ app.start("render.preflight");
+ }
+}
+
+fn output_check(app: &SolveApp, ui: &mut egui::Ui) {
+ let Some(check) = &app.render_workspace.view.inspector.checked else {
+ ui_kit::text(ui, app.tr("render.output_check_help"), ui_kit::Text::Note("render.output_check_help"));
+ return;
+ };
+ if !check.current(app) || super::image_params(app).as_ref().ok() != Some(&check.request) {
+ ui_kit::check_line(ui, "render:check:stale", app.tr("render.review_stale"), true);
+ return;
+ }
+ ui_kit::check_line(ui, "render:check:ready", app.tr("render.output_ready"), false);
+ if let (Some(w), Some(h)) = (check.reply["request"]["width"].as_u64(), check.reply["request"]["height"].as_u64()) {
+ let label = crate::i18n::format("render.output_size_ok", &[("width", &w.to_string()), ("height", &h.to_string())]);
+ ui_kit::check_line(ui, "render:check:size", &label, false);
+ }
+ if let Some(transparency) = check.reply["transparency"].as_str() {
+ let key = match transparency {
+ "physical_transmission" => "render.check_transmission",
+ "opaque_only" => "render.check_opaque",
+ _ => "render.check_sorted_alpha",
+ };
+ ui_kit::check_line(ui, "render:check:transparency", app.tr(key), transparency != "physical_transmission");
+ }
+ if let Some(warnings) = check.reply["warnings"].as_array() {
+ for warning in warnings.iter().take(32) {
+ ui_kit::check_line(ui, "render:check:warning", &warning.to_string(), true);
+ }
+ }
}
pub(super) fn scene_resource(app: &mut SolveApp, ui: &mut egui::Ui, id: &str) {
diff --git a/crates/ui-egui/src/render_workspace_inspector_tests.rs b/crates/ui-egui/src/render_workspace_inspector_tests.rs
index b5bb60466c..9d2672d053 100644
--- a/crates/ui-egui/src/render_workspace_inspector_tests.rs
+++ b/crates/ui-egui/src/render_workspace_inspector_tests.rs
@@ -10,7 +10,7 @@ fn fixture() -> Harness {
h
}
#[test]
-fn native_inspector_defaults_to_output_and_keeps_job_actions_on_screen_in_both_shells() {
+fn native_inspector_keeps_stage_actions_on_screen_and_output_has_no_pinned_footer() {
for dark in [false, true] {
for layout in [crate::shell::LayoutMode::Docked, crate::shell::LayoutMode::Floating] {
let mut h = fixture();
@@ -25,7 +25,20 @@ fn native_inspector_defaults_to_output_and_keeps_job_actions_on_screen_in_both_s
h.app.render_workspace.view.inspector.page = page;
h.frames(3);
let inspector = crate::scenario::rect_of("render:inspector").unwrap();
+ assert_eq!(h.app.session.doc.to_json(), before);
+ assert_eq!(h.app.session.revision, revision);
+ assert_eq!((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());
if page == Page::Appearance {
+ assert!(crate::scenario::rect_of("render:job-footer").is_none());
+ continue;
+ }
+ if page == Page::Output {
+ assert!(crate::scenario::rect_of("render:job-footer").is_none());
+ for name in ["render:stage:render.start", "render:stage:render.cancel"] {
+ assert!(crate::scenario::rect_of(name).is_some());
+ }
continue;
}
let footer = crate::scenario::rect_of("render:job-footer").unwrap();
@@ -34,11 +47,6 @@ fn native_inspector_defaults_to_output_and_keeps_job_actions_on_screen_in_both_s
let target = crate::scenario::rect_of(name).unwrap();
assert!(footer.contains_rect(target), "{name} clipped at {page:?}");
}
- assert_eq!(h.app.session.doc.to_json(), before);
- assert_eq!(h.app.session.revision, revision);
- assert_eq!((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());
}
}
}
@@ -204,7 +212,8 @@ fn actual_output_ratio_and_orientation_controls_are_local_and_preserve_saved_cap
setups::save(&mut h.app).unwrap();
let saved = h.app.session.doc.to_json();
let camera = h.app.cam;
- h.frames(3);
+ reveal(&mut h.app, "render_output_advanced");
+ h.frames(24);
h.step(&json!({"click":{"handle":"render:aspect-lock"}})).unwrap();
assert!(h.app.render_workspace.view.inspector.resolution.locked);
assert!(!h.app.render_workspace.view.dirty, "coupling editor coordinates is not a saved numerical edit");
@@ -293,7 +302,7 @@ fn ribbon_navigation_reuses_inspector_and_preserves_exact_unsaved_intent() {
("render.library.environment.apply", Page::Environment),
("render.stage.backdrop", Page::Background),
("render.quality.prepare", Page::Output),
- ("render.status", Page::Diagnostics),
+ ("render.status", Page::Output),
("render.camera.get", Page::Camera),
("render.camera.set", Page::Camera),
("render.preset.apply", Page::Scene),
@@ -310,8 +319,8 @@ fn ribbon_navigation_reuses_inspector_and_preserves_exact_unsaved_intent() {
("render.hdr.inspect", Page::Environment),
("render.settings.capture_hdr", Page::Environment),
("render.aging.describe", Page::Appearance),
- ("render.effects.describe", Page::Effects),
- ("render.backends", Page::Diagnostics),
+ ("render.effects.describe", Page::Output),
+ ("render.backends", Page::Output),
] {
h.app.start(id);
h.frames(3);
@@ -557,14 +566,14 @@ fn aging_tab_adds_reorders_disables_and_persists_layers_without_engineering_edit
}
#[test]
-fn effects_tab_retains_ordered_looks_and_photographic_intent_across_save_and_reload() {
+fn output_effects_retains_ordered_looks_and_photographic_intent_across_save_and_reload() {
use solidcraft_engine::render::job::looks::LookKind;
let mut h = fixture();
super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
let before = h.app.session.doc.to_json();
h.app.start("render.effects.describe");
- h.frames(3);
- assert_eq!(h.app.render_workspace.view.inspector.page, Page::Effects);
+ h.frames(24);
+ assert_eq!(h.app.render_workspace.view.inspector.page, Page::Output);
for code in [3, 6] {
h.step(&json!({"click":{"handle":"render:look-add"}})).unwrap();
h.frames(2);
diff --git a/crates/ui-egui/src/render_workspace_library.rs b/crates/ui-egui/src/render_workspace_library.rs
index 2af3a41836..d471718874 100644
--- a/crates/ui-egui/src/render_workspace_library.rs
+++ b/crates/ui-egui/src/render_workspace_library.rs
@@ -462,7 +462,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: matches!(stage, super::Stage::Look | super::Stage::Light),
+ enabled: stage != super::Stage::Frame,
header_actions: (stage == super::Stage::Look).then_some(&mut actions as &mut dyn FnMut(&mut egui::Ui)),
},
&mut side,
@@ -470,8 +470,9 @@ pub(super) fn card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) {
|ui| match stage {
super::Stage::Look => ui_kit::catalog_scope(ui, |ui| browse_contents(app, ui, true)),
super::Stage::Light => light_panel(app, ui),
- super::Stage::Frame | super::Stage::Output => {
- let reason = app.tr(if stage == super::Stage::Frame { "render.frame_presets_pending" } else { "render.size_presets_pending" });
+ 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"));
}
},
diff --git a/crates/ui-egui/src/render_workspace_ribbon.rs b/crates/ui-egui/src/render_workspace_ribbon.rs
index c4401b414d..1e9bc3eff3 100644
--- a/crates/ui-egui/src/render_workspace_ribbon.rs
+++ b/crates/ui-egui/src/render_workspace_ribbon.rs
@@ -7,7 +7,7 @@ use solidcraft_engine::render::job::Phase;
use solidcraft_engine::{CommandInfo, CommandSpec};
fn is_job_action(id: &str) -> bool {
- matches!(id, "render.preflight" | "render.start" | "render.cancel" | "render.export" | "render.result.regrade")
+ matches!(id, "render.preflight" | "render.start" | "render.cancel" | "render.export" | "render.result.regrade" | "render.result.copy")
}
fn handled(id: &str) -> bool {
is_job_action(id)
@@ -44,6 +44,8 @@ fn handled(id: &str) -> bool {
| "render.quality.prepare"
| "render.status"
| "render.backends"
+ | "render.result.view"
+ | "render.result.close"
)
}
@@ -79,7 +81,8 @@ pub(super) fn action_ready(app: &SolveApp, id: &str) -> Result<(), String> {
presentation(app).validate().map_err(|error| error.to_string())
}
"render.cancel" if !busy(app) => Err(app.tr("render.ribbon_no_active_job").into()),
- "render.export" => {
+ "render.result.close" if !super::result_active(app) => Err(app.tr("render.ribbon_no_result").into()),
+ "render.export" | "render.result.copy" => {
let completed = app
.render_workspace
.view
@@ -89,7 +92,7 @@ pub(super) fn action_ready(app: &SolveApp, id: &str) -> Result<(), String> {
if completed.is_none() {
return Err(app.tr("render.ribbon_no_result").into());
}
- if app.render_workspace.view.studio.export_exr && !studio::linear_export_available(app) {
+ if id == "render.export" && app.render_workspace.view.studio.export_exr && !studio::linear_export_available(app) {
return Err(app.tr("render.linear_unavailable").into());
}
Ok(())
@@ -135,6 +138,10 @@ pub(super) fn perform_job(app: &mut SolveApp, id: &str) -> Result<(), String> {
app.render_workspace.view.job = Some(job);
app.render_workspace.view.job_shot = Some(app.render_workspace.view.name.clone());
}
+ "render.result.copy" => {
+ let job = app.render_workspace.view.completed.ok_or_else(|| app.tr("render.ribbon_no_result").to_string())?;
+ app.run(id, json!({"job":job}))?;
+ }
"render.result.regrade" => {
let source = app.render_workspace.view.completed.ok_or_else(|| app.tr("render.ribbon_no_result").to_string())?;
let reply = app.run(id, json!({"job":source,"presentation":presentation(app)}))?;
@@ -174,6 +181,12 @@ pub(super) fn presentation(app: &SolveApp) -> solidcraft_engine::render::job::pr
fn focus(app: &mut SolveApp, page: inspector::Page, category: Option<&str>) {
app.render_workspace.view.inspector.hidden = false;
+ let page = if matches!(page, inspector::Page::Effects | inspector::Page::Diagnostics) {
+ inspector::reveal(app, if page == inspector::Page::Effects { "render_output_effects" } else { "render_output_check" });
+ inspector::Page::Output
+ } else {
+ page
+ };
app.render_workspace.view.inspector.page = page;
if let Some(category) = category {
library::open_category(app, category);
@@ -212,6 +225,12 @@ fn navigate(app: &mut SolveApp, id: &str) -> Result<(), String> {
focus(app, Page::Appearance, None);
inspector::reveal(app, "render:appearance:advanced");
}
+ "render.result.close" => {
+ app.run(id, json!({}))?;
+ }
+ "render.result.view" => {
+ app.run(id, json!({"view":"image"}))?;
+ }
"render.effects.describe" => focus(app, Page::Effects, None),
"render.preset.resolve" | "render.preset.apply" => focus(app, Page::Scene, Some("native_scenes")),
"render.settings.get" | "render.shot.duplicate" | "render.shot.rename" | "render.shot.remove" => {
diff --git a/crates/ui-egui/src/render_workspace_studio.rs b/crates/ui-egui/src/render_workspace_studio.rs
index 266e888cc6..15f0540760 100644
--- a/crates/ui-egui/src/render_workspace_studio.rs
+++ b/crates/ui-egui/src/render_workspace_studio.rs
@@ -132,10 +132,14 @@ pub(super) fn vector(ui: &mut egui::Ui, label: &str, value: &mut [f64; 3], range
});
}
+#[cfg(test)]
pub(super) fn finishing_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
super::transport::sampling_controls(app, ui);
post_controls(app, ui);
- ui.label(app.tr("render.studio_tone_map"));
+ tone_controls(app, ui);
+}
+pub(super) fn tone_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
+ ui_kit::text(ui, app.tr("render.studio_tone_map"), ui_kit::Text::Inline);
let selected = app.render_workspace.view.studio.tone_map;
let label = match selected {
ToneMap::Reinhard => crate::i18n::tr("render.tone_reinhard"),
@@ -441,23 +445,37 @@ pub(super) fn backdrop_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
}
}
+pub(super) fn export_label(app: &SolveApp) -> &str {
+ app.tr(if app.render_workspace.view.studio.export_exr { "render.export_linear" } else { "render.output_export" })
+}
+
pub(super) fn export_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- let exr = app.render_workspace.view.studio.export_exr;
- let key = if exr { "render.export_linear" } else { "render.export_display" };
- let label = app.tr(key).to_string();
- let r = ui_kit::dropdown_menu(ui, "render_export_format", &label, |ui| {
- for (value, key) in [(false, "render.export_display"), (true, "render.export_linear")] {
- if ui_kit::list_picker(ui, key, app.tr(key), value == exr).clicked() {
- app.render_workspace.view.studio.export_exr = value;
- ui.close();
- }
+ let label = app.tr("render.output_format").to_string();
+ let response = ui_kit::row(ui, &label, |ui| format_choices(app, ui));
+ crate::scenario::publish_target("render:export-format", response.rect);
+}
+pub(super) fn format_choices(app: &mut SolveApp, ui: &mut egui::Ui) -> egui::Response {
+ ui.scope(|ui| {
+ let reason = app.tr("render.output_exr_unavailable");
+ let mut format = usize::from(app.render_workspace.view.studio.export_exr);
+ if ui_kit::segmented(
+ ui,
+ &mut format,
+ &["PNG", "EXR"],
+ ui_kit::Segments {
+ disabled_reasons: &[None, Some(reason)],
+ workspace_accent: true,
+ intrinsic: true,
+ compact: true,
+ ..Default::default()
+ },
+ ) {
+ app.render_workspace.view.studio.export_exr = false;
}
- });
- crate::scenario::publish_target("render:export-format", r.rect);
- if app.render_workspace.view.studio.export_exr && !linear_export_available(app) {
- ui_kit::text(ui, app.tr("render.linear_unavailable"), ui_kit::Text::Note("render.linear_unavailable"));
- }
+ })
+ .response
}
+
pub(super) fn linear_export_available(app: &SolveApp) -> bool {
app.render_workspace
.view
diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs
index 8a7fbd01cc..de3c6b85cf 100644
--- a/crates/ui-egui/src/render_workspace_tests.rs
+++ b/crates/ui-egui/src/render_workspace_tests.rs
@@ -1992,7 +1992,7 @@ fn clicked_setup_save_reload_and_switch_keep_gpu_numeric_intent_without_a_host()
let mut h = Harness::new();
h.call("ui.resize", json!({"width":1600,"height":2200}));
enter(&mut h.app, true).unwrap();
- h.app.render_workspace.view.inspector.page = inspector::Page::All;
+ h.app.run("view.render_stage", json!({"stage":"output"})).unwrap();
h.frames(3);
h.app.session.set_render_job_host(None).unwrap();
assert!(image_host(&h.app, ImageMethod::GpuRaytrace).is_err());
@@ -2067,8 +2067,9 @@ fn clicked_setup_save_reload_and_switch_keep_gpu_numeric_intent_without_a_host()
let open_section = |h: &mut Harness, handle: String| {
for _ in 0..4 {
let at = crate::scenario::handle_at(&handle).unwrap();
+ let inspector = crate::scenario::rect_of("render:inspector").unwrap();
let top = crate::scenario::rect_of("render:inspector:header").unwrap().bottom() + Tokens::get().space_8;
- let bottom = crate::scenario::rect_of("render:job-footer").unwrap().top() - Tokens::get().space_8;
+ let bottom = crate::scenario::rect_of("render:job-footer").map_or(inspector.bottom(), |r| r.top()) - Tokens::get().space_8;
if (top..=bottom).contains(&at.y) {
break;
}
@@ -2078,10 +2079,15 @@ fn clicked_setup_save_reload_and_switch_keep_gpu_numeric_intent_without_a_host()
}
h.step(&json!({"click":{"handle":handle}})).unwrap();
};
- for key in ["render.image_advanced", "render.studio_environment", "render.studio_lighting"] {
+ for key in ["render.output_advanced", "render.output_effects"] {
open_section(&mut h, format!("dialog:section:{}", crate::i18n::tr(key)));
}
+ h.app.run("view.render_stage", json!({"stage":"light"})).unwrap();
+ h.frames(3);
open_section(&mut h, format!("dialog:section:{} 1", crate::i18n::tr("render.studio_area")));
+ h.app.start("render.hdr.inspect");
+ h.frames(3);
+ h.app.run("view.render_stage", json!({"stage":"frame"})).unwrap();
h.frames(3);
assert_eq!(setups::snapshot(&h.app).unwrap(), expected);
assert!(!h.app.render_workspace.view.dirty);
@@ -2767,7 +2773,7 @@ fn finishing_backdrop_and_raw_retention_save_reload_without_a_gpu_or_hidden_tran
enter(&mut h.app, true).unwrap();
h.app.session.set_render_job_host(None).unwrap();
select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
- h.app.render_workspace.view.inspector.page = inspector::Page::Output;
+ h.app.run("view.render_stage", json!({"stage":"output"})).unwrap();
h.app.render_workspace.view.name = "Linear studio".into();
h.app.render_workspace.view.studio.finishing =
Finishing { rgb_gain: [1.3, 0.8, 0.9], saturation: 0.4, contrast: 1.2, vignette: 0.3, ..Default::default() };
@@ -2790,6 +2796,8 @@ fn finishing_backdrop_and_raw_retention_save_reload_without_a_gpu_or_hidden_tran
h.app.render_workspace.view.transparent = false;
let before = h.app.session.doc.to_json();
h.frames(3);
+ let effects = h.app.tr("render.output_effects").to_string();
+ h.step(&json!({"click":{"handle":format!("dialog:section:{effects}")}})).unwrap();
let title = h.app.tr("render.post_title").to_string();
h.step(&json!({"click":{"handle":format!("dialog:section:{title}")}})).unwrap();
h.step(&json!({"click":{"handle":"render:post-reset"}})).unwrap();
@@ -2861,9 +2869,11 @@ fn render_workspace_stage_chips_dispatch_without_mutations_and_remember_each_doc
assert!(h.app.render_workspace.view.job.is_none());
assert!(h.app.render_workspace.view.completed.is_none());
// Stage selection preserves access to the other command-driven editors.
- h.app.start("render.status");
- h.frames(2);
- assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Diagnostics);
+ for command in ["render.status", "render.backends"] {
+ h.app.start(command);
+ h.frames(2);
+ assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Output);
+ }
}
h.app.run("view.render_stage", json!({"stage":"frame"})).unwrap();
crate::documents::open_tab(&mut h.app, Session::default()).unwrap();
@@ -4579,3 +4589,298 @@ fn appearance_editor_hostile_optics_stay_finite_and_never_panic() {
h.app.render_workspace.view.materials.bindings = vec![binding];
assert!(materials::params(&h.app, &mut json!({})).is_ok(), "box boundaries are closed dielectrics too");
}
+
+fn output_viewer_fixture() -> Harness {
+ let mut h = Harness::new();
+ h.app.home.open = false;
+ h.app.session.set_render_job_host(Some(solidcraft_engine::render::job::CpuHost::cooperative())).unwrap();
+ enter(&mut h.app, true).unwrap();
+ h.app.run("view.render_stage", json!({"stage":"output"})).unwrap();
+ h.app.run("view.render_select", json!({"kind":"output"})).unwrap();
+ h.app.render_workspace.view.draft.width = 16;
+ h.app.render_workspace.view.draft.height = 16;
+ h.frames(3);
+ h
+}
+
+#[test]
+fn output_viewer_size_chips_obey_limits_and_largest_upscales_at_the_current_aspect() {
+ let mut h = output_viewer_fixture();
+ let document = h.app.session.doc.clone();
+ let undo = h.app.session.undo.len();
+ for (key, expected) in [("720", (1280, 720)), ("1080", (1920, 1080))] {
+ h.step(&json!({"click":{"handle":format!("render:size:{key}")}})).unwrap();
+ let draft = &h.app.render_workspace.view.draft;
+ assert_eq!((draft.width, draft.height), expected);
+ }
+ let largest = inspector::largest_output(&h.app).unwrap();
+ assert!(largest.0 > 1920);
+ assert_eq!(cpu::image_limits(&h.app).fit(largest.0, largest.1, None), Some(largest));
+ assert!((largest.0 as f64 / largest.1 as f64 - 16.0 / 9.0).abs() < 0.002);
+ h.step(&json!({"click":{"handle":"render:size:largest"}})).unwrap();
+ assert_eq!((u64::from(h.app.render_workspace.view.draft.width), u64::from(h.app.render_workspace.view.draft.height)), largest);
+ let before = h.app.render_workspace.view.draft.clone();
+ assert!(h.app.run("render.output.size", json!({"width":4096,"height":4096})).is_err());
+ assert_eq!(h.app.render_workspace.view.draft, before);
+ assert!(Arc::ptr_eq(&document, &h.app.session.doc));
+ assert_eq!(undo, h.app.session.undo.len());
+ assert!(h.app.render_workspace.view.job.is_none());
+}
+
+#[test]
+fn output_viewer_check_lists_preflight_results_without_starting_and_marks_edits_stale() {
+ let mut h = output_viewer_fixture();
+ let host = h.app.session.render_job_host().unwrap().clone();
+ let document = h.app.session.doc.clone();
+ let undo = h.app.session.undo.len();
+ h.step(&json!({"click":{"handle":"render:stage:check"}})).unwrap();
+ assert!(h.app.render_workspace.view.job.is_none());
+ assert_eq!(host.admitted_bytes(), 0);
+ assert!(Arc::ptr_eq(&document, &h.app.session.doc));
+ assert_eq!(undo, h.app.session.undo.len());
+ for key in ["ready", "size", "transparency"] {
+ assert!(crate::scenario::rect_of(&format!("render:check:{key}")).is_some(), "{key}");
+ }
+ h.app.run("render.output.size", json!({"width":32,"height":16})).unwrap();
+ h.frames(2);
+ assert!(crate::scenario::rect_of("render:check:stale").is_some());
+ assert!(h.app.render_workspace.view.job.is_none());
+}
+
+#[test]
+fn output_viewer_copy_uses_retained_final_pixels_and_refuses_missing_or_oversized_images() {
+ let mut h = output_viewer_fixture();
+ assert!(ribbon::perform_job(&mut h.app, "render.result.copy").is_err());
+ assert!(h.app.render_workspace.clipboard_image.is_none());
+ assert!(decode_render_image(&[], 4097, 1, RenderLimits::default(), 4096).unwrap_err().contains("resource profile"));
+ assert!(decode_render_image(&[], 4096, 4096, RenderLimits::default(), 4096).unwrap_err().contains("resource profile"));
+ let first = completed_preview(&mut h, [12, 34, 56]);
+ h.app.render_workspace.view.completed = Some(first);
+ // A new queued render must not become the source for Copy.
+ ribbon::perform_job(&mut h.app, "render.start").unwrap();
+ ribbon::perform_job(&mut h.app, "render.result.copy").unwrap();
+ let image = h.app.render_workspace.clipboard_image.as_ref().unwrap();
+ assert_eq!(image.size, [16, 16]);
+ assert_eq!(image.pixels[0], egui::Color32::from_rgb(12, 34, 56));
+ let document = h.app.session.doc.clone();
+ let undo = h.app.session.undo.len();
+ h.frame();
+ assert!(h.app.render_workspace.clipboard_image.is_none());
+ assert!(h.output.commands.iter().any(|command| matches!(command, egui::OutputCommand::CopyImage(image) if image.size == [16,16])));
+ assert!(Arc::ptr_eq(&document, &h.app.session.doc));
+ assert_eq!(undo, h.app.session.undo.len());
+}
+
+#[test]
+fn output_viewer_progress_keeps_stage_tools_and_cancel_cancels_without_closing_viewer() {
+ let mut h = output_viewer_fixture();
+ h.app.render_workspace.view.result = true;
+ ribbon::perform_job(&mut h.app, "render.start").unwrap();
+ let job = h.app.render_workspace.view.job.unwrap();
+ h.frames(3);
+ assert!(crate::scenario::rect_of("render:progress-pill").is_some());
+ assert!(crate::scenario::rect_of("render:stage:size").is_some());
+ assert!(crate::scenario::rect_of("render:hud").is_none());
+ h.step(&json!({"click":{"handle":"render:progress-cancel"}})).unwrap();
+ h.app.session.render_job_host().unwrap().pump(1024).unwrap();
+ assert_eq!(h.app.session.execute("render.status", &json!({"job":job})).unwrap()["progress"]["phase"], "cancelled");
+ assert!(h.app.render_workspace.view.result);
+ h.frames(3);
+ assert!(crate::scenario::rect_of("render:progress-pill").is_none());
+ h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
+ h.frames(3);
+ assert!(crate::scenario::handle_at("render:pick").is_some());
+}
+
+#[test]
+fn output_viewer_r_starts_active_setup_and_escape_returns_to_model_without_cancelling() {
+ let mut h = output_viewer_fixture();
+ h.app.render_workspace.view.name = "Active shot".into();
+ h.app.render_workspace.view.draft.width = 32;
+ h.app.render_workspace.view.draft.height = 24;
+ assert_eq!(crate::keymap::command_for(&h.app, "R"), Some("render.start"));
+ h.step(&json!({"key":"R"})).unwrap();
+ let job = h.app.render_workspace.view.job.unwrap();
+ assert_eq!(h.app.render_workspace.view.job_shot.as_deref(), Some("Active shot"));
+ let status = h.app.session.execute("render.status", &json!({"job":job})).unwrap();
+ assert_eq!(status["request"]["width"], 32);
+ assert_eq!(status["request"]["height"], 24);
+ // A repeated R while busy cannot fall through to Rectangle/Create Sketch.
+ h.step(&json!({"key":"R"})).unwrap();
+ assert_eq!(h.app.render_workspace.view.job, Some(job));
+ assert!(h.app.dialog.is_none() && h.app.tool.is_none());
+ h.app.run("render.result.view", json!({"view":"image"})).unwrap();
+ h.frames(2);
+ h.step(&json!({"key":"Escape"})).unwrap();
+ assert!(!h.app.render_workspace.view.result);
+ assert!(ribbon::busy(&h.app), "closing the image never cancels the job");
+ h.app.run("render.result.view", json!({"view":"image"})).unwrap();
+ h.app.viewport.nav = Some(crate::viewport::NavMode::Pan);
+ crate::keymap::press(&mut h.app, "Escape", false);
+ assert!(!h.app.render_workspace.view.result);
+ assert!(h.app.viewport.nav.is_none(), "closing the image releases its navigation capture");
+ enter(&mut h.app, false).unwrap();
+ assert_ne!(crate::keymap::command_for(&h.app, "R"), Some("render.start"));
+}
+
+/// Actual app controls and retained pixels, rasterized from egui without a window.
+#[test]
+fn output_viewer_evidence() {
+ let Some(dir) = std::env::var_os("SOLIDCRAFT_OUTPUT_EVIDENCE") else { return };
+ let dir = std::path::PathBuf::from(dir);
+ std::fs::create_dir_all(&dir).unwrap();
+ let previous = crate::theme::is_dark();
+ for dark in [false, true] {
+ let mut h = output_viewer_fixture();
+ h.app.run("solid.box", json!({"length":24,"width":18,"height":12})).unwrap();
+ inspector::fit_subject(&mut h.app).unwrap();
+ h.app.pending_fit = None;
+ h.app.cancel_view_animation();
+ h.app.preferences.render_inspector_width = 305.0;
+ h.app.run("render.output.size", json!({"width":1280,"height":720})).unwrap();
+ ribbon::perform_job(&mut h.app, "render.preflight").unwrap();
+ h.ctx = crate::fonts::test_context();
+ h.app.preferences.theme = if dark { "dark" } else { "light" }.into();
+ h.app.ui.dark = dark;
+ crate::theme::set_dark(dark);
+ crate::theme::apply(&h.ctx);
+ let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0));
+ let mut textures = std::collections::HashMap::new();
+ for (index, state) in ["settings", "check", "effects", "running", "completed"].into_iter().enumerate() {
+ if state == "check" {
+ inspector::reveal(&mut h.app, "render_output_check");
+ h.app.cancel_view_animation();
+ ribbon::perform_job(&mut h.app, "render.preflight").unwrap();
+ }
+ if state == "effects" {
+ select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ h.app.start("render.effects.describe");
+ }
+ if state == "running" {
+ select_image_method(&mut h.app, ImageMethod::Raster);
+ inspector::reveal(&mut h.app, "render_output_image");
+ // Retain a real first image while the next job makes bounded progress.
+ ribbon::perform_job(&mut h.app, "render.start").unwrap();
+ let host = h.app.session.render_job_host().unwrap().clone();
+ for _ in 0..1000 {
+ if !host.pump(65536).unwrap() {
+ break;
+ }
+ }
+ cache_render_images(&mut h.app, &h.ctx);
+ assert!(h.app.render_workspace.view.completed.is_some());
+ h.app.run("render.result.view", json!({"view":"image"})).unwrap();
+ ribbon::perform_job(&mut h.app, "render.start").unwrap();
+ host.pump(327680).unwrap();
+ assert!(ribbon::busy(&h.app));
+ }
+ if state == "completed" {
+ let host = h.app.session.render_job_host().unwrap().clone();
+ for _ in 0..1000 {
+ if !host.pump(65536).unwrap() {
+ break;
+ }
+ }
+ }
+ for frame in 0..10 {
+ let mut events = Vec::new();
+ if frame == 0 {
+ events.push(egui::Event::PointerMoved(egui::pos2(700.0, 500.0)));
+ }
+ let mut input = egui::RawInput {
+ screen_rect: Some(bounds),
+ focused: true,
+ time: Some((index * 10 + frame) as f64 / 60.0),
+ events,
+ ..Default::default()
+ };
+ h.app.raw_input_hook(&mut input);
+ let mut output = h.ctx.run_ui(input, |ui| {
+ h.app.logic(ui.ctx());
+ if state == "check" && frame == 9 {
+ // Check the settled, scrolled view immediately before capturing it.
+ ribbon::perform_job(&mut h.app, "render.preflight").unwrap();
+ }
+ h.app.ui(ui);
+ });
+ crate::ui_kit::update_test_textures(&mut textures, &output.textures_delta);
+ if frame == 9 {
+ if state == "check" {
+ for key in ["ready", "size", "transparency"] {
+ assert!(crate::scenario::rect_of(&format!("render:check:{key}")).is_some(), "{key}");
+ }
+ assert!(h.app.render_workspace.view.job.is_none());
+ }
+ crate::ui_kit::raster_ui(&h.ctx, output.shapes.clone(), output.pixels_per_point, bounds, &textures)
+ .save(dir.join(format!("output-{state}-{}.png", if dark { "dark" } else { "light" })))
+ .unwrap();
+ }
+ output.textures_delta.clear();
+ }
+ }
+ }
+ crate::theme::set_dark(previous);
+}
+
+#[test]
+fn output_viewer_radial_defaults_keep_planned_actions_disabled() {
+ let h = output_viewer_fixture();
+ let expected = [
+ "render.start",
+ "appearance.assign",
+ "render.lights.add",
+ "render.settings.set",
+ "render.camera.fit",
+ "render.compare",
+ "ui.workspace.design",
+ "undo",
+ ];
+ assert_eq!(crate::mouse_gesture::Studio::Render.defaults(), expected);
+ for id in ["render.lights.add", "render.compare"] {
+ assert!(!crate::mouse_gesture::item(&h.app, id).unwrap().enabled);
+ }
+}
+
+#[test]
+fn output_viewer_presets_are_commands_with_limits_and_custom_keeps_the_size() {
+ let mut h = output_viewer_fixture();
+ let document = h.app.session.doc.clone();
+ let undo = h.app.session.undo.len();
+ for (key, expected) in [("720", (1280, 720)), ("1080", (1920, 1080)), ("square", (2048, 2048))] {
+ h.step(&json!({"click":{"handle":format!("render:preset:{key}")}})).unwrap();
+ assert_eq!((h.app.render_workspace.view.draft.width, h.app.render_workspace.view.draft.height), expected);
+ }
+ h.step(&json!({"click":{"handle":"render:preset:4k"}})).unwrap();
+ assert_eq!((h.app.render_workspace.view.draft.width, h.app.render_workspace.view.draft.height), (2048, 2048));
+ h.step(&json!({"click":{"handle":"render:preset:custom"}})).unwrap();
+ assert!(h.app.render_workspace.view.inspector.resolution.custom);
+ assert_eq!((h.app.render_workspace.view.draft.width, h.app.render_workspace.view.draft.height), (2048, 2048));
+ assert!(Arc::ptr_eq(&document, &h.app.session.doc));
+ assert_eq!(undo, h.app.session.undo.len());
+ assert!(h.app.render_workspace.view.job.is_none());
+}
+
+#[test]
+fn output_viewer_has_sections_without_pages_or_footer_and_selected_row_routes_to_output() {
+ for dark in [false, true] {
+ let mut h = output_viewer_fixture();
+ h.app.preferences.theme = if dark { "dark" } else { "light" }.into();
+ h.app.ui.dark = dark;
+ h.call("ui.resize", json!({"width":1440,"height":900}));
+ h.frames(3);
+ for key in ["render.output_image", "render.output_effects", "render.output_check"] {
+ assert!(crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr(key))).is_some(), "{key}");
+ }
+ assert!(crate::scenario::rect_of("render:job-footer").is_none());
+ for page in ["output", "effects", "all"] {
+ assert!(crate::scenario::rect_of(&format!("render:page:{page}")).is_none());
+ }
+ let tools = crate::scenario::rect_of("render:stage_tools").unwrap();
+ for target in ["render:stage:size", "render:stage:check"] {
+ assert!(tools.contains_rect(crate::scenario::rect_of(target).unwrap()));
+ }
+ h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
+ h.frames(3);
+ assert!(crate::scenario::rect_of("render:output-width").is_some(), "selected Output keeps its editor when the stage changes");
+ }
+}
diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs
index d190d5958a..66e6d7247c 100644
--- a/crates/ui-egui/src/toolbar.rs
+++ b/crates/ui-egui/src/toolbar.rs
@@ -2273,6 +2273,10 @@ pub fn shortcuts(app: &mut SolveApp, ctx: &egui::Context) {
match k {
Key::Escape => {
app.esc_handled = true;
+ if crate::render_workspace::result_active(app) {
+ crate::keymap::press(app, "Escape", repeat);
+ continue;
+ }
// End navigation before the underlying tool or dialog; sketch double-Escape
// handling starts with the next press.
if app.viewport.nav.take().is_some() {
diff --git a/crates/ui-egui/src/ui_kit/choice.rs b/crates/ui-egui/src/ui_kit/choice.rs
index 8658d7e4a8..21a81a7c4f 100644
--- a/crates/ui-egui/src/ui_kit/choice.rs
+++ b/crates/ui-egui/src/ui_kit/choice.rs
@@ -20,6 +20,8 @@ pub(crate) struct Segments<'a> {
pub dense: bool,
pub small: bool,
pub states: &'a [bool],
+ /// Per-segment disabled explanation; unavailable choices remain visible.
+ pub disabled_reasons: &'a [Option<&'a str>],
pub compact: bool,
pub primary: bool,
pub intrinsic: bool,
@@ -33,7 +35,7 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con
if crate::prefs_search::querying(ui) && !crate::prefs_search::shows_all(ui) {
crate::prefs_search::reveal(ui);
}
- let Segments { targets, icons, workspace_accent, dense, small, states, compact, primary, intrinsic, proportional } = config;
+ let Segments { targets, icons, workspace_accent, dense, small, states, disabled_reasons, compact, primary, intrinsic, proportional } = config;
let accent = crate::theme::TabAccent::current(ui.ctx());
let t = Tokens::get();
let catalog = super::layout::in_catalog(ui);
@@ -55,7 +57,7 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con
.fold(0.0, f32::max);
// Judged on the whole row, which is what a scrollbar narrows, not on one segment.
let need = if intrinsic { total } else { (widest + 2.0 * t.space_8) * options.len() as f32 };
- if !proportional && !compact && !super::fits_steadily(ui, label(ui), need, segment_width * options.len() as f32) {
+ if disabled_reasons.is_empty() && !proportional && !compact && !super::fits_steadily(ui, label(ui), need, segment_width * options.len() as f32) {
let before = *selected;
let id = format!("segments_fallback_{}", label(ui));
dropdown(ui, &id, selected, options);
@@ -86,7 +88,14 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con
if (intrinsic || proportional) && total > 0.0 { natural.get(index).copied().unwrap_or(0.0) * rect.width() / total } else { equal_width };
let segment = egui::Rect::from_min_size(egui::pos2(x, rect.top()), vec2(width, rect.height()));
x += width;
- let response = ui.interact(segment, ui.make_persistent_id(("segment", index)), egui::Sense::click());
+ let reason = disabled_reasons.get(index).copied().flatten();
+ let enabled = ui.is_enabled() && reason.is_none();
+ let id = ui.make_persistent_id(("segment", index));
+ let response = if reason.is_some() {
+ ui.add_enabled_ui(false, |ui| ui.interact(segment, id, egui::Sense::click())).inner
+ } else {
+ ui.interact(segment, id, egui::Sense::click())
+ };
let on = states.get(index).copied().unwrap_or(*selected == index);
let rounding = egui::CornerRadius {
nw: if index == 0 { t.control_radius } else { 0 },
@@ -132,7 +141,9 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con
text_rect,
option,
font,
- if on && primary {
+ if reason.is_some() {
+ t.form_dim
+ } else if on && primary {
t.on_accent
} else if on && workspace_accent {
accent.ink
@@ -144,7 +155,7 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con
false,
);
t.button_bevel_with_radius(ui, &response, on, rounding);
- response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Button, ui.is_enabled(), on, *option));
+ response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Button, enabled, on, *option));
scenario::publish_target(&format!("dialog:{}:{option}", label(ui)), segment);
if let Some(target) = targets.get(index) {
let visible = segment.intersect(ui.clip_rect());
@@ -152,7 +163,8 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con
scenario::publish_target(target, visible);
}
}
- if response.on_hover_text(*option).clicked() {
+ let response = if let Some(reason) = reason { response.on_disabled_hover_text(reason) } else { response.on_hover_text(*option) };
+ if response.clicked() && enabled {
*selected = index;
clicked = true;
}
diff --git a/crates/ui-egui/src/ui_kit/choice_tests.rs b/crates/ui-egui/src/ui_kit/choice_tests.rs
index 11795f7170..186f8677ad 100644
--- a/crates/ui-egui/src/ui_kit/choice_tests.rs
+++ b/crates/ui-egui/src/ui_kit/choice_tests.rs
@@ -228,3 +228,86 @@ fn save_shot_dashes_leave_rounded_corners_at_the_chip_radius() {
}
output.textures_delta.clear();
}
+
+#[test]
+fn segmented_unavailable_choices_remain_visible_and_cannot_change_selection() {
+ let ctx = crate::fonts::test_context();
+ let mut selected = 1;
+ let mut draw = |ui: &mut Ui| {
+ row(ui, "Quality", |ui| {
+ segmented(
+ ui,
+ &mut selected,
+ &["Draft", "Custom"],
+ Segments { disabled_reasons: &[Some("waiting for the quality contract"), None], ..Default::default() },
+ )
+ });
+ };
+ frame(&ctx, vec![], &mut draw);
+ let draft = scenario::handle_at("dialog:Quality:Draft").unwrap();
+ frame(&ctx, pointer(draft, true), &mut draw);
+ frame(&ctx, pointer(draft, false), &mut draw);
+ assert_eq!(selected, 1);
+ assert!(scenario::handle_at("dialog:Quality:Custom").is_some());
+}
+
+#[test]
+fn output_radio_rows_keep_titles_summaries_and_disabled_choices_in_both_themes() {
+ for dark in [false, true] {
+ let tokens = if dark { crate::theme::Tokens::dark() } else { crate::theme::Tokens::light() };
+ let _restore = crate::theme::scoped_tokens(tokens);
+ for language in ["en", "ja", "zh", "de", "ko"] {
+ let locale = crate::i18n::Locale::for_language(language);
+ let ctx = crate::fonts::test_context();
+ let mut enabled = true;
+ let mut clicked = false;
+ let mut draw = |ui: &mut Ui| {
+ ui.set_width(240.0);
+ let response = ui
+ .add_enabled_ui(enabled, |ui| {
+ settings_choice_row(
+ ui,
+ &SettingsChoice {
+ key: "test:output:radio",
+ title: locale.text("render.size_full_hd"),
+ summary: "1920 × 1080",
+ detail: "Full HD",
+ },
+ true,
+ )
+ })
+ .inner;
+ assert_eq!(response.rect.height(), 40.0);
+ assert_eq!(response.rect.width(), 240.0);
+ clicked |= response.clicked();
+ };
+ let output = crate::test_support::frame(&ctx, egui::RawInput::default(), &mut draw);
+ let texts: Vec<_> = crate::test_support::text_shapes(&output).collect();
+ let title = texts.iter().find(|text| text.galley.text() == locale.text("render.size_full_hd")).unwrap();
+ let summary = texts.iter().find(|text| text.galley.text() == "1920 × 1080").unwrap();
+ assert!(title.pos.x + title.galley.size().x <= summary.pos.x, "{language}: title must clear its summary");
+ frame(&ctx, vec![], &mut draw);
+ let point = scenario::handle_at("test:output:radio").unwrap();
+ frame(&ctx, pointer(point, true), &mut draw);
+ frame(&ctx, pointer(point, false), &mut draw);
+ assert!(clicked);
+ enabled = false;
+ clicked = false;
+ let mut disabled = |ui: &mut Ui| {
+ ui.add_enabled_ui(enabled, |ui| {
+ clicked |= settings_choice_row(
+ ui,
+ &SettingsChoice { key: "test:output:radio", title: "4K", summary: "3840 × 2160", detail: "Over budget" },
+ false,
+ )
+ .clicked();
+ });
+ };
+ frame(&ctx, vec![], &mut disabled);
+ let point = scenario::handle_at("test:output:radio").unwrap();
+ frame(&ctx, pointer(point, true), &mut disabled);
+ frame(&ctx, pointer(point, false), &mut disabled);
+ assert!(!clicked);
+ }
+ }
+}
diff --git a/crates/ui-egui/src/ui_kit/container.rs b/crates/ui-egui/src/ui_kit/container.rs
index 2bc6ed1a51..b9117d78b0 100644
--- a/crates/ui-egui/src/ui_kit/container.rs
+++ b/crates/ui-egui/src/ui_kit/container.rs
@@ -100,6 +100,19 @@ impl Container {
})
}
+ /// Reserve an anchored one-row Navigation card and the common card gap.
+ pub(crate) fn below_navigation_row(bounds: egui::Rect) -> egui::Rect {
+ let t = Tokens::get();
+ egui::Rect::from_min_max(egui::pos2(bounds.left(), (bounds.top() + t.control_height + t.space_8 * 2.0).min(bounds.bottom())), bounds.max)
+ }
+
+ /// Inline navigation band using the same chrome and padding as anchored HUDs.
+ pub(crate) fn navigation_contents<R>(ui: &mut egui::Ui, add: impl FnOnce(&mut egui::Ui) -> R) -> egui::InnerResponse<R> {
+ let container = Self::new(ui.ctx(), Surface::Navigation);
+ let frame = container.frame(ui.ctx(), Tokens::get().overlay, Side::Left).inner_margin(Tokens::get().space_4);
+ container.show_frame(ui, frame, ui.max_rect(), |ui| super::scope(ui, add))
+ }
+
/// Declare contacts from shell geometry; styling remains entirely in the container.
pub fn joined(mut self, edges: DockEdges) -> Self {
self.joined = Some(edges);
diff --git a/crates/ui-egui/src/ui_kit/fields.rs b/crates/ui-egui/src/ui_kit/fields.rs
index 502c549436..eb4e3dc500 100644
--- a/crates/ui-egui/src/ui_kit/fields.rs
+++ b/crates/ui-egui/src/ui_kit/fields.rs
@@ -451,6 +451,29 @@ pub(crate) fn value_pair(ui: &mut Ui, label: &str, values: [&mut String; 2], axe
})
}
+/// Paired bounded numeric fields in the shared value-pair row geometry.
+pub(crate) fn number_pair<T: egui::emath::Numeric>(
+ ui: &mut Ui,
+ label: &str,
+ values: [&mut T; 2],
+ range: std::ops::RangeInclusive<T>,
+ speed: f64,
+ suffix: &str,
+) -> [Response; 2] {
+ let t = Tokens::get();
+ super::row(ui, label, |ui| {
+ let width = ((dimension(ui.available_width()) - t.space_8) / 2.0).max(0.0);
+ ui.spacing_mut().item_spacing.x = t.space_8;
+ values.map(|value| {
+ ui.allocate_ui_with_layout(vec2(width, row_height()), egui::Layout::left_to_right(egui::Align::Center), |ui| {
+ ui.set_clip_rect(ui.clip_rect().intersect(ui.max_rect()));
+ number_field(ui, value, range.clone(), speed, suffix)
+ })
+ .inner
+ })
+ })
+}
+
/// Variable-radius location editor. Tokens: scope's control and typography tokens.
/// Retains the established 0.01 step, fractional range and locale parser.
/// Locale-aware variable-radius position editor. Tokens: `scope control/font tokens`.
diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs
index b4c87efc14..131b90de66 100644
--- a/crates/ui-egui/src/ui_kit/gallery.rs
+++ b/crates/ui-egui/src/ui_kit/gallery.rs
@@ -168,6 +168,16 @@ const ELEMENTS: &[Element] = &[
element!("searchable_icon_dropdown", |ui, _| {
searchable_icon_dropdown(ui, "spin", "Replace…", &mut String::new(), &[]);
}),
+ element!("number_pair", |ui, _| {
+ let (mut w, mut h) = (1920, 1080);
+ number_pair(ui, "Size", [&mut w, &mut h], 1..=16384, 1.0, "");
+ }),
+ element!("progress_action", |ui, _| {
+ progress_action(ui, "Rendering · 62%", 0.62, "Cancel");
+ }),
+ element!("settings_choice_row", |ui, _| {
+ settings_choice_row(ui, &SettingsChoice { key: "gallery:radio_row", title: "Preview", summary: "1280 × 720", detail: "Preview size" }, true);
+ }),
element!("icon_label_action", |ui, _| {
icon_label_action(ui, "Render Image", Some("play"), true, true);
}),
@@ -255,6 +265,20 @@ const ELEMENTS: &[Element] = &[
let mut value = 0.5;
mixed_scalar_field(ui, &mut value, 0.0..=1.0, Some("Mixed"));
}),
+ element!("check_line", |ui, _s| {
+ check_line(ui, "gallery:check_ok", "Ready", false);
+ }),
+ element!("check_line_warning", |ui, _s| {
+ check_line(ui, "gallery:check_warning", "Transparency approximation", true);
+ }),
+ element!("segmented_unavailable", |ui, s| {
+ segmented(
+ ui,
+ &mut s.selected,
+ &["Draft", "Custom"],
+ Segments { disabled_reasons: &[Some("waiting for the quality contract"), None], ..Default::default() },
+ );
+ }),
element!("sphere_grid", |ui, _| {
let sphere = Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None };
let tiles = ["gallery:grid:a", "gallery:grid:b", "gallery:grid:c"].map(|id| SphereTile {
diff --git a/crates/ui-egui/src/ui_kit/preferences_assistant.rs b/crates/ui-egui/src/ui_kit/preferences_assistant.rs
index a536b6a25d..92d1daa132 100644
--- a/crates/ui-egui/src/ui_kit/preferences_assistant.rs
+++ b/crates/ui-egui/src/ui_kit/preferences_assistant.rs
@@ -39,7 +39,7 @@ fn choice_row(ui: &mut Ui, choices: &[SettingsChoice<'_>], selected: &mut usize,
ui.spacing_mut().item_spacing.x = t.space_8;
for index in keep {
let Some(choice) = choices.get(*index) else { continue };
- let response = choice_card(ui, width, choice, *selected == *index);
+ let response = choice_card(ui, width, choice, *selected == *index, false);
if response.clicked() {
*selected = *index;
changed = true;
@@ -49,39 +49,57 @@ fn choice_row(ui: &mut Ui, choices: &[SettingsChoice<'_>], selected: &mut usize,
changed
}
-fn choice_card(ui: &mut Ui, width: f32, choice: &SettingsChoice<'_>, selected: bool) -> Response {
+/// Compact radio tile for preset lists, sharing the settings choice painter and tokens.
+pub(crate) fn settings_choice_row(ui: &mut Ui, choice: &SettingsChoice<'_>, selected: bool) -> Response {
+ choice_card(ui, dimension(ui.available_width()), choice, selected, true)
+}
+fn choice_card(ui: &mut Ui, width: f32, choice: &SettingsChoice<'_>, selected: bool, row: bool) -> Response {
let t = Tokens::get();
- let height = t.space_24 * 3.0 + t.space_16;
+ let accent = crate::theme::TabAccent::current(ui.ctx());
+ let selected_bg = if row { accent.soft } else { t.selected_bg };
+ let selected_ink = if row { accent.ink } else { t.selected_ink };
+ let primary = if row { accent.color } else { t.form_primary };
+ let height = if row { t.space_24 + t.space_16 } else { t.space_24 * 3.0 + t.space_16 };
let (rect, response) = ui.allocate_exact_size(vec2(width, height), Sense::click());
ui.painter().rect(
rect,
t.radius_lg,
if selected {
- t.selected_bg
+ selected_bg
} else if response.hovered() {
t.hover
} else {
t.control_fill
},
- if selected { Stroke::new(2.0, t.form_primary) } else { t.control_border_stroke(t.control_border) },
+ if selected { Stroke::new(if row { 1.0 } else { 2.0 }, primary) } else { t.control_border_stroke(t.control_border) },
egui::StrokeKind::Inside,
);
- let radio = pos2(rect.left() + t.space_16, rect.top() + t.space_16);
+ let radio = pos2(rect.left() + t.space_16, if row { rect.center().y } else { rect.top() + t.space_16 });
ui.painter().circle(
radio,
t.space_6,
t.control_fill,
- if selected { Stroke::new(1.0, t.form_primary) } else { t.control_border_stroke(t.control_border) },
+ if selected { Stroke::new(1.0, primary) } else { t.control_border_stroke(t.control_border) },
);
if selected {
- ui.painter().circle_filled(radio, t.space_3, t.form_primary);
+ ui.painter().circle_filled(radio, t.space_3, primary);
+ }
+ let title = if row {
+ Rect::from_min_max(pos2(radio.x + t.space_12, rect.top()), pos2(rect.right() - t.space_8, rect.bottom()))
+ } else {
+ Rect::from_min_max(pos2(radio.x + t.space_12, rect.top() + t.space_4), pos2(rect.right() - t.space_8, rect.top() + t.space_24 + t.space_4))
+ };
+ let summary_width = ui.painter().layout_no_wrap(choice.summary.into(), FontId::proportional(t.font_small), t.form_dim).size().x;
+ let title = if row { Rect::from_min_max(title.min, title.max - vec2(summary_width + t.space_8, 0.0)) } else { title };
+ paint_text(ui, title, choice.title, crate::fonts::semibold(t.font_label), if selected { selected_ink } else { t.form_ink }, false);
+ if row {
+ let body = Rect::from_min_max(pos2(rect.right() - t.space_8 - summary_width, rect.top()), rect.max - vec2(t.space_8, 0.0));
+ paint_text(ui, body, choice.summary, FontId::proportional(t.font_small), t.form_dim, false);
+ } else {
+ let body = Rect::from_min_max(pos2(rect.left() + t.space_12, title.bottom() + t.space_4), rect.max - vec2(t.space_12, t.space_8));
+ let galley = ui.painter().layout(choice.summary.to_owned(), FontId::proportional(t.font_small), t.form_dim, body.width());
+ ui.painter().with_clip_rect(ui.clip_rect().intersect(body)).galley(body.min, galley, t.form_dim);
}
- let title =
- Rect::from_min_max(pos2(radio.x + t.space_12, rect.top() + t.space_4), pos2(rect.right() - t.space_8, rect.top() + t.space_24 + t.space_4));
- paint_text(ui, title, choice.title, crate::fonts::semibold(t.font_label), if selected { t.selected_ink } else { t.form_ink }, false);
- let body = Rect::from_min_max(pos2(rect.left() + t.space_12, title.bottom() + t.space_4), rect.max - vec2(t.space_12, t.space_8));
- let galley = ui.painter().layout(choice.summary.to_owned(), FontId::proportional(t.font_small), t.form_dim, body.width());
- ui.painter().with_clip_rect(ui.clip_rect().intersect(body)).galley(body.min, galley, t.form_dim);
response.widget_info(|| {
egui::WidgetInfo::selected(egui::WidgetType::RadioButton, ui.is_enabled(), selected, format!("{}: {}", choice.title, choice.detail))
});
diff --git a/crates/ui-egui/src/ui_kit/status.rs b/crates/ui-egui/src/ui_kit/status.rs
index 7ea311fb7d..0eafeb89d9 100644
--- a/crates/ui-egui/src/ui_kit/status.rs
+++ b/crates/ui-egui/src/ui_kit/status.rs
@@ -88,3 +88,30 @@ pub(crate) fn completion_text(ui: &mut egui::Ui, label: &str, complete: bool) ->
response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Label, ui.is_enabled(), label));
response
}
+
+/// Read-only check row with shared success/warning artwork and token-sized icon.
+pub(crate) fn check_line(ui: &mut egui::Ui, key: &str, label: &str, warning: bool) -> egui::Response {
+ let t = Tokens::get();
+ let response = ui
+ .horizontal(|ui| {
+ let (rect, _) = ui.allocate_exact_size(vec2(t.form_icon_size, t.form_icon_size), egui::Sense::hover());
+ crate::icons::paint_icon(ui.painter(), rect, if warning { "status_warning" } else { "finish" }, 1.0);
+ super::text(ui, label, super::Text::Report(key, false));
+ })
+ .response;
+ crate::scenario::publish_rect(key, response.rect);
+ response
+}
+
+/// Single-row render status for a shared Navigation card. The caller dispatches Cancel.
+pub(crate) fn progress_action(ui: &mut egui::Ui, caption: &str, fraction: f32, cancel: &str) -> egui::Response {
+ let t = Tokens::get();
+ ui.horizontal(|ui| {
+ super::text(ui, caption, super::Text::Inline);
+ ui.allocate_ui_with_layout(vec2(t.space_24 * 6.0, t.control_height), egui::Layout::left_to_right(egui::Align::Center), |ui| {
+ progress(ui, "render-pill", fraction);
+ });
+ super::button(ui, cancel, super::Button::Normal)
+ })
+ .inner
+}
diff --git a/docs/render-workspace.md b/docs/render-workspace.md
index 8085eef4af..d35126e07f 100644
--- a/docs/render-workspace.md
+++ b/docs/render-workspace.md
@@ -52,9 +52,9 @@ catalog navigation from the Inspector retains the read-only resource browser.
Light hosts the existing native studios and HDR environments in the same tile grid.
A click runs `render.preset.apply` or `render.library.environment.apply`, preserving
those commands' validation and undo behavior. Studios require an explicitly selected
-GPU path setup; environments require CPU or GPU ray tracing. Frame and Output show
-faded Frame presets / Size presets placeholders with their Shot editor / Output
-editor reasons. Stage navigation itself never applies a resource.
+GPU path setup; environments require CPU or GPU ray tracing. Frame shows a faded
+Frame presets placeholder with its Shot editor reason. Output hosts the Size presets
+card described below. Stage navigation itself never applies a resource.
The 110 pt compass uses the free canvas beside the Inspector; the navigation bar
keeps its shared handler. The Shots strip's independent `view.shots_strip`
@@ -406,8 +406,8 @@ current numerical image setup, without inventing a saved rig.
engine selection), Environment, Light, Shot and Output. It belongs to each document
view and is never saved in a design. `view.render_select` validates semantic focus
requests without opening dialogs or editing/evaluating a design. Object picks and
-Browser selections keep the existing selection commands. Inspector routing stays
-as before; the focus state is available to a later Inspector change.
+Browser selections keep the existing selection commands. Selecting Output opens the Output editor. Other focus types retain their existing
+Inspector routing for subsequent selection-following editor changes.
Look expands Objects, Light expands Lights and Environment, and Frame expands
Shots. Output leaves expansion unchanged. Stages preserve selection and never
@@ -424,4 +424,26 @@ texture-map, reflection and aging controls. The separate Textures disclosure is
marked Soon. The shared footer exports the design library through `library.export`
and resets the current target's override through `appearance.assign`.
`view.render_inspector {visible}` controls transient per-document visibility;
-selecting a stage reopens the editor. Selection focus routing is deferred.
+selecting a stage reopens the editor. Output selection routes to its dedicated editor;
+other semantic selection focus routing remains deferred.
+
+## Output editor
+
+The Output stage offers size, format, quality and a Check summary in the stage bar's
+second row. Its lower-left Size presets card offers Preview (1280 × 720), Full HD,
+4K, Square and Custom. Presets outside the selected executor's limits stay visible
+with a disabled explanation. Custom retains the current size and reveals its fields.
+Numerical size edits and presets use `render.output.size`; they never save a shot
+or start a job.
+
+Selecting Output in the Browser shows one editor with Image, Effects and Check
+sections, without page navigation or pinned job actions. Image retains size/aspect,
+format, sampling, method, transparency and export destination controls. Effects owns
+tone, bloom, grading and regrade. Check retains the preflight list, freshness checks,
+installed backend/status metadata and expandable diagnostics. Named quality presets
+and EXR settings remain unavailable with their existing reasons. Destination selection
+uses the existing completed-image export picker.
+
+Render and Cancel stay in the stage bar. Active jobs also show a single-row progress
+pill with Cancel. The result viewer retains Copy, export, close, Fit/100% and shared
+pan/zoom. R starts the active setup; Escape closes the image without cancelling its job.
diff --git a/docs/ui-kit.md b/docs/ui-kit.md
index 5de5f3ce77..6aa7076f6f 100644
--- a/docs/ui-kit.md
+++ b/docs/ui-kit.md
@@ -152,7 +152,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera
| `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 |
| `color_field`, `color_popover` | Opaque document RGB swatch and kit popover; global U8/F segments, copy, gamma-byte or linear RGB fields, painter-drawn HSV square/hue and current strip; outside click dismisses | `control_*`, `form_*`, `border`, `on_accent`, `space_*` |
-| choice: `segmented`, `Segments` | Equal text choices; `states` supplies mixed selection, `compact` clips instead of falling back to a dropdown, `primary` uses accent/on-accent for the selected segment | `control_*`, `selected_bg/ink`, `font_label`, `space_4/8` |
+| choice: `segmented`, `Segments` | Equal text choices; `states` supplies mixed selection, `disabled_reasons` keeps unavailable choices visible with an explanation, `compact` clips instead of falling back to a dropdown, `primary` uses accent/on-accent for the selected segment | `control_*`, `selected_bg/ink`, `font_label`, `space_4/8` |
| `segmented_icons`, `IconSegment` | Equal icon choices and mixed states | segment tokens, icon palette |
| `checkbox`, `checkbox_indeterminate`, `checkbox_row`, `checkbox_grid`, `options` | One box/tick painter for inline, mixed, full-row, grid and menu choices | `space_14/3/2`, `radius_sm`, `control_fill/border`, `form_primary/ink`, `hover`, `on_accent` |
| `text_emphasis` | Bold/italic with translated accessible names | form control/font tokens |
@@ -739,3 +739,12 @@ shared token paint and hit targets. All are exercised in the kit gallery.
| method_section | Compact, initially collapsed editor section with a method tag; unsupported contents remain inspectable and disabled, with a translated reason visible even when collapsed. Uses editor_section typography and spacing. |
| vector3_field | Three bounded number fields divide the row's control column evenly, retaining the shared parser, focus and bevels. Used for RGB absorption and world-space origin/repeat vectors. |
| sphere_preview_with_source | Sample card with an interactive source tag, retaining the sphere, name, usage badge and trailing action. Appearance uses the tag to inspect its inheritance chain. |
+
+The compact `settings_choice_row` variant reuses the shared settings radio-card painter
+for preset lists: 40 pt rows, right-aligned summaries and the active workspace accent.
+`progress_action` keeps a status caption, bounded progress track and Cancel action on
+one row inside a Navigation card. `Container::below_navigation_row` reserves that card
+and its shared gap above an inline result toolbar.
+
+`number_pair` extends the shared value-pair row to bounded numeric fields (such as
+image width and height), preserving label alignment, clipping and number-field behavior.