Skip to content

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

Render stage panels: Surfaces and references, Studios and environments, and the review dialogs (#6281) (#7999)

Nathan Danea545f321136f
diff --git a/assets/locales/pending/render-stage-complete.json b/assets/locales/pending/render-stage-complete.json
new file mode 100644
index 0000000000..19d2920c90
--- /dev/null
+++ b/assets/locales/pending/render-stage-complete.json
@@ -0,0 +1,272 @@
+{
+ "ar": {
+ "render.stage_layout.appearance_note": "انقر للتطبيق على التحديد.",
+ "render.stage_layout.studio_note": "انقر للمراجعة قبل التطبيق.",
+ "render.stage_panels.acknowledge": "أقرّ بالاستبدال والقيود",
+ "render.stage_panels.apply": "تطبيق",
+ "render.stage_panels.captured_bounds": "استخدام حدود المشهد الملتقطة",
+ "render.stage_panels.depth": "العمق",
+ "render.stage_panels.kept": "ما يُحتفظ به",
+ "render.stage_panels.kept_fields": "الكاميرا، وأخذ العيّنات، والأبعاد، والروابط البصرية، وهندسة CAD، والخصائص الهندسية.",
+ "render.stage_panels.mine": "الخاصة بي",
+ "render.stage_panels.mine_pending": "حفظ الاستوديوهات الشخصية غير مدعوم بعد.",
+ "render.stage_panels.omits": "ما يُغفل",
+ "render.stage_panels.partial_reference": "المرشحات: قيم موثقة المصدر فقط؛ راجع الدرجة والحالة والمصادر. تبقى القيم المجهولة مجهولة.",
+ "render.stage_panels.plane": "مستوى",
+ "render.stage_panels.projects": "يُسقط",
+ "render.stage_panels.reference": "مرجع",
+ "render.stage_panels.references": "مراجع",
+ "render.stage_panels.remove_optics_help": "يزيل البصريات المحفوظة من هذه اللقطة. تُحفظ الهندسة المصدر.",
+ "render.stage_panels.remove_optics_title": "إزالة البصريات المحفوظة؟",
+ "render.stage_panels.remove_stage_help": "يزيل الألواح السلبية المحفوظة من هذه اللقطة. تبقى خلفية الكاميرا.",
+ "render.stage_panels.remove_stage_title": "إزالة المنصة المحفوظة؟",
+ "render.stage_panels.repeat": "التكرار",
+ "render.stage_panels.replaces": "ما يُستبدل",
+ "render.stage_panels.replaces_environment": "البيئة",
+ "render.stage_panels.replaces_maps": "الخرائط المؤقتة على الجسم المختار؛ قد تتعارض معها البصريات المحفوظة.",
+ "render.stage_panels.replaces_physical": "لا شيء. هذه الخطة للقراءة فقط.",
+ "render.stage_panels.replaces_quality": "أبعاد الصورة، وعدد العيّنات الثابت، وعمق المسار، وبذرة التوليد، وإزالة التشويش.",
+ "render.stage_panels.replaces_rig": "الإضاءة والبيئة والمنصة",
+ "render.stage_panels.replaces_saved_maps": "خرائط الأسطح المحفوظة على الجسم المختار؛ قد تتعارض معها التجاوزات المؤقتة.",
+ "render.stage_panels.replaces_stage": "الأرضية المحفوظة وألواح المنصة السلبية",
+ "render.stage_panels.replaces_studio": "الإضاءة والبيئة والتعريض والمنصة",
+ "render.stage_panels.replaces_uniform": "المظهر المعتم على الجسم المختار. تُقرَّب الخرائط المكانية بقيم موحّدة.",
+ "render.stage_panels.review_environment": "مراجعة البيئة",
+ "render.stage_panels.review_maps": "مراجعة خرائط GPU",
+ "render.stage_panels.review_physical": "خطة المرجع الفيزيائي",
+ "render.stage_panels.review_quality": "استخدام ميزانية ثابتة لأخذ العيّنات",
+ "render.stage_panels.review_rig": "ملاءمة طقم الإضاءة",
+ "render.stage_panels.review_saved_maps": "مراجعة الخرائط المحفوظة",
+ "render.stage_panels.review_stage": "مراجعة الأرضية والمنصة",
+ "render.stage_panels.review_studio": "مراجعة الاستوديو الأصلي",
+ "render.stage_panels.review_uniform": "مراجعة المظهر الموحّد",
+ "render.stage_panels.scope": "النطاق",
+ "render.stage_panels.search_studios": "البحث عن استوديوهات",
+ "render.stage_panels.search_surfaces": "البحث عن أسطح ومراجع",
+ "render.stage_panels.specifications": "المواصفات · للقراءة فقط",
+ "render.stage_panels.studio_note": "انقر للمراجعة. لا يستبدل التطبيق الإضاءة والبيئة والمنصة إلا بعد تأكيدك. تبقى الأضواء قابلة للتحرير.",
+ "render.stage_panels.studios": "الاستوديوهات",
+ "render.stage_panels.subtitle_environment": "بيئة HDR أصلية · المشهد بأكمله",
+ "render.stage_panels.subtitle_maps": "خرائط مكانية مُعدّة · معاينة مؤقتة",
+ "render.stage_panels.subtitle_physical": "خطة للقراءة فقط · لا تُنشأ مادة ولا تُعيَّن",
+ "render.stage_panels.subtitle_quality": "ميزانية GPU ثابتة · تُغفل المتطلبات المستقبلية",
+ "render.stage_panels.subtitle_rig": "طقم إضاءة مُعدّ · باعثات وبطاقات سلبية",
+ "render.stage_panels.subtitle_saved_maps": "خرائط مُعدّة · محفوظة مع هذه اللقطة",
+ "render.stage_panels.subtitle_stage": "أرضية ومنصة فيزيائيتان · ملائمتان للمنتج",
+ "render.stage_panels.subtitle_studio": "استوديو أصلي · يُطبَّق على المشهد بأكمله",
+ "render.stage_panels.subtitle_uniform": "تقريب موحّد · ليس مادة مقاسة",
+ "render.stage_panels.surfaces_references": "الأسطح والمراجع",
+ "render.stage_panels.target": "الهدف",
+ "render.stage_panels.use_maps": "استخدام خرائط GPU",
+ "render.stage_panels.use_uniform": "استخدام المظهر الموحّد",
+ "render.stage_panels.kept_quality": "الطريقة، والكاميرا، والإضاءة، والبيئة، والمنصة، والبصريات، والتعريض، وتعيين درجات اللون.",
+ "render.stage_panels.paint_pending": "التلوين والتعيين بالسحب غير مدعومين بعد. اختر هدفًا لتطبيق مظهر.",
+ "render.stage_panels.quality_omissions": "التوقف التكيّفي وأهداف الخطأ، وعمق نفاذ منفصل، وقواعد الروليت الروسية، والإخراج الخطي الخام، ونسخة EXR الأصلية، وشهادة التقارب.",
+ "render.stage_panels.appearance_note": "انقر للتطبيق على التحديد. اسحب إلى النموذج. عند عدم تحديد شيء، يفعّل النقر أداة التلوين.",
+ "render.stage_panels.badge_native": "أصلي",
+ "render.stage_panels.badge_projection": "إسقاط",
+ "render.stage_panels.badge_reference": "مرجع",
+ "render.stage_panels.badge_specification": "مواصفات فقط",
+ "render.stage_panels.badge_blocked": "محظور",
+ "render.stage_panels.rig_summary": "طقم إضاءة مُعدّ · {emitters} باعثات، {cards} بطاقات",
+ "render.stage_panels.candidate_summary": "المرشحات: {count} قيم موثقة المصدر. تحتاج الدرجة والتشطيب إلى مراجعة.",
+ "render.stage_panels.apply_studio": "تطبيق الاستوديو",
+ "render.stage_panels.centre": "المركز",
+ "render.stage_panels.extent": "الامتداد",
+ "render.stage_panels.fit_save": "ملاءمة وحفظ",
+ "render.stage_panels.use_budget": "استخدام هذه الميزانية",
+ "render.stage_panels.quality_ack": "أقرّ بالميزانية الثابتة وما تُغفله",
+ "render.stage_panels.studio_ack": "تأكيد استبدال الإضاءة والبيئة والتعريض والمنصة",
+ "render.stage_panels.keep": "احتفاظ",
+ "render.stage_panels.remove_stage": "إزالة المنصة",
+ "render.stage_panels.remove_optics": "إزالة البصريات",
+ "render.stage_panels.remove_shot": "إزالة اللقطة",
+ "render.stage_panels.rigs": "أطقم الإضاءة",
+ "render.stage_panels.environments": "البيئات",
+ "render.stage_panels.surfaces": "الأسطح",
+ "render.stage_panels.prepare_plan": "تجهيز خطة الإنشاء",
+ "render.stage_panels.save_maps": "حفظ الخرائط في هذه اللقطة",
+ "render.stage_panels.source_note": "خريطة مصدر للون الأساسي مُعدّة. ليست مادة مقاسة.",
+ "render.stage_panels.gpu_required": "يتطلب تتبّع المسار على GPU"
+ },
+ "he": {
+ "render.stage_layout.appearance_note": "לחץ להחלה על הבחירה.",
+ "render.stage_layout.studio_note": "לחץ לסקירה לפני ההחלה.",
+ "render.stage_panels.acknowledge": "ידוע לי על ההחלפה והמגבלות",
+ "render.stage_panels.apply": "החל",
+ "render.stage_panels.captured_bounds": "שימוש בגבולות הסצנה שנלכדו",
+ "render.stage_panels.depth": "עומק",
+ "render.stage_panels.kept": "נשמר",
+ "render.stage_panels.kept_fields": "מצלמה, דגימה, ממדים, קישורים אופטיים, גאומטריית CAD ותכונות הנדסיות.",
+ "render.stage_panels.mine": "שלי",
+ "render.stage_panels.mine_pending": "שמירת אולפנים אישיים עדיין אינה נתמכת.",
+ "render.stage_panels.omits": "מושמט",
+ "render.stage_panels.partial_reference": "מועמדים: ערכים מתועדי מקור בלבד; יש לסקור את הדרגה, המצב והמקורות. ערכים לא ידועים נשארים לא ידועים.",
+ "render.stage_panels.plane": "מישור",
+ "render.stage_panels.projects": "מקרין",
+ "render.stage_panels.reference": "ייחוס",
+ "render.stage_panels.references": "ייחוסים",
+ "render.stage_panels.remove_optics_help": "מסיר את האופטיקה השמורה מצילום זה. גאומטריית המקור נשמרת.",
+ "render.stage_panels.remove_optics_title": "להסיר את האופטיקה השמורה?",
+ "render.stage_panels.remove_stage_help": "מסיר את הלוחות הסבילים השמורים מצילום זה. רקע המצלמה נשאר.",
+ "render.stage_panels.remove_stage_title": "להסיר את הבמה השמורה?",
+ "render.stage_panels.repeat": "חזרה",
+ "render.stage_panels.replaces": "מוחלף",
+ "render.stage_panels.replaces_environment": "סביבה",
+ "render.stage_panels.replaces_maps": "מפות זמניות על הגוף שנבחר; ייתכן קונפליקט עם האופטיקה השמורה.",
+ "render.stage_panels.replaces_physical": "דבר אינו מוחלף. תוכנית זו היא לקריאה בלבד.",
+ "render.stage_panels.replaces_quality": "ממדי תמונה, מספר דגימות קבוע, עומק נתיב, זרע אקראי והפחתת רעש.",
+ "render.stage_panels.replaces_rig": "תאורה, סביבה ובמה",
+ "render.stage_panels.replaces_saved_maps": "מפות משטח שמורות על הגוף שנבחר; ייתכן קונפליקט עם עקיפות זמניות.",
+ "render.stage_panels.replaces_stage": "קרקע ולוחות במה סבילים שנשמרו",
+ "render.stage_panels.replaces_studio": "תאורה, סביבה, חשיפה ובמה",
+ "render.stage_panels.replaces_uniform": "המראה האטום של הגוף שנבחר. מפות מרחביות מקורבות באמצעות ערכים אחידים.",
+ "render.stage_panels.review_environment": "סקירת הסביבה",
+ "render.stage_panels.review_maps": "סקירת מפות GPU",
+ "render.stage_panels.review_physical": "תוכנית ייחוס פיזיקלי",
+ "render.stage_panels.review_quality": "שימוש בתקציב דגימה קבוע",
+ "render.stage_panels.review_rig": "התאמת מערך התאורה",
+ "render.stage_panels.review_saved_maps": "סקירת מפות שמורות",
+ "render.stage_panels.review_stage": "סקירת הקרקע והבמה",
+ "render.stage_panels.review_studio": "סקירת אולפן מובנה",
+ "render.stage_panels.review_uniform": "סקירת מראה אחיד",
+ "render.stage_panels.scope": "היקף",
+ "render.stage_panels.search_studios": "חיפוש אולפנים",
+ "render.stage_panels.search_surfaces": "חיפוש משטחים וייחוסים",
+ "render.stage_panels.specifications": "מפרטים · לקריאה בלבד",
+ "render.stage_panels.studio_note": "לחץ לסקירה. ההחלה מחליפה את התאורה, הסביבה והבמה רק לאחר אישורך. מקורות האור נשארים ניתנים לעריכה.",
+ "render.stage_panels.studios": "אולפנים",
+ "render.stage_panels.subtitle_environment": "סביבת HDR מקורית · הסצנה כולה",
+ "render.stage_panels.subtitle_maps": "מפות מרחביות מעוצבות · תצוגה מקדימה זמנית",
+ "render.stage_panels.subtitle_physical": "תוכנית לקריאה בלבד · לא נוצר או משויך חומר",
+ "render.stage_panels.subtitle_quality": "תקציב GPU קבוע · דרישות עתידיות מושמטות",
+ "render.stage_panels.subtitle_rig": "מערך תאורה מעוצב · פולטי אור וכרטיסים סבילים",
+ "render.stage_panels.subtitle_saved_maps": "מפות מעוצבות · נשמרות עם צילום זה",
+ "render.stage_panels.subtitle_stage": "קרקע ובמה פיזיות · מותאמות למוצר",
+ "render.stage_panels.subtitle_studio": "אולפן מובנה · חל על הסצנה כולה",
+ "render.stage_panels.subtitle_uniform": "קירוב אחיד · אינו חומר שנמדד",
+ "render.stage_panels.surfaces_references": "משטחים וייחוסים",
+ "render.stage_panels.target": "יעד",
+ "render.stage_panels.use_maps": "שימוש במפות GPU",
+ "render.stage_panels.use_uniform": "שימוש במראה אחיד",
+ "render.stage_panels.kept_quality": "שיטה, מצלמה, תאורה, סביבה, במה, אופטיקה, חשיפה ומיפוי גוונים.",
+ "render.stage_panels.paint_pending": "צביעה ושיוך בגרירה עדיין אינם נתמכים. בחר יעד להחלת מראה.",
+ "render.stage_panels.quality_omissions": "עצירה מסתגלת ויעדי שגיאה, עומק העברה נפרד, כללי רולטה רוסית, פלט ליניארי גולמי, קובץ מקור EXR ואישור התכנסות.",
+ "render.stage_panels.appearance_note": "לחץ להחלה על הבחירה. גרור אל המודל. כשדבר אינו נבחר, לחיצה מכינה את כלי הצביעה לשימוש.",
+ "render.stage_panels.badge_native": "מובנה",
+ "render.stage_panels.badge_projection": "היטל",
+ "render.stage_panels.badge_reference": "ייחוס",
+ "render.stage_panels.badge_specification": "מפרט בלבד",
+ "render.stage_panels.badge_blocked": "חסום",
+ "render.stage_panels.rig_summary": "מערך תאורה מעוצב · {emitters} פולטי אור, {cards} כרטיסים",
+ "render.stage_panels.candidate_summary": "מועמדים: {count} ערכים מתועדי מקור. הדרגה והגימור דורשים סקירה.",
+ "render.stage_panels.apply_studio": "החלת אולפן",
+ "render.stage_panels.centre": "מרכז",
+ "render.stage_panels.extent": "ממדי התחום",
+ "render.stage_panels.fit_save": "התאמה ושמירה",
+ "render.stage_panels.use_budget": "שימוש בתקציב זה",
+ "render.stage_panels.quality_ack": "ידוע לי על התקציב הקבוע והפרטים המושמטים בו",
+ "render.stage_panels.studio_ack": "אישור החלפת התאורה, הסביבה, החשיפה והבמה",
+ "render.stage_panels.keep": "שמור",
+ "render.stage_panels.remove_stage": "הסרת הבמה",
+ "render.stage_panels.remove_optics": "הסרת האופטיקה",
+ "render.stage_panels.remove_shot": "הסרת הצילום",
+ "render.stage_panels.rigs": "מערכי תאורה",
+ "render.stage_panels.environments": "סביבות",
+ "render.stage_panels.surfaces": "משטחים",
+ "render.stage_panels.prepare_plan": "הכנת תוכנית יצירה",
+ "render.stage_panels.save_maps": "שמירת מפות בצילום זה",
+ "render.stage_panels.source_note": "מפת מקור מעוצבת לצבע בסיס. אינה חומר שנמדד.",
+ "render.stage_panels.gpu_required": "נדרש מעקב נתיב ב-GPU"
+ },
+ "vi": {
+ "render.stage_layout.appearance_note": "Bấm để áp dụng cho vùng chọn.",
+ "render.stage_layout.studio_note": "Bấm để xem xét trước khi áp dụng.",
+ "render.stage_panels.acknowledge": "Tôi xác nhận việc thay thế và các giới hạn",
+ "render.stage_panels.apply": "Áp dụng",
+ "render.stage_panels.captured_bounds": "Sử dụng ranh giới cảnh đã ghi nhận",
+ "render.stage_panels.depth": "độ sâu",
+ "render.stage_panels.kept": "Được giữ lại",
+ "render.stage_panels.kept_fields": "Camera, lấy mẫu, kích thước, liên kết quang học, hình học CAD và đặc tính kỹ thuật.",
+ "render.stage_panels.mine": "Của tôi",
+ "render.stage_panels.mine_pending": "Chưa hỗ trợ lưu studio cá nhân.",
+ "render.stage_panels.omits": "Lược bỏ",
+ "render.stage_panels.partial_reference": "Ứng viên: chỉ gồm các giá trị có nguồn; hãy xem xét mác vật liệu, điều kiện và nguồn. Giá trị chưa rõ vẫn được giữ là chưa rõ.",
+ "render.stage_panels.plane": "Mặt phẳng",
+ "render.stage_panels.projects": "Chiếu",
+ "render.stage_panels.reference": "Tham chiếu",
+ "render.stage_panels.references": "Các tham chiếu",
+ "render.stage_panels.remove_optics_help": "Xóa cài đặt quang học đã lưu khỏi khung hình này. Hình học nguồn được giữ lại.",
+ "render.stage_panels.remove_optics_title": "Xóa cài đặt quang học đã lưu?",
+ "render.stage_panels.remove_stage_help": "Xóa các tấm thụ động đã lưu khỏi khung hình này. Phông nền camera được giữ lại.",
+ "render.stage_panels.remove_stage_title": "Xóa sân khấu đã lưu?",
+ "render.stage_panels.repeat": "Lặp lại",
+ "render.stage_panels.replaces": "Thay thế",
+ "render.stage_panels.replaces_environment": "Môi trường",
+ "render.stage_panels.replaces_maps": "Các bản đồ tạm thời trên khối được chọn; có thể xung đột với cài đặt quang học đã lưu.",
+ "render.stage_panels.replaces_physical": "Không thay thế gì. Kế hoạch này chỉ đọc.",
+ "render.stage_panels.replaces_quality": "Kích thước ảnh, số mẫu cố định, độ sâu đường đi, hạt giống ngẫu nhiên và khử nhiễu.",
+ "render.stage_panels.replaces_rig": "Ánh sáng, môi trường và sân khấu",
+ "render.stage_panels.replaces_saved_maps": "Các bản đồ bề mặt đã lưu trên khối được chọn; có thể xung đột với ghi đè tạm thời.",
+ "render.stage_panels.replaces_stage": "Mặt sàn và các tấm sân khấu thụ động đã lưu",
+ "render.stage_panels.replaces_studio": "Ánh sáng, môi trường, phơi sáng và sân khấu",
+ "render.stage_panels.replaces_uniform": "Diện mạo đục trên khối được chọn. Các bản đồ không gian được xấp xỉ bằng giá trị đồng nhất.",
+ "render.stage_panels.review_environment": "Xem xét môi trường",
+ "render.stage_panels.review_maps": "Xem xét bản đồ GPU",
+ "render.stage_panels.review_physical": "Kế hoạch tham chiếu vật lý",
+ "render.stage_panels.review_quality": "Sử dụng ngân sách lấy mẫu cố định",
+ "render.stage_panels.review_rig": "Khớp bộ đèn chiếu sáng",
+ "render.stage_panels.review_saved_maps": "Xem xét bản đồ đã lưu",
+ "render.stage_panels.review_stage": "Xem xét mặt sàn và sân khấu",
+ "render.stage_panels.review_studio": "Xem xét studio gốc",
+ "render.stage_panels.review_uniform": "Xem xét diện mạo đồng nhất",
+ "render.stage_panels.scope": "Phạm vi",
+ "render.stage_panels.search_studios": "Tìm studio",
+ "render.stage_panels.search_surfaces": "Tìm bề mặt và tham chiếu",
+ "render.stage_panels.specifications": "Thông số kỹ thuật · chỉ đọc",
+ "render.stage_panels.studio_note": "Bấm để xem xét. Việc áp dụng chỉ thay thế ánh sáng, môi trường và sân khấu sau khi bạn xác nhận. Các đèn vẫn có thể chỉnh sửa.",
+ "render.stage_panels.studios": "Studio",
+ "render.stage_panels.subtitle_environment": "Môi trường HDR nguyên bản · toàn bộ cảnh",
+ "render.stage_panels.subtitle_maps": "Bản đồ không gian đã tạo · xem trước tạm thời",
+ "render.stage_panels.subtitle_physical": "Kế hoạch chỉ đọc · không tạo hay gán vật liệu",
+ "render.stage_panels.subtitle_quality": "Ngân sách GPU cố định · lược bỏ các yêu cầu tương lai",
+ "render.stage_panels.subtitle_rig": "Bộ đèn chiếu sáng đã thiết kế · bộ phát sáng và tấm thụ động",
+ "render.stage_panels.subtitle_saved_maps": "Bản đồ đã tạo · lưu cùng khung hình này",
+ "render.stage_panels.subtitle_stage": "Mặt sàn và sân khấu vật lý · khớp với sản phẩm",
+ "render.stage_panels.subtitle_studio": "Studio gốc · áp dụng cho toàn bộ cảnh",
+ "render.stage_panels.subtitle_uniform": "Xấp xỉ đồng nhất · không phải vật liệu được đo đạc",
+ "render.stage_panels.surfaces_references": "Bề mặt và tham chiếu",
+ "render.stage_panels.target": "Mục tiêu",
+ "render.stage_panels.use_maps": "Sử dụng bản đồ GPU",
+ "render.stage_panels.use_uniform": "Sử dụng diện mạo đồng nhất",
+ "render.stage_panels.kept_quality": "Phương thức, camera, ánh sáng, môi trường, sân khấu, cài đặt quang học, phơi sáng và ánh xạ sắc điệu.",
+ "render.stage_panels.paint_pending": "Chưa hỗ trợ tô và gán bằng cách kéo. Chọn mục tiêu để áp dụng diện mạo.",
+ "render.stage_panels.quality_omissions": "Dừng thích ứng và mục tiêu sai số, độ sâu truyền dẫn riêng, quy tắc roulette Nga, đầu ra tuyến tính thô, bản gốc EXR và chứng nhận hội tụ.",
+ "render.stage_panels.appearance_note": "Bấm để áp dụng cho vùng chọn. Kéo lên mô hình. Khi không chọn gì, bấm để kích hoạt công cụ Tô.",
+ "render.stage_panels.badge_native": "gốc",
+ "render.stage_panels.badge_projection": "phép chiếu",
+ "render.stage_panels.badge_reference": "tham chiếu",
+ "render.stage_panels.badge_specification": "chỉ thông số",
+ "render.stage_panels.badge_blocked": "bị chặn",
+ "render.stage_panels.rig_summary": "Bộ đèn chiếu sáng đã thiết kế · {emitters} bộ phát sáng, {cards} tấm",
+ "render.stage_panels.candidate_summary": "Ứng viên: {count} giá trị có nguồn. Cần xem xét mác vật liệu và lớp hoàn thiện.",
+ "render.stage_panels.apply_studio": "Áp dụng studio",
+ "render.stage_panels.centre": "Tâm",
+ "render.stage_panels.extent": "Phạm vi",
+ "render.stage_panels.fit_save": "Khớp và lưu",
+ "render.stage_panels.use_budget": "Sử dụng ngân sách này",
+ "render.stage_panels.quality_ack": "Tôi xác nhận ngân sách cố định và các mục bị lược bỏ",
+ "render.stage_panels.studio_ack": "Xác nhận thay thế ánh sáng, môi trường, phơi sáng và sân khấu",
+ "render.stage_panels.keep": "Giữ lại",
+ "render.stage_panels.remove_stage": "Xóa sân khấu",
+ "render.stage_panels.remove_optics": "Xóa cài đặt quang học",
+ "render.stage_panels.remove_shot": "Xóa khung hình",
+ "render.stage_panels.rigs": "Bộ đèn chiếu sáng",
+ "render.stage_panels.environments": "Môi trường",
+ "render.stage_panels.surfaces": "Bề mặt",
+ "render.stage_panels.prepare_plan": "Chuẩn bị kế hoạch tạo",
+ "render.stage_panels.save_maps": "Lưu bản đồ vào khung hình này",
+ "render.stage_panels.source_note": "Bản đồ nguồn màu cơ sở đã tạo. Không phải vật liệu được đo đạc.",
+ "render.stage_panels.gpu_required": "Cần dò đường đi của tia bằng GPU"
+ }
+}
diff --git a/assets/locales/pending/render-stage-layout.json b/assets/locales/pending/render-stage-layout.json
new file mode 100644
index 0000000000..8e5a731302
--- /dev/null
+++ b/assets/locales/pending/render-stage-layout.json
@@ -0,0 +1,22 @@
+{
+ "en": {
+ "render.stage_layout.appearance_note": "Click to apply to the selection.",
+ "render.stage_layout.studio_note": "Click to review before applying."
+ },
+ "de": {
+ "render.stage_layout.appearance_note": "Zum Anwenden auf die Auswahl klicken.",
+ "render.stage_layout.studio_note": "Vor dem Anwenden zur Prüfung klicken."
+ },
+ "ja": {
+ "render.stage_layout.appearance_note": "クリックして選択に適用します。",
+ "render.stage_layout.studio_note": "クリックして適用前に確認します。"
+ },
+ "ko": {
+ "render.stage_layout.appearance_note": "클릭하여 선택 항목에 적용합니다.",
+ "render.stage_layout.studio_note": "클릭하여 적용 전에 검토하세요."
+ },
+ "zh": {
+ "render.stage_layout.appearance_note": "点击应用到所选对象。",
+ "render.stage_layout.studio_note": "点击以在应用前检查。"
+ }
+}
diff --git a/assets/locales/pending/render-stage-panels.json b/assets/locales/pending/render-stage-panels.json
new file mode 100644
index 0000000000..22c958924d
--- /dev/null
+++ b/assets/locales/pending/render-stage-panels.json
@@ -0,0 +1,442 @@
+{
+ "en": {
+ "render.stage_panels.acknowledge": "I acknowledge the replacement and limitations",
+ "render.stage_panels.apply": "Apply",
+ "render.stage_panels.captured_bounds": "Use captured scene bounds",
+ "render.stage_panels.depth": "depth",
+ "render.stage_panels.kept": "Kept",
+ "render.stage_panels.kept_fields": "Camera, sampling, dimensions, optical bindings, CAD geometry and engineering properties.",
+ "render.stage_panels.mine": "Mine",
+ "render.stage_panels.mine_pending": "Saving personal studios is not supported yet.",
+ "render.stage_panels.omits": "Omits",
+ "render.stage_panels.partial_reference": "Candidates: sourced values only; review grade, condition and sources. Unknown values remain unknown.",
+ "render.stage_panels.plane": "Plane",
+ "render.stage_panels.projects": "Projects",
+ "render.stage_panels.reference": "Reference",
+ "render.stage_panels.references": "References",
+ "render.stage_panels.remove_optics_help": "Removes saved optics from this shot. Source geometry is kept.",
+ "render.stage_panels.remove_optics_title": "Remove saved optics?",
+ "render.stage_panels.remove_stage_help": "Removes the saved passive panels from this shot. The camera backdrop stays.",
+ "render.stage_panels.remove_stage_title": "Remove the saved stage?",
+ "render.stage_panels.repeat": "Repeat",
+ "render.stage_panels.replaces": "Replaces",
+ "render.stage_panels.replaces_environment": "Environment",
+ "render.stage_panels.replaces_maps": "Temporary maps on the picked body; saved optics may conflict.",
+ "render.stage_panels.replaces_physical": "Nothing. This plan is read-only.",
+ "render.stage_panels.replaces_quality": "Image dimensions, fixed samples, path depth, seed and denoising.",
+ "render.stage_panels.replaces_rig": "Lighting, environment and stage",
+ "render.stage_panels.replaces_saved_maps": "Saved surface maps on the picked body; temporary overrides may conflict.",
+ "render.stage_panels.replaces_stage": "Saved ground and passive stage panels",
+ "render.stage_panels.replaces_studio": "Lighting, environment, exposure and stage",
+ "render.stage_panels.replaces_uniform": "Opaque appearance on the picked body. Spatial maps are approximated by uniform values.",
+ "render.stage_panels.review_environment": "Review environment",
+ "render.stage_panels.review_maps": "Review GPU maps",
+ "render.stage_panels.review_physical": "Physical reference plan",
+ "render.stage_panels.review_quality": "Use a fixed sampling budget",
+ "render.stage_panels.review_rig": "Fit light rig",
+ "render.stage_panels.review_saved_maps": "Review saved maps",
+ "render.stage_panels.review_stage": "Review ground and stage",
+ "render.stage_panels.review_studio": "Review native studio",
+ "render.stage_panels.review_uniform": "Review uniform appearance",
+ "render.stage_panels.scope": "Scope",
+ "render.stage_panels.search_studios": "Search studios",
+ "render.stage_panels.search_surfaces": "Search surfaces and references",
+ "render.stage_panels.specifications": "Specifications · read-only",
+ "render.stage_panels.studio_note": "Click to review. Applying replaces lighting, environment and stage only after you confirm. Lights stay editable.",
+ "render.stage_panels.studios": "Studios",
+ "render.stage_panels.subtitle_environment": "Original HDR environment · whole scene",
+ "render.stage_panels.subtitle_maps": "Authored spatial maps · temporary preview",
+ "render.stage_panels.subtitle_physical": "Read-only plan · no material created or assigned",
+ "render.stage_panels.subtitle_quality": "Fixed GPU budget · future requirements omitted",
+ "render.stage_panels.subtitle_rig": "Authored light rig · emitters and passive cards",
+ "render.stage_panels.subtitle_saved_maps": "Authored maps · saved with this shot",
+ "render.stage_panels.subtitle_stage": "Physical ground and stage · fitted to the product",
+ "render.stage_panels.subtitle_studio": "Native studio · applies to the whole scene",
+ "render.stage_panels.subtitle_uniform": "Uniform approximation · not a measured material",
+ "render.stage_panels.surfaces_references": "Surfaces and references",
+ "render.stage_panels.target": "Target",
+ "render.stage_panels.use_maps": "Use GPU maps",
+ "render.stage_panels.use_uniform": "Use uniform",
+ "render.stage_panels.kept_quality": "Method, camera, lighting, environment, stage, optics, exposure and tone mapping.",
+ "render.stage_panels.paint_pending": "Paint and drag assignment are not supported yet. Pick a target to apply a look.",
+ "render.stage_panels.quality_omissions": "Adaptive stopping and error targets, separate transmission depth, Russian roulette rules, raw linear output, EXR master and convergence certification.",
+ "render.stage_panels.appearance_note": "Click to apply to the selection. Drag onto the model. With nothing selected, a click arms Paint.",
+ "render.stage_panels.badge_native": "native",
+ "render.stage_panels.badge_projection": "projection",
+ "render.stage_panels.badge_reference": "reference",
+ "render.stage_panels.badge_specification": "spec only",
+ "render.stage_panels.badge_blocked": "blocked",
+ "render.stage_panels.rig_summary": "Authored light rig · {emitters} emitters, {cards} cards",
+ "render.stage_panels.candidate_summary": "Candidates: {count} sourced values. Grade and finish need review.",
+ "render.stage_panels.apply_studio": "Apply studio",
+ "render.stage_panels.centre": "Centre",
+ "render.stage_panels.extent": "Extent",
+ "render.stage_panels.fit_save": "Fit and save",
+ "render.stage_panels.use_budget": "Use this budget",
+ "render.stage_panels.quality_ack": "I acknowledge the fixed budget and its omissions",
+ "render.stage_panels.studio_ack": "Confirm replacing lighting, environment, exposure and stage",
+ "render.stage_panels.keep": "Keep",
+ "render.stage_panels.remove_stage": "Remove stage",
+ "render.stage_panels.remove_optics": "Remove optics",
+ "render.stage_panels.remove_shot": "Remove shot",
+ "render.stage_panels.rigs": "Rigs",
+ "render.stage_panels.environments": "Environments",
+ "render.stage_panels.surfaces": "Surfaces",
+ "render.stage_panels.prepare_plan": "Prepare creation plan",
+ "render.stage_panels.save_maps": "Save maps to this shot",
+ "render.stage_panels.source_note": "Authored base-colour source map. Not a measured material.",
+ "render.stage_panels.gpu_required": "Needs GPU path tracing"
+ },
+ "de": {
+ "render.stage_panels.acknowledge": "Ich bestätige den Ersatz und die Einschränkungen",
+ "render.stage_panels.apply": "Anwenden",
+ "render.stage_panels.captured_bounds": "Erfasste Szenengrenzen verwenden",
+ "render.stage_panels.depth": "Tiefe",
+ "render.stage_panels.kept": "Beibehalten",
+ "render.stage_panels.kept_fields": "Kamera, Abtastung, Abmessungen, optische Bindungen, CAD-Geometrie und technische Eigenschaften.",
+ "render.stage_panels.mine": "Meine",
+ "render.stage_panels.mine_pending": "Eigene Studios können noch nicht gespeichert werden.",
+ "render.stage_panels.omits": "Ausgelassen",
+ "render.stage_panels.partial_reference": "Kandidaten: nur belegte Werte; Güte, Zustand und Quellen prüfen. Unbekannte Werte bleiben unbekannt.",
+ "render.stage_panels.plane": "Ebene",
+ "render.stage_panels.projects": "Projiziert",
+ "render.stage_panels.reference": "Referenz",
+ "render.stage_panels.references": "Referenzen",
+ "render.stage_panels.remove_optics_help": "Entfernt die gespeicherte Optik aus dieser Aufnahme. Die Quellgeometrie bleibt erhalten.",
+ "render.stage_panels.remove_optics_title": "Gespeicherte Optik entfernen?",
+ "render.stage_panels.remove_stage_help": "Entfernt die gespeicherten passiven Flächen dieser Aufnahme. Der Kamerahintergrund bleibt erhalten.",
+ "render.stage_panels.remove_stage_title": "Gespeicherte Bühne entfernen?",
+ "render.stage_panels.repeat": "Wiederholung",
+ "render.stage_panels.replaces": "Ersetzt",
+ "render.stage_panels.replaces_environment": "Umgebung",
+ "render.stage_panels.replaces_maps": "Temporäre Texturen am gewählten Körper; gespeicherte Optik kann im Konflikt stehen.",
+ "render.stage_panels.replaces_physical": "Nichts. Dieser Plan ist schreibgeschützt.",
+ "render.stage_panels.replaces_quality": "Bildabmessungen, feste Abtastungen, Pfadtiefe, Startwert und Entrauschen.",
+ "render.stage_panels.replaces_rig": "Beleuchtung, Umgebung und Bühne",
+ "render.stage_panels.replaces_saved_maps": "Gespeicherte Oberflächentexturen am gewählten Körper; temporäre Einstellungen können kollidieren.",
+ "render.stage_panels.replaces_stage": "Gespeicherter Boden und passive Bühnenflächen",
+ "render.stage_panels.replaces_studio": "Beleuchtung, Umgebung, Belichtung und Bühne",
+ "render.stage_panels.replaces_uniform": "Deckendes Aussehen des gewählten Körpers. Räumliche Texturen werden durch einheitliche Werte angenähert.",
+ "render.stage_panels.review_environment": "Umgebung prüfen",
+ "render.stage_panels.review_maps": "GPU-Texturen prüfen",
+ "render.stage_panels.review_physical": "Physikalischer Referenzplan",
+ "render.stage_panels.review_quality": "Festes Abtastbudget verwenden",
+ "render.stage_panels.review_rig": "Lichtaufbau einpassen",
+ "render.stage_panels.review_saved_maps": "Gespeicherte Texturen prüfen",
+ "render.stage_panels.review_stage": "Boden und Bühne prüfen",
+ "render.stage_panels.review_studio": "Natives Studio prüfen",
+ "render.stage_panels.review_uniform": "Einheitliches Aussehen prüfen",
+ "render.stage_panels.scope": "Bereich",
+ "render.stage_panels.search_studios": "Studios suchen",
+ "render.stage_panels.search_surfaces": "Oberflächen und Referenzen suchen",
+ "render.stage_panels.specifications": "Spezifikationen · schreibgeschützt",
+ "render.stage_panels.studio_note": "Zum Prüfen anklicken. Beleuchtung, Umgebung und Bühne werden erst nach Bestätigung ersetzt. Lichter bleiben bearbeitbar.",
+ "render.stage_panels.studios": "Studios",
+ "render.stage_panels.subtitle_environment": "Originale HDR-Umgebung · gesamte Szene",
+ "render.stage_panels.subtitle_maps": "Erstellte räumliche Texturen · temporäre Vorschau",
+ "render.stage_panels.subtitle_physical": "Schreibgeschützter Plan · kein Material erstellt oder zugewiesen",
+ "render.stage_panels.subtitle_quality": "Festes GPU-Budget · zukünftige Anforderungen ausgelassen",
+ "render.stage_panels.subtitle_rig": "Erstellter Lichtaufbau · Lichtquellen und passive Flächen",
+ "render.stage_panels.subtitle_saved_maps": "Erstellte Texturen · mit dieser Aufnahme gespeichert",
+ "render.stage_panels.subtitle_stage": "Physischer Boden und Bühne · an das Produkt angepasst",
+ "render.stage_panels.subtitle_studio": "Natives Studio · für die gesamte Szene",
+ "render.stage_panels.subtitle_uniform": "Einheitliche Näherung · kein gemessenes Material",
+ "render.stage_panels.surfaces_references": "Oberflächen und Referenzen",
+ "render.stage_panels.target": "Ziel",
+ "render.stage_panels.use_maps": "GPU-Texturen verwenden",
+ "render.stage_panels.use_uniform": "Einheitlich verwenden",
+ "render.stage_panels.kept_quality": "Methode, Kamera, Beleuchtung, Umgebung, Bühne, Optik, Belichtung und Tonwertabbildung.",
+ "render.stage_panels.paint_pending": "Malen und Zuweisen per Ziehen werden noch nicht unterstützt. Zum Anwenden ein Ziel wählen.",
+ "render.stage_panels.quality_omissions": "Adaptives Stoppen und Fehlerziele, separate Transmissionstiefe, Russian-Roulette-Regeln, lineare Rohausgabe, EXR-Master und Konvergenznachweis.",
+ "render.stage_panels.appearance_note": "Zum Anwenden auf die Auswahl klicken. Auf das Modell ziehen. Ohne Auswahl aktiviert ein Klick Malen.",
+ "render.stage_panels.badge_native": "nativ",
+ "render.stage_panels.badge_projection": "Projektion",
+ "render.stage_panels.badge_reference": "Referenz",
+ "render.stage_panels.badge_specification": "nur Spez.",
+ "render.stage_panels.badge_blocked": "gesperrt",
+ "render.stage_panels.rig_summary": "Erstellter Lichtaufbau · {emitters} Lichtquellen, {cards} passive Flächen",
+ "render.stage_panels.candidate_summary": "Kandidaten: {count} belegte Werte. Güte und Oberfläche müssen geprüft werden.",
+ "render.stage_panels.apply_studio": "Studio anwenden",
+ "render.stage_panels.centre": "Mitte",
+ "render.stage_panels.extent": "Ausdehnung",
+ "render.stage_panels.fit_save": "Einpassen und speichern",
+ "render.stage_panels.use_budget": "Dieses Budget verwenden",
+ "render.stage_panels.quality_ack": "Ich bestätige das feste Budget und seine Auslassungen",
+ "render.stage_panels.studio_ack": "Ersatz von Beleuchtung, Umgebung, Belichtung und Bühne bestätigen",
+ "render.stage_panels.keep": "Behalten",
+ "render.stage_panels.remove_stage": "Bühne entfernen",
+ "render.stage_panels.remove_optics": "Optik entfernen",
+ "render.stage_panels.remove_shot": "Aufnahme entfernen",
+ "render.stage_panels.rigs": "Lichtaufbauten",
+ "render.stage_panels.environments": "Umgebungen",
+ "render.stage_panels.surfaces": "Oberflächen",
+ "render.stage_panels.prepare_plan": "Erstellungsplan vorbereiten",
+ "render.stage_panels.save_maps": "Texturen in dieser Aufnahme speichern",
+ "render.stage_panels.source_note": "Erstellte Grundfarbentextur. Kein gemessenes Material.",
+ "render.stage_panels.gpu_required": "Benötigt GPU-Pfadverfolgung"
+ },
+ "ja": {
+ "render.stage_panels.acknowledge": "置換と制限事項を確認しました",
+ "render.stage_panels.apply": "適用",
+ "render.stage_panels.captured_bounds": "取得したシーン境界を使用",
+ "render.stage_panels.depth": "深度",
+ "render.stage_panels.kept": "保持",
+ "render.stage_panels.kept_fields": "カメラ、サンプリング、画像寸法、光学設定、CAD形状、工学的特性。",
+ "render.stage_panels.mine": "自分の項目",
+ "render.stage_panels.mine_pending": "個人用スタジオの保存は未対応です。",
+ "render.stage_panels.omits": "省略",
+ "render.stage_panels.partial_reference": "候補:出典のある値のみ。等級、状態、出典を確認してください。不明な値は不明のままです。",
+ "render.stage_panels.plane": "平面",
+ "render.stage_panels.projects": "投影",
+ "render.stage_panels.reference": "参照",
+ "render.stage_panels.references": "参照",
+ "render.stage_panels.remove_optics_help": "このショットの保存済み光学設定を削除します。元の形状は保持されます。",
+ "render.stage_panels.remove_optics_title": "保存済み光学設定を削除しますか?",
+ "render.stage_panels.remove_stage_help": "このショットの保存済み受動パネルを削除します。カメラ背景は保持されます。",
+ "render.stage_panels.remove_stage_title": "保存済みステージを削除しますか?",
+ "render.stage_panels.repeat": "繰り返し",
+ "render.stage_panels.replaces": "置換",
+ "render.stage_panels.replaces_environment": "環境",
+ "render.stage_panels.replaces_maps": "選択したボディの一時マップ。保存済み光学設定と競合する場合があります。",
+ "render.stage_panels.replaces_physical": "なし。この計画は読み取り専用です。",
+ "render.stage_panels.replaces_quality": "画像寸法、固定サンプル数、パス深度、シード、ノイズ除去。",
+ "render.stage_panels.replaces_rig": "照明、環境、ステージ",
+ "render.stage_panels.replaces_saved_maps": "選択したボディの保存済み表面マップ。一時設定と競合する場合があります。",
+ "render.stage_panels.replaces_stage": "保存済みの地面と受動ステージパネル",
+ "render.stage_panels.replaces_studio": "照明、環境、露出、ステージ",
+ "render.stage_panels.replaces_uniform": "選択したボディの不透明な外観。空間マップを均一な値で近似します。",
+ "render.stage_panels.review_environment": "環境を確認",
+ "render.stage_panels.review_maps": "GPUマップを確認",
+ "render.stage_panels.review_physical": "物理参照計画",
+ "render.stage_panels.review_quality": "固定サンプリング予算を使用",
+ "render.stage_panels.review_rig": "ライトリグをフィット",
+ "render.stage_panels.review_saved_maps": "保存マップを確認",
+ "render.stage_panels.review_stage": "地面とステージを確認",
+ "render.stage_panels.review_studio": "ネイティブスタジオを確認",
+ "render.stage_panels.review_uniform": "均一な外観を確認",
+ "render.stage_panels.scope": "範囲",
+ "render.stage_panels.search_studios": "スタジオを検索",
+ "render.stage_panels.search_surfaces": "サーフェスと参照を検索",
+ "render.stage_panels.specifications": "仕様・読み取り専用",
+ "render.stage_panels.studio_note": "クリックして確認。適用時は確認後に照明、環境、ステージを置換します。ライトは編集可能なままです。",
+ "render.stage_panels.studios": "スタジオ",
+ "render.stage_panels.subtitle_environment": "オリジナルHDR環境・シーン全体",
+ "render.stage_panels.subtitle_maps": "作成済み空間マップ・一時プレビュー",
+ "render.stage_panels.subtitle_physical": "読み取り専用計画・マテリアルの作成や割り当てなし",
+ "render.stage_panels.subtitle_quality": "固定GPU予算・将来の要件は省略",
+ "render.stage_panels.subtitle_rig": "作成済みライトリグ・光源と受動カード",
+ "render.stage_panels.subtitle_saved_maps": "作成済みマップ・このショットに保存",
+ "render.stage_panels.subtitle_stage": "物理的な地面とステージ・製品にフィット",
+ "render.stage_panels.subtitle_studio": "ネイティブスタジオ・シーン全体に適用",
+ "render.stage_panels.subtitle_uniform": "均一な近似・測定済みマテリアルではありません",
+ "render.stage_panels.surfaces_references": "サーフェスと参照",
+ "render.stage_panels.target": "対象",
+ "render.stage_panels.use_maps": "GPUマップを使用",
+ "render.stage_panels.use_uniform": "均一な外観を使用",
+ "render.stage_panels.kept_quality": "方式、カメラ、照明、環境、ステージ、光学設定、露出、トーンマッピング。",
+ "render.stage_panels.paint_pending": "ペイントとドラッグによる割り当ては未対応です。対象を選択して外観を適用してください。",
+ "render.stage_panels.quality_omissions": "適応停止と誤差目標、個別の透過深度、ロシアンルーレット規則、線形RAW出力、EXRマスター、収束認証。",
+ "render.stage_panels.appearance_note": "クリックして選択対象に適用。モデルへドラッグ。未選択時はクリックでペイントを開始します。",
+ "render.stage_panels.badge_native": "ネイティブ",
+ "render.stage_panels.badge_projection": "投影",
+ "render.stage_panels.badge_reference": "参照",
+ "render.stage_panels.badge_specification": "仕様のみ",
+ "render.stage_panels.badge_blocked": "使用不可",
+ "render.stage_panels.rig_summary": "作成済みライトリグ・光源 {emitters} 個、カード {cards} 枚",
+ "render.stage_panels.candidate_summary": "候補:出典のある値 {count} 件。等級と仕上げは確認が必要です。",
+ "render.stage_panels.apply_studio": "スタジオを適用",
+ "render.stage_panels.centre": "中心",
+ "render.stage_panels.extent": "範囲",
+ "render.stage_panels.fit_save": "フィットして保存",
+ "render.stage_panels.use_budget": "この予算を使用",
+ "render.stage_panels.quality_ack": "固定予算と省略事項を確認しました",
+ "render.stage_panels.studio_ack": "照明、環境、露出、ステージの置換を確認",
+ "render.stage_panels.keep": "保持",
+ "render.stage_panels.remove_stage": "ステージを削除",
+ "render.stage_panels.remove_optics": "光学設定を削除",
+ "render.stage_panels.remove_shot": "ショットを削除",
+ "render.stage_panels.rigs": "リグ",
+ "render.stage_panels.environments": "環境",
+ "render.stage_panels.surfaces": "サーフェス",
+ "render.stage_panels.prepare_plan": "作成計画を準備",
+ "render.stage_panels.save_maps": "このショットにマップを保存",
+ "render.stage_panels.source_note": "作成済みベースカラーマップ。測定済みマテリアルではありません。",
+ "render.stage_panels.gpu_required": "GPUパストレーシングが必要です"
+ },
+ "zh": {
+ "render.stage_panels.acknowledge": "我确认替换内容及限制",
+ "render.stage_panels.apply": "应用",
+ "render.stage_panels.captured_bounds": "使用捕获的场景边界",
+ "render.stage_panels.depth": "深度",
+ "render.stage_panels.kept": "保留",
+ "render.stage_panels.kept_fields": "相机、采样、图像尺寸、光学绑定、CAD 几何体和工程属性。",
+ "render.stage_panels.mine": "我的",
+ "render.stage_panels.mine_pending": "暂不支持保存个人工作室。",
+ "render.stage_panels.omits": "省略",
+ "render.stage_panels.partial_reference": "候选:仅含有来源的数据;请审核等级、状态和来源。未知值仍保持未知。",
+ "render.stage_panels.plane": "平面",
+ "render.stage_panels.projects": "投影",
+ "render.stage_panels.reference": "参考",
+ "render.stage_panels.references": "参考",
+ "render.stage_panels.remove_optics_help": "从此镜头中移除保存的光学设置。源几何体将保留。",
+ "render.stage_panels.remove_optics_title": "移除保存的光学设置?",
+ "render.stage_panels.remove_stage_help": "移除此镜头中保存的被动面板。相机背景保留。",
+ "render.stage_panels.remove_stage_title": "移除保存的舞台?",
+ "render.stage_panels.repeat": "重复",
+ "render.stage_panels.replaces": "替换",
+ "render.stage_panels.replaces_environment": "环境",
+ "render.stage_panels.replaces_maps": "选中实体上的临时贴图;可能与保存的光学设置冲突。",
+ "render.stage_panels.replaces_physical": "无。此计划为只读。",
+ "render.stage_panels.replaces_quality": "图像尺寸、固定采样数、路径深度、种子和降噪。",
+ "render.stage_panels.replaces_rig": "灯光、环境和舞台",
+ "render.stage_panels.replaces_saved_maps": "选中实体上保存的表面贴图;可能与临时覆盖冲突。",
+ "render.stage_panels.replaces_stage": "保存的地面和被动舞台面板",
+ "render.stage_panels.replaces_studio": "灯光、环境、曝光和舞台",
+ "render.stage_panels.replaces_uniform": "选中实体的不透明外观。空间贴图以均匀值近似。",
+ "render.stage_panels.review_environment": "审核环境",
+ "render.stage_panels.review_maps": "审核 GPU 贴图",
+ "render.stage_panels.review_physical": "物理参考计划",
+ "render.stage_panels.review_quality": "使用固定采样预算",
+ "render.stage_panels.review_rig": "适配灯光装置",
+ "render.stage_panels.review_saved_maps": "审核保存的贴图",
+ "render.stage_panels.review_stage": "审核地面和舞台",
+ "render.stage_panels.review_studio": "审核原生工作室",
+ "render.stage_panels.review_uniform": "审核均匀外观",
+ "render.stage_panels.scope": "范围",
+ "render.stage_panels.search_studios": "搜索工作室",
+ "render.stage_panels.search_surfaces": "搜索表面和参考",
+ "render.stage_panels.specifications": "规格 · 只读",
+ "render.stage_panels.studio_note": "点击审核。确认后才会替换灯光、环境和舞台。灯光仍可编辑。",
+ "render.stage_panels.studios": "工作室",
+ "render.stage_panels.subtitle_environment": "原创 HDR 环境 · 整个场景",
+ "render.stage_panels.subtitle_maps": "创作的空间贴图 · 临时预览",
+ "render.stage_panels.subtitle_physical": "只读计划 · 未创建或分配材料",
+ "render.stage_panels.subtitle_quality": "固定 GPU 预算 · 省略未来要求",
+ "render.stage_panels.subtitle_rig": "创作的灯光装置 · 发光体和被动卡片",
+ "render.stage_panels.subtitle_saved_maps": "创作的贴图 · 保存在此镜头中",
+ "render.stage_panels.subtitle_stage": "物理地面和舞台 · 适配产品",
+ "render.stage_panels.subtitle_studio": "原生工作室 · 应用于整个场景",
+ "render.stage_panels.subtitle_uniform": "均匀近似 · 非测量材料",
+ "render.stage_panels.surfaces_references": "表面和参考",
+ "render.stage_panels.target": "目标",
+ "render.stage_panels.use_maps": "使用 GPU 贴图",
+ "render.stage_panels.use_uniform": "使用均匀外观",
+ "render.stage_panels.kept_quality": "方法、相机、灯光、环境、舞台、光学设置、曝光和色调映射。",
+ "render.stage_panels.paint_pending": "暂不支持绘制和拖动分配。请选择目标以应用外观。",
+ "render.stage_panels.quality_omissions": "自适应停止和误差目标、独立透射深度、俄罗斯轮盘规则、原始线性输出、EXR 母版及收敛认证。",
+ "render.stage_panels.appearance_note": "点击以应用到选中对象。拖到模型上。未选中对象时,点击将启用绘制。",
+ "render.stage_panels.badge_native": "原生",
+ "render.stage_panels.badge_projection": "投影",
+ "render.stage_panels.badge_reference": "参考",
+ "render.stage_panels.badge_specification": "仅规格",
+ "render.stage_panels.badge_blocked": "已阻止",
+ "render.stage_panels.rig_summary": "创作的灯光装置 · {emitters} 个发光体,{cards} 张卡片",
+ "render.stage_panels.candidate_summary": "候选:{count} 个有来源的值。等级和表面处理需要审核。",
+ "render.stage_panels.apply_studio": "应用工作室",
+ "render.stage_panels.centre": "中心",
+ "render.stage_panels.extent": "范围",
+ "render.stage_panels.fit_save": "适配并保存",
+ "render.stage_panels.use_budget": "使用此预算",
+ "render.stage_panels.quality_ack": "我确认此固定预算及其省略内容",
+ "render.stage_panels.studio_ack": "确认替换灯光、环境、曝光和舞台",
+ "render.stage_panels.keep": "保留",
+ "render.stage_panels.remove_stage": "移除舞台",
+ "render.stage_panels.remove_optics": "移除光学设置",
+ "render.stage_panels.remove_shot": "移除镜头",
+ "render.stage_panels.rigs": "灯光装置",
+ "render.stage_panels.environments": "环境",
+ "render.stage_panels.surfaces": "表面",
+ "render.stage_panels.prepare_plan": "准备创建计划",
+ "render.stage_panels.save_maps": "将贴图保存到此镜头",
+ "render.stage_panels.source_note": "创作的基础颜色源贴图。非测量材料。",
+ "render.stage_panels.gpu_required": "需要 GPU 路径追踪"
+ },
+ "ko": {
+ "render.stage_panels.acknowledge": "교체 내용과 제한 사항을 확인했습니다",
+ "render.stage_panels.apply": "적용",
+ "render.stage_panels.captured_bounds": "캡처한 장면 경계 사용",
+ "render.stage_panels.depth": "깊이",
+ "render.stage_panels.kept": "유지",
+ "render.stage_panels.kept_fields": "카메라, 샘플링, 이미지 크기, 광학 바인딩, CAD 형상 및 공학 속성.",
+ "render.stage_panels.mine": "내 항목",
+ "render.stage_panels.mine_pending": "개인 스튜디오 저장은 아직 지원되지 않습니다.",
+ "render.stage_panels.omits": "생략",
+ "render.stage_panels.partial_reference": "후보: 출처가 있는 값만 포함합니다. 등급, 상태 및 출처를 검토하세요. 알 수 없는 값은 그대로 유지됩니다.",
+ "render.stage_panels.plane": "평면",
+ "render.stage_panels.projects": "투영",
+ "render.stage_panels.reference": "참조",
+ "render.stage_panels.references": "참조",
+ "render.stage_panels.remove_optics_help": "이 샷에 저장된 광학 설정을 제거합니다. 원본 형상은 유지됩니다.",
+ "render.stage_panels.remove_optics_title": "저장된 광학 설정을 제거할까요?",
+ "render.stage_panels.remove_stage_help": "이 샷에 저장된 수동 패널을 제거합니다. 카메라 배경은 유지됩니다.",
+ "render.stage_panels.remove_stage_title": "저장된 스테이지를 제거할까요?",
+ "render.stage_panels.repeat": "반복",
+ "render.stage_panels.replaces": "교체",
+ "render.stage_panels.replaces_environment": "환경",
+ "render.stage_panels.replaces_maps": "선택한 바디의 임시 맵. 저장된 광학 설정과 충돌할 수 있습니다.",
+ "render.stage_panels.replaces_physical": "없음. 이 계획은 읽기 전용입니다.",
+ "render.stage_panels.replaces_quality": "이미지 크기, 고정 샘플 수, 경로 깊이, 시드 및 노이즈 제거.",
+ "render.stage_panels.replaces_rig": "조명, 환경 및 스테이지",
+ "render.stage_panels.replaces_saved_maps": "선택한 바디에 저장된 표면 맵. 임시 설정과 충돌할 수 있습니다.",
+ "render.stage_panels.replaces_stage": "저장된 바닥 및 수동 스테이지 패널",
+ "render.stage_panels.replaces_studio": "조명, 환경, 노출 및 스테이지",
+ "render.stage_panels.replaces_uniform": "선택한 바디의 불투명 외관. 공간 맵은 균일한 값으로 근사합니다.",
+ "render.stage_panels.review_environment": "환경 검토",
+ "render.stage_panels.review_maps": "GPU 맵 검토",
+ "render.stage_panels.review_physical": "물리 참조 계획",
+ "render.stage_panels.review_quality": "고정 샘플링 예산 사용",
+ "render.stage_panels.review_rig": "조명 리그 맞춤",
+ "render.stage_panels.review_saved_maps": "저장된 맵 검토",
+ "render.stage_panels.review_stage": "바닥 및 스테이지 검토",
+ "render.stage_panels.review_studio": "네이티브 스튜디오 검토",
+ "render.stage_panels.review_uniform": "균일한 외관 검토",
+ "render.stage_panels.scope": "범위",
+ "render.stage_panels.search_studios": "스튜디오 검색",
+ "render.stage_panels.search_surfaces": "표면 및 참조 검색",
+ "render.stage_panels.specifications": "사양 · 읽기 전용",
+ "render.stage_panels.studio_note": "클릭하여 검토하세요. 확인 후에만 조명, 환경 및 스테이지를 교체합니다. 조명은 계속 편집할 수 있습니다.",
+ "render.stage_panels.studios": "스튜디오",
+ "render.stage_panels.subtitle_environment": "원본 HDR 환경 · 전체 장면",
+ "render.stage_panels.subtitle_maps": "제작된 공간 맵 · 임시 미리 보기",
+ "render.stage_panels.subtitle_physical": "읽기 전용 계획 · 재질 생성 또는 할당 없음",
+ "render.stage_panels.subtitle_quality": "고정 GPU 예산 · 향후 요구 사항 생략",
+ "render.stage_panels.subtitle_rig": "제작된 조명 리그 · 광원 및 수동 카드",
+ "render.stage_panels.subtitle_saved_maps": "제작된 맵 · 이 샷에 저장",
+ "render.stage_panels.subtitle_stage": "물리적 바닥 및 스테이지 · 제품에 맞춤",
+ "render.stage_panels.subtitle_studio": "네이티브 스튜디오 · 전체 장면에 적용",
+ "render.stage_panels.subtitle_uniform": "균일한 근사 · 측정된 재질이 아님",
+ "render.stage_panels.surfaces_references": "표면 및 참조",
+ "render.stage_panels.target": "대상",
+ "render.stage_panels.use_maps": "GPU 맵 사용",
+ "render.stage_panels.use_uniform": "균일한 외관 사용",
+ "render.stage_panels.kept_quality": "방식, 카메라, 조명, 환경, 스테이지, 광학 설정, 노출 및 톤 매핑.",
+ "render.stage_panels.paint_pending": "페인트 및 끌어서 할당은 아직 지원되지 않습니다. 외관을 적용할 대상을 선택하세요.",
+ "render.stage_panels.quality_omissions": "적응형 중지 및 오차 목표, 별도 투과 깊이, 러시안 룰렛 규칙, 원시 선형 출력, EXR 마스터 및 수렴 인증.",
+ "render.stage_panels.appearance_note": "클릭하여 선택 항목에 적용합니다. 모델로 끌어 놓으세요. 선택 항목이 없으면 클릭하여 페인트를 시작합니다.",
+ "render.stage_panels.badge_native": "네이티브",
+ "render.stage_panels.badge_projection": "투영",
+ "render.stage_panels.badge_reference": "참조",
+ "render.stage_panels.badge_specification": "사양만",
+ "render.stage_panels.badge_blocked": "차단됨",
+ "render.stage_panels.rig_summary": "제작된 조명 리그 · 광원 {emitters}개, 카드 {cards}개",
+ "render.stage_panels.candidate_summary": "후보: 출처가 있는 값 {count}개. 등급과 마감 검토가 필요합니다.",
+ "render.stage_panels.apply_studio": "스튜디오 적용",
+ "render.stage_panels.centre": "중심",
+ "render.stage_panels.extent": "크기",
+ "render.stage_panels.fit_save": "맞춤 및 저장",
+ "render.stage_panels.use_budget": "이 예산 사용",
+ "render.stage_panels.quality_ack": "고정 예산과 생략 사항을 확인했습니다",
+ "render.stage_panels.studio_ack": "조명, 환경, 노출 및 스테이지 교체 확인",
+ "render.stage_panels.keep": "유지",
+ "render.stage_panels.remove_stage": "스테이지 제거",
+ "render.stage_panels.remove_optics": "광학 설정 제거",
+ "render.stage_panels.remove_shot": "샷 제거",
+ "render.stage_panels.rigs": "리그",
+ "render.stage_panels.environments": "환경",
+ "render.stage_panels.surfaces": "표면",
+ "render.stage_panels.prepare_plan": "생성 계획 준비",
+ "render.stage_panels.save_maps": "이 샷에 맵 저장",
+ "render.stage_panels.source_note": "제작된 기본 색상 소스 맵. 측정된 재질이 아닙니다.",
+ "render.stage_panels.gpu_required": "GPU 경로 추적 필요"
+ }
+}
diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs
index 5e8cf58c20..be7aa7628b 100644
--- a/crates/ui-egui/src/render_workspace.rs
+++ b/crates/ui-egui/src/render_workspace.rs
@@ -655,6 +655,15 @@ pub fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
inspector::panel(app, ui);
}
+/// Interactive stage-panel review. Direct engine JSON calls remain dialog-free.
+/// S5 supplies its selected specification id without owning another consent form.
+pub(crate) fn review_resource(app: &mut SolveApp, command: &str, id: &str) -> Result<(), String> {
+ match command {
+ "render.quality.prepare" => library::review::quality(app, id),
+ _ => Err("this command has no stage-panel review adapter".into()),
+ }
+}
+
pub(crate) fn apply_browser_controls(app: &mut SolveApp, value: &serde_json::Value) {
let view = &mut app.render_workspace.view;
if let Some(by_look) = value.get("by_look").and_then(serde_json::Value::as_bool) {
diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs
index d5620a1224..c8635bcea9 100644
--- a/crates/ui-egui/src/render_workspace_inspector.rs
+++ b/crates/ui-egui/src/render_workspace_inspector.rs
@@ -92,16 +92,11 @@ pub(super) struct View {
reveal: Option<&'static str>,
pending: Option<Pending>,
shot_name: String,
- scene_review: Option<Review>,
- scene_consent: bool,
- quality_review: Option<Value>,
- quality_ack: bool,
pub checked: Option<Review>,
scene_info: Option<Review>,
ground_margin: f64,
ground_gap: f64,
ground_color: [f64; 3],
- replace_ground: bool,
appearance: Appearance,
selection_appearance: selection_appearance::View,
pub(super) resolution: Resolution,
@@ -183,14 +178,6 @@ impl Review {
self.revision == app.session.revision && Weak::ptr_eq(&self.document, &Arc::downgrade(&app.session.doc))
}
}
-impl View {
- pub(super) fn clear_resource_reviews(&mut self) {
- self.scene_review = None;
- self.scene_consent = false;
- self.quality_review = None;
- self.quality_ack = false;
- }
-}
impl Default for View {
fn default() -> Self {
Self {
@@ -200,16 +187,11 @@ impl Default for View {
reveal: None,
pending: None,
shot_name: String::new(),
- scene_review: None,
- scene_consent: false,
- quality_review: None,
- quality_ack: false,
checked: None,
scene_info: None,
ground_margin: 1.0,
ground_gap: 0.1,
ground_color: [0.18; 3],
- replace_ground: false,
appearance: Appearance::default(),
selection_appearance: Default::default(),
resolution: Resolution::default(),
@@ -348,6 +330,8 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
crate::scenario::publish_rect("render:inspector", rect);
}
confirmation(app, ui.ctx());
+ library::review::dialog(app, ui.ctx());
+ library::review::confirmation(app, ui.ctx());
}
fn header(app: &mut SolveApp, ui: &mut egui::Ui) {
let current = app.render_workspace.view.name.clone();
@@ -448,8 +432,8 @@ fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
}
let removing = matches!(&pending.action, PendingAction::Remove(_));
let title = app.tr(if removing { "render.shot_remove_title" } else { "render.draft_confirm_title" }).to_string();
- let keep = app.tr("render.keep_editing").to_string();
- let primary = app.tr(if removing { "render.shot_remove" } else { "render.save_continue" }).to_string();
+ let keep = app.tr(if removing { "render.stage_panels.keep" } else { "render.keep_editing" }).to_string();
+ let primary = app.tr(if removing { "render.stage_panels.remove_shot" } else { "render.save_continue" }).to_string();
let discard = app.tr("render.discard_continue").to_string();
let message = app.tr(if removing { "render.shot_remove_help" } else { "render.draft_confirm_help" }).to_string();
let (closed, answer) = ui_kit::Confirm::new(egui::Id::new("render_pending_shot"), if removing { "delete" } else { "save" }, &title)
@@ -484,21 +468,9 @@ fn browse_button(app: &mut SolveApp, ui: &mut egui::Ui, kind: &str, key: &str) {
}
}
fn scene_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
- // After a library selection, primary native-resource actions lead the page.
- // Shared method/help and catalog navigation remain below, not between the
- // chosen resource and its explicit review/consent. No state is changed by layout.
- let selected_native = library::selected_kind(app, "native_scenes");
- if selected_native {
- library::inspect_kinds(app, ui, &["native_scenes"]);
- }
ui_kit::text(ui, app.tr("render.scene_preserves_design"), ui_kit::Text::Note("render.scene_preserves_design"));
- super::method_selector(app, ui);
- gpu_status(app, ui);
browse_button(app, ui, "native_scenes", "render.browse_native_scenes");
browse_button(app, ui, "scenes", "render.browse_scene_specs");
- if !selected_native {
- library::inspect_kinds(app, ui, &["native_scenes", "scenes", "selene_shots"]);
- }
physical_stage_controls(app, ui);
shot_controls(app, ui);
}
@@ -512,9 +484,6 @@ fn physical_stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
ui_kit::number_field(ui, &mut app.render_workspace.view.inspector.ground_gap, 0.0001..=1000.0, 0.01, " mm");
let label = app.tr("render.ground_linear_rgb").to_string();
vector(ui, &label, &mut app.render_workspace.view.inspector.ground_color, 0.0..=1.0, 0.01);
- let label = app.tr("render.replace_ground").to_string();
- let replace = ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.inspector.replace_ground);
- crate::scenario::publish_target("render:stage-replace-consent", replace.rect);
let saved = setups::snapshot(app);
if ui_kit::button(
ui,
@@ -525,11 +494,8 @@ fn physical_stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
&& let Ok(set) = saved
{
let v = &app.render_workspace.view.inspector;
- let request = json!({"name":app.render_workspace.view.name,"set":set,"margin_fraction":v.ground_margin,"gap_mm":v.ground_gap,"reflectance_linear":v.ground_color,"replace_stage":v.replace_ground});
- match app.run("render.stage.ground", request) {
- Ok(_) => setups::load(app),
- Err(e) => app.set_status(e, true),
- }
+ let request = json!({"name":app.render_workspace.view.name,"set":set,"margin_fraction":v.ground_margin,"gap_mm":v.ground_gap,"reflectance_linear":v.ground_color,"replace_stage":true});
+ library::review::command(app, "render.stage.ground", request);
}
ui_kit::text(ui, app.tr("render.physical_background_help"), ui_kit::Text::Note("render.physical_background_help"));
for (kind, key) in [("floor_wall", "render.physical_floor_wall"), ("cyclorama", "render.physical_cyclorama")] {
@@ -542,11 +508,8 @@ fn physical_stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
{
let v = &app.render_workspace.view.inspector;
let p = json!({"name":app.render_workspace.view.name,"set":set,"kind":kind,"expected_revision":app.session.revision,
- "replace_stage":v.replace_ground,"reflectance_linear":v.ground_color});
- match app.run("render.stage.backdrop", p) {
- Ok(_) => setups::load(app),
- Err(error) => app.set_status(error, true),
- }
+ "replace_stage":true,"reflectance_linear":v.ground_color});
+ library::review::command(app, "render.stage.backdrop", p);
}
}
library::stage_content(app, ui);
@@ -629,6 +592,7 @@ fn appearance_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
if selection_appearance::controls(app, ui) {
return;
}
+ library::inspect_appearance(app, ui);
ui_kit::text(ui, app.tr("render.appearance_physics_separate"), ui_kit::Text::Note("render.appearance_physics_separate"));
base_appearance(app, ui);
materials::controls(app, ui);
@@ -644,7 +608,7 @@ fn advanced_appearance_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
}
fn lighting_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
browse_button(app, ui, "rigs", "render.browse_rigs");
- library::inspect_kinds(app, ui, &["rigs", "lighting"]);
+
match app.render_workspace.view.method {
ImageMethod::GpuRaytrace => studio::lighting_controls(app, ui),
ImageMethod::CpuRaytrace => {
@@ -667,7 +631,7 @@ fn environment_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
studio::backdrop_controls(app, ui);
}
browse_button(app, ui, "hdr", "render.browse_environments");
- library::inspect_kinds(app, ui, &["hdr", "environments"]);
+
match app.render_workspace.view.method {
ImageMethod::GpuRaytrace => studio::environment_controls(app, ui),
ImageMethod::CpuRaytrace => cpu::environment_controls(app, ui),
@@ -1063,91 +1027,25 @@ fn output_check(app: &SolveApp, ui: &mut egui::Ui) {
}
pub(super) fn scene_resource(app: &mut SolveApp, ui: &mut egui::Ui, id: &str) {
- let snapshot = setups::snapshot(app);
- let resolve = ui_kit::button(
- ui,
- app.tr("render.scene_review"),
- ui_kit::Button::Enabled(snapshot.is_ok() && app.render_workspace.view.method == ImageMethod::GpuRaytrace),
- );
- crate::scenario::publish_target("render:scene-resolve", resolve.rect);
- if resolve.clicked()
- && let Ok(set) = snapshot
+ if ui_kit::button(ui, app.tr("render.scene_review"), ui_kit::Button::Enabled(app.render_workspace.view.method == ImageMethod::GpuRaytrace))
+ .clicked()
{
- let request = json!({"id":id,"name":app.render_workspace.view.name,"set":set,"expected_revision":app.session.revision});
- match app.run("render.preset.resolve", request.clone()) {
- Ok(reply) => {
- app.render_workspace.view.inspector.scene_review =
- Some(Review { request, reply, revision: app.session.revision, document: Arc::downgrade(&app.session.doc) });
- app.render_workspace.view.inspector.scene_consent = false;
- }
- Err(error) => app.set_status(error, true),
- }
- }
- let review = app.render_workspace.view.inspector.scene_review.clone().filter(|r| r.request["id"] == id);
- if let Some(review) = review {
- let unchanged =
- review.current(app) && setups::snapshot(app).ok().and_then(|v| serde_json::to_value(v).ok()).as_ref() == Some(&review.request["set"]);
- if !unchanged {
- ui_kit::text(ui, app.tr("render.review_stale"), ui_kit::Text::Error("render.review_stale"));
- }
- if let Some(fields) = review.reply["replaces"].as_array() {
- ui.small(format!("{}: {}", app.tr("render.scene_replaces"), fields.iter().filter_map(Value::as_str).collect::<Vec<_>>().join(", ")));
- }
- let label = app.tr("render.scene_consent").to_string();
- let consent = ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.inspector.scene_consent).on_hover_text(&label);
- crate::scenario::publish_target("render:scene-consent", consent.rect);
- let apply =
- ui_kit::button(ui, app.tr("render.scene_apply"), ui_kit::Button::Enabled(unchanged && app.render_workspace.view.inspector.scene_consent));
- crate::scenario::publish_target("render:scene-apply", apply.rect);
- if apply.clicked() {
- let mut request = review.request;
- request["replace_lighting_and_environment"] = json!(true);
- request["replace_stage"] = json!(true);
- match app.run("render.preset.apply", request) {
- Ok(_) => {
- setups::load(app);
- app.render_workspace.view.inspector.scene_review = None;
- app.set_status(app.tr("render.library_applied").to_string(), false);
- }
- Err(error) => app.set_status(error, true),
- }
+ let mut view = library::View::default();
+ if let Err(error) = library::choose(app, &mut view, "native_scenes", id).and_then(|()| library::review::light(app, &view, id)) {
+ app.set_status(error, true);
}
}
- let title = app.tr("render.scene_scope_details").to_string();
- ui_kit::section(ui, ("render_native_composition_scope", id), &title, false, |ui| {
- for key in ["render.scene_review_help", "render.scene_preserved_fields", "render.library_authored_help"] {
- ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key));
- }
- });
}
pub(super) fn quality_resource(app: &mut SolveApp, ui: &mut egui::Ui, id: &str) {
ui_kit::text(ui, app.tr("render.quality_projection_help"), ui_kit::Text::Note("render.quality_projection_help"));
- let label = app.tr("render.quality_ack").to_string();
- ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.inspector.quality_ack);
- let enabled = app.render_workspace.view.inspector.quality_ack && app.render_workspace.view.method == ImageMethod::GpuRaytrace;
- if ui_kit::button(ui, app.tr("render.quality_review"), ui_kit::Button::Enabled(enabled)).clicked() {
- match app.run("render.quality.prepare", json!({"id":id,"variant":"fixed_samples_png","acknowledge_omissions":true})) {
- Ok(reply) => app.render_workspace.view.inspector.quality_review = Some(reply),
- Err(error) => {
- app.render_workspace.view.inspector.quality_review = None;
- app.set_status(error, true);
- }
- }
- }
- if let Some(plan) = app.render_workspace.view.inspector.quality_review.clone().filter(|p| p["id"] == id) {
- ui.label(format!(
- "{} x {} px / {} spp / {}",
- plan["settings"]["width"], plan["settings"]["height"], plan["gpu_options"]["samples"], plan["gpu_options"]["max_depth"]
- ));
- if ui_kit::button(ui, app.tr("render.quality_apply"), ui_kit::Button::Enabled(enabled)).clicked() {
- let result = apply_quality(app, &plan);
- if let Err(error) = result {
- app.set_status(error, true);
- }
- }
+ if ui_kit::button(ui, app.tr("render.quality_review"), ui_kit::Button::Enabled(app.render_workspace.view.method == ImageMethod::GpuRaytrace))
+ .clicked()
+ && let Err(error) = library::review::quality(app, id)
+ {
+ app.set_status(error, true);
}
}
-fn apply_quality(app: &mut SolveApp, plan: &Value) -> Result<(), String> {
+pub(super) fn apply_quality(app: &mut SolveApp, plan: &Value) -> Result<(), String> {
if app.render_workspace.view.method != ImageMethod::GpuRaytrace || plan["variant"] != "fixed_samples_png" {
return Err(crate::i18n::tr("render.error_quality_method").into());
}
@@ -1396,7 +1294,10 @@ fn camera_actions(app: &mut SolveApp, ui: &mut egui::Ui) {
}
pub(super) fn confirmation_open(app: &SolveApp) -> bool {
- app.render_workspace.view.inspector.pending.is_some() || app.render_workspace.view.save_shot_name.is_some() || materials::confirmation_open(app)
+ app.render_workspace.view.inspector.pending.is_some()
+ || app.render_workspace.view.save_shot_name.is_some()
+ || materials::confirmation_open(app)
+ || library::review_open(app)
}
pub(super) fn reveal(app: &mut SolveApp, section: &'static str) {
app.render_workspace.view.inspector.reveal = Some(section);
diff --git a/crates/ui-egui/src/render_workspace_inspector_tests.rs b/crates/ui-egui/src/render_workspace_inspector_tests.rs
index 9d2672d053..c05d7db92a 100644
--- a/crates/ui-egui/src/render_workspace_inspector_tests.rs
+++ b/crates/ui-egui/src/render_workspace_inspector_tests.rs
@@ -134,17 +134,328 @@ fn complete_native_studio_can_be_reviewed_and_applied_from_real_ui_controls() {
setups::save(&mut h.app).unwrap();
library::open_category(&mut h.app, "native_scenes");
h.frames(4);
- h.step(&json!({"click":{"handle":"render:library:NATIVE-STUDIO-002"}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:light:NATIVE-STUDIO-002"}})).unwrap();
let before = h.app.session.doc.to_json();
- h.step(&json!({"widget":h.app.tr("render.scene_review")})).unwrap();
+ h.step(&json!({"click":{"handle":"render:light:review"}})).unwrap();
assert_eq!(h.app.session.doc.to_json(), before);
- assert!(h.app.render_workspace.view.inspector.scene_review.is_some());
- h.step(&json!({"widget":h.app.tr("render.scene_consent")})).unwrap();
- h.step(&json!({"widget":h.app.tr("render.scene_apply")})).unwrap();
+ assert!(h.app.render_workspace.view.library.review.is_some());
+ h.step(&json!({"click":{"handle":"render:review:acknowledge"}})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
assert!(!h.app.render_workspace.view.draft.stage.is_empty());
- assert!(h.app.render_workspace.view.inspector.scene_review.is_none());
+ assert!(h.app.render_workspace.view.library.review.is_none());
assert!(!h.app.render_workspace.view.dirty);
}
+
+#[test]
+fn surface_stage_contains_preview_target_plane_repeat_and_method_reason_in_order() {
+ let mut h = fixture();
+ h.call("ui.resize", json!({"width":1600,"height":1800}));
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name:"Subject".into() }]})).unwrap();
+ library::open_category(&mut h.app, "surfaces");
+ h.frames(3);
+ let before = h.app.session.doc.to_json();
+ h.step(&json!({"click":{"handle":"render:library:SURF-001"}})).unwrap();
+ h.frames(3);
+ let note = crate::scenario::rect_of("dialog:note:surface:note").unwrap();
+ let target = crate::scenario::rect_of("render:surface:target").unwrap();
+ let plane = crate::scenario::rect_of("render:surface:xy").unwrap();
+ let repeat = crate::scenario::rect_of("render:surface:repeat").unwrap();
+ let reason = crate::scenario::rect_of("dialog:note:surface:gpu:reason").unwrap();
+ assert!(note.bottom() < target.top());
+ assert!(target.bottom() <= plane.top());
+ assert!(plane.bottom() <= repeat.top());
+ assert!(repeat.bottom() < reason.top());
+ assert_eq!(h.app.render_workspace.view.method, ImageMethod::Raster);
+ assert_eq!(h.app.session.doc.to_json(), before);
+}
+
+#[test]
+fn stage_catalogs_fill_a_290_by_530_panel_and_keep_two_line_labels_inside_tiles() {
+ use crate::{scenario, ui_kit};
+ use egui::{Pos2, RawInput, Rect, vec2};
+ let previous_theme = crate::theme::is_dark();
+ for dark in [false, true] {
+ for (kind, selected, method, key) in [
+ ("appearances", None, ImageMethod::Raster, "render:library:catalog"),
+ ("surfaces", None, ImageMethod::Raster, "render:surface:catalog"),
+ ("surfaces", Some("SURF-001"), ImageMethod::Raster, "render:surface:catalog"),
+ ("physical_profiles", Some("steel-304-plate"), ImageMethod::Raster, "render:surface:catalog"),
+ ("native_scenes", None, ImageMethod::Raster, "render:light:catalog"),
+ ("native_scenes", Some("NATIVE-STUDIO-002"), ImageMethod::GpuRaytrace, "render:light:catalog"),
+ ] {
+ let mut h = fixture();
+ // Capture the font atlas from its first upload along with panel textures.
+ h.ctx = crate::fonts::test_context();
+ crate::theme::set_dark(dark);
+ h.ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
+ // A resizable 290 pt card needs the floating, wide-screen policy.
+ h.app.ui.layout = crate::shell::LayoutMode::Floating;
+ h.app.preferences.render_browser_width = 290.0;
+ h.app.preferences.render_browser_side = "left".into();
+ super::super::select_image_method(&mut h.app, method);
+ library::open_category(&mut h.app, kind);
+ crate::theme::TabAccent::publish(&h.app, &h.ctx);
+ let document = h.app.session.doc.to_json();
+ let history = (h.app.session.undo.len(), h.app.session.redo.len());
+ // Panel::workspace reserves an 8 pt bottom gap in these bounds.
+ let bounds = Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 538.0));
+ let mut textures = std::collections::HashMap::new();
+ let mut output = None;
+ let mut unselected_height = 0.0;
+ for pass in 0..8 {
+ if pass == 4 {
+ unselected_height = scenario::rect_of(&format!("{key}:body")).unwrap().height();
+ if let Some(id) = selected {
+ let mut view = std::mem::take(&mut h.app.render_workspace.view.library);
+ library::choose(&mut h.app, &mut view, kind, id).unwrap();
+ h.app.render_workspace.view.library = view;
+ }
+ }
+ let mut frame = h.ctx.run_ui(RawInput { screen_rect: Some(bounds), ..Default::default() }, |ui| {
+ scenario::clear_handles();
+ library::card(&mut h.app, ui, bounds);
+ });
+ ui_kit::test_textures_update(&mut textures, &frame.textures_delta);
+ frame.textures_delta.clear();
+ output = Some(frame);
+ }
+ let panel = h.app.shell.workspace_panels.get("render:appearances").unwrap().0;
+ assert!((panel.width() - 290.0).abs() < 2.0 && (panel.height() - 530.0).abs() < 2.0, "{panel:?}");
+ let content = scenario::rect_of(&format!("{key}:content")).unwrap();
+ let body = scenario::rect_of(&format!("{key}:body")).unwrap();
+ let footer = scenario::rect_of(&format!("{key}:footer")).unwrap();
+ assert!(body.height() >= 0.7 * (content.height() - footer.height()), "{kind} {selected:?}: {content:?} {body:?} {footer:?}");
+ assert!(panel.contains_rect(body) && panel.contains_rect(footer), "{kind}: {panel:?} {body:?} {footer:?}");
+ assert!(body.bottom() <= footer.top() + 0.1, "{kind}: overlapping body and footer");
+ assert!((content.bottom() - footer.bottom()).abs() <= 1.0, "{kind}: footer is not at the bottom");
+ if key == "render:surface:catalog" {
+ let row = scenario::rect_of("render:library:SURF-001").or_else(|| scenario::rect_of("render:library:steel-304-plate")).unwrap();
+ assert!(body.height() >= row.height() * 3.0, "three complete list rows must remain visible");
+ if selected.is_some() {
+ assert!(body.height() < unselected_height, "selecting a resource must make room for its detail card");
+ }
+ } else {
+ let labels: Vec<_> = scenario::rects("render:").into_iter().filter(|(name, _)| name.ends_with(":galley")).collect();
+ assert!(labels.len() >= 3, "{kind}: missing tile captions");
+ for (name, galley) in labels {
+ let id = name.strip_suffix(":galley").unwrap();
+ let tile = scenario::rect_of(id).unwrap();
+ let label = scenario::rect_of(&format!("{id}:label")).unwrap();
+ assert!(tile.contains_rect(label) && label.expand(0.1).contains_rect(galley), "{name}: {tile:?} {label:?} {galley:?}");
+ }
+ let frame = output.as_ref().unwrap();
+ let captions: Vec<_> = crate::test_support::text_shapes(frame).filter(|text| text.galley.job.wrap.max_rows == 2).collect();
+ assert!(captions.iter().any(|text| text.galley.rows.len() == 2), "{kind}: exercise a two-line caption");
+ assert!(captions.iter().all(|text| text.galley.rows.len() <= 2 && !text.galley.job.wrap.break_anywhere));
+ let note = h.app.tr(if kind == "appearances" { "render.stage_layout.appearance_note" } else { "render.stage_layout.studio_note" });
+ let note = crate::test_support::text_shapes(frame).find(|text| text.galley.job.text == note).unwrap();
+ assert_eq!(note.galley.rows.len(), 1, "catalog notes must stay on one line");
+ }
+ assert_eq!(h.app.session.doc.to_json(), document);
+ assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), history);
+ if let Some(dir) = std::env::var_os("SOLIDCRAFT_STAGE_LAYOUT_EVIDENCE") {
+ std::fs::create_dir_all(&dir).unwrap();
+ let frame = output.unwrap();
+ let image = ui_kit::test_raster(&h.ctx, frame.shapes, frame.pixels_per_point, panel, &textures);
+ image
+ .save(std::path::Path::new(&dir).join(format!(
+ "{kind}-{}-{}-{}.png",
+ selected.unwrap_or("none"),
+ method.label(),
+ if dark { "dark" } else { "light" }
+ )))
+ .unwrap();
+ }
+ }
+ }
+ crate::theme::set_dark(previous_theme);
+}
+
+#[test]
+fn review_expires_when_the_reviewed_settings_or_document_change() {
+ let mut h = fixture();
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ library::review::quality(&mut h.app, "Q-002").unwrap();
+ h.frames(3);
+ h.step(&json!({"click":{"handle":"render:review:acknowledge"}})).unwrap();
+ h.app.render_workspace.view.draft.width = 333;
+ h.frames(3);
+ assert!(crate::scenario::rect_of("dialog:report:review:stale").is_some());
+ let before = h.app.session.doc.to_json();
+ let ok = crate::scenario::rect_of("dialog:ok").unwrap().center();
+ h.step(&json!({"click":[ok.x,ok.y]})).unwrap();
+ assert_eq!(h.app.session.doc.to_json(), before);
+ assert_eq!(h.app.render_workspace.view.draft.width, 333);
+ assert!(h.app.render_workspace.view.library.review.is_some());
+}
+
+#[test]
+fn quality_review_is_callable_by_command_and_saves_only_after_acknowledgement() {
+ let mut h = fixture();
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ let mut view = library::View::default();
+ library::choose(&mut h.app, &mut view, "quality", "Q-002").unwrap();
+ h.app.render_workspace.view.library = view;
+ let before = h.app.session.doc.to_json();
+ h.app.start("render.quality.prepare");
+ h.frames(3);
+ assert!(h.app.render_workspace.view.library.review.is_some());
+ assert_eq!(h.app.session.doc.to_json(), before);
+ h.step(&json!({"click":{"handle":"render:review:acknowledge"}})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ let saved = &h.app.session.doc.render.setups[&h.app.render_workspace.view.name];
+ assert_eq!((saved.width, saved.height), (1600, 900));
+ assert_eq!(h.app.render_workspace.view.samples, 512);
+ assert!(h.app.render_workspace.view.library.review.is_none());
+}
+
+#[test]
+fn physical_review_is_read_only_and_can_be_closed_after_acknowledgement() {
+ let mut h = fixture();
+ let before = h.app.session.doc.to_json();
+ let plan = h.app.run("render.library.physical.prepare", json!({"id":"steel-304-plate","name":"Reference","acknowledge_reference":true})).unwrap();
+ library::review::open(&mut h.app, "physical", "304 steel".into(), plan.clone(), library::review::Apply::Physical(plan)).unwrap();
+ h.frames(3);
+ assert!(crate::scenario::rect_of("dialog:note:review:physical").is_some());
+ assert!(crate::scenario::rect_of("dialog:apply").is_some());
+ h.step(&json!({"click":{"handle":"render:review:acknowledge"}})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ assert_eq!(h.app.session.doc.to_json(), before);
+ assert!(h.app.session.doc.user_materials.is_empty());
+}
+
+#[test]
+fn quality_review_rejects_hostile_ids_and_preserves_the_design() {
+ let mut h = fixture();
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ let before = h.app.session.doc.to_json();
+ for id in ["", "../Q-002", "\0", "Q-999999999999999999999999999"] {
+ assert!(library::review::quality(&mut h.app, id).is_err());
+ }
+ assert_eq!(h.app.session.doc.to_json(), before);
+ assert!(h.app.render_workspace.view.library.review.is_none());
+}
+
+#[test]
+fn saved_optics_removal_requires_confirmation_and_keeps_geometry() {
+ let mut h = fixture();
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ setups::save(&mut h.app).unwrap();
+ let name = h.app.render_workspace.view.name.clone();
+ h.app
+ .run(
+ "render.optics.bind",
+ json!({"name":name,"body_index":0,"body_name":"Subject", "expected_revision":h.app.session.revision,"optics":{"ior":1.4}}),
+ )
+ .unwrap();
+ setups::load(&mut h.app);
+ let target = h.app.render_workspace.view.draft.optics.iter().next().unwrap().target.clone();
+ let before = h.app.session.doc.to_json();
+ let geometry = h.app.session.doc.features.clone();
+ let revision = h.app.session.revision;
+ library::review::remove(&mut h.app, "render.optics.unbind", json!({"name":name,"target":target,"expected_revision":revision}));
+ h.frames(3);
+ assert_eq!(h.app.session.doc.to_json(), before);
+ h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap();
+ assert_eq!(h.app.session.doc.to_json(), before);
+ library::review::remove(&mut h.app, "render.optics.unbind", json!({"name":name,"target":target,"expected_revision":revision}));
+ h.frames(3);
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ assert!(h.app.session.doc.render.setups[&name].optics.is_empty());
+ assert_eq!(h.app.session.doc.features, geometry);
+}
+
+#[test]
+fn temporary_maps_review_keeps_plane_scale_and_requires_acknowledgement() {
+ let mut h = fixture();
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ let target: materials::Target = serde_json::from_value(h.app.run("render.scene", json!({})).unwrap()["bodies"][0].clone()).unwrap();
+ let plan = h
+ .app
+ .run("render.library.surface.prepare", json!({"id":"SURF-001","body_index":target.ordinal,"body_name":target.name,"plane":"yz","scale":2.5}))
+ .unwrap();
+ let before = h.app.session.doc.to_json();
+ library::review::open(
+ &mut h.app,
+ "maps",
+ "Brushed stainless".into(),
+ plan,
+ library::review::Apply::Maps { id: "SURF-001".into(), target, plane: "yz".into(), scale: 2.5 },
+ )
+ .unwrap();
+ h.frames(3);
+ assert!(h.app.render_workspace.view.materials.bindings.is_empty());
+ h.step(&json!({"click":{"handle":"render:review:acknowledge"}})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ let binding = &h.app.render_workspace.view.materials.bindings[0];
+ assert_eq!(binding.maps.frame.u, [0.0, 250.0, 0.0]);
+ assert_eq!(binding.maps.frame.v, [0.0, 0.0, 250.0]);
+ assert_eq!(h.app.session.doc.to_json(), before);
+}
+
+#[test]
+fn rig_review_contains_fit_and_consent_controls_in_design_order_without_applying() {
+ let mut h = fixture();
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
+ let mut view = library::View::default();
+ library::choose(&mut h.app, &mut view, "rigs", "RIG-002").unwrap();
+ let before = h.app.session.doc.to_json();
+ library::review::light(&mut h.app, &view, "RIG-002").unwrap();
+ h.frames(3);
+ let mut previous = crate::scenario::rect_of("review:sphere").unwrap().bottom();
+ for key in ["render:review:center:0", "render:review:extent", "render:review:bounds", "render:review:emitters-only", "render:review:acknowledge"]
+ {
+ let rect = crate::scenario::rect_of(key).unwrap();
+ assert!(rect.top() >= previous, "{key} is out of design order");
+ previous = rect.bottom();
+ }
+ assert_eq!(h.app.session.doc.to_json(), before);
+ assert!(!h.app.render_workspace.view.library.review.as_ref().unwrap().acknowledged);
+}
+
+#[test]
+fn returning_between_look_and_light_restores_catalogs_for_the_selected_scope() {
+ let mut h = fixture();
+ let catalog = h.app.run("appearance.library", json!({})).unwrap();
+ let id = catalog["appearances"].as_array().unwrap().iter().find_map(|entry| entry["id"].as_str()).unwrap().to_string();
+ let before = h.app.session.doc.to_json();
+ library::open_category(&mut h.app, "native_scenes");
+ h.frames(3);
+ assert!(crate::scenario::rect_of("render:light:NATIVE-STUDIO-001").is_some());
+ h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
+ h.frames(3);
+ assert!(crate::scenario::rect_of(&format!("render:library:{id}")).is_some());
+ library::open_category(&mut h.app, "scenes");
+ h.frames(3);
+ assert!(crate::scenario::rect_of("render:light:SCENE-001").is_some());
+ h.app.run("view.render_stage", json!({"stage":"look"})).unwrap();
+ h.frames(3);
+ h.app.run("view.render_stage", json!({"stage":"light"})).unwrap();
+ h.frames(3);
+ assert!(crate::scenario::rect_of("render:light:SCENE-001").is_some());
+ assert!(crate::scenario::rect_of("dialog:note:render:light:reason").is_some());
+ assert_eq!(h.app.session.doc.to_json(), before);
+}
+
+#[test]
+fn surface_target_dropdown_keeps_the_chosen_body_through_review() {
+ let mut h = fixture();
+ h.call("ui.resize", json!({"width":1600,"height":1800}));
+ h.app.run("solid.box", json!({"length":5,"width":5,"height":5,"body_name":"Other"})).unwrap();
+ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body { name:"Subject".into() }]})).unwrap();
+ library::open_category(&mut h.app, "surfaces");
+ h.frames(3);
+ h.step(&json!({"click":{"handle":"render:library:SURF-001"}})).unwrap();
+ h.frames(3);
+ h.step(&json!({"click":{"handle":"render:surface:target"}})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:list:Other"}})).unwrap();
+ h.frames(3);
+ h.step(&json!({"widget":h.app.tr("render.stage_panels.use_uniform")})).unwrap();
+ h.step(&json!({"click":{"handle":"render:review:acknowledge"}})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ assert!(h.app.session.doc.appearances.bodies.contains_key("Other"));
+ assert!(!h.app.session.doc.appearances.bodies.contains_key("Subject"));
+}
#[test]
fn unsupported_output_is_visible_and_never_fakes_export_or_clamps_intent() {
let mut h = fixture();
@@ -256,6 +567,10 @@ fn temporary_library_maps_preserve_the_reviewed_plane_scale_and_optical_exclusiv
let original = binding.maps.frame;
assert!(materials::install_library_surface(&mut h.app, "SURF-001", target.clone(), "unknown", 1.0).is_err());
assert!(materials::install_library_surface(&mut h.app, "SURF-001", target.clone(), "xy", 0.0).is_err());
+ for scale in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -1.0, f64::MAX] {
+ assert!(materials::install_library_surface(&mut h.app, "SURF-001", target.clone(), "xy", scale).is_err());
+ assert_eq!(h.app.render_workspace.view.materials.bindings[0].maps.frame, original);
+ }
assert_eq!(h.app.render_workspace.view.materials.bindings[0].maps.frame, original);
h.app.render_workspace.view.materials.bindings[0].glass_enabled = true;
assert!(materials::install_library_surface(&mut h.app, "SURF-001", target, "xy", 1.0).is_err());
@@ -264,7 +579,7 @@ fn temporary_library_maps_preserve_the_reviewed_plane_scale_and_optical_exclusiv
}
#[test]
-fn native_composition_review_actions_are_visible_before_auxiliary_resource_details() {
+fn native_composition_review_actions_are_visible_in_shared_dialog() {
for dark in [false, true] {
let mut h = fixture();
h.call("ui.set", json!({"dark":dark}));
@@ -272,16 +587,18 @@ fn native_composition_review_actions_are_visible_before_auxiliary_resource_detai
setups::save(&mut h.app).unwrap();
library::open_category(&mut h.app, "native_scenes");
h.frames(3);
- h.step(&json!({"click":{"handle":"render:library:NATIVE-STUDIO-002"}})).unwrap();
- let footer = crate::scenario::rect_of("render:job-footer").unwrap();
- let resolve = crate::scenario::rect_of("render:scene-resolve").unwrap();
- assert!(resolve.bottom() < footer.top(), "the review action must precede supplementary prose");
- h.step(&json!({"click":{"handle":"render:scene-resolve"}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:light:NATIVE-STUDIO-002"}})).unwrap();
+ h.step(&json!({"click":{"handle":"render:light:review"}})).unwrap();
h.frames(3);
- for name in ["render:scene-consent", "render:scene-apply"] {
- let rect = crate::scenario::rect_of(name).unwrap();
- assert!(rect.bottom() < footer.top(), "{name} must remain above the pinned job actions: rect={rect:?}, footer={footer:?}, dark={dark}");
- }
+ let card = crate::scenario::rect_of("review:sphere").unwrap();
+ let replaces = crate::scenario::rect_of("dialog:note:review:replaces").unwrap();
+ let kept = crate::scenario::rect_of("dialog:note:review:kept").unwrap();
+ let ack = crate::scenario::rect_of("render:review:acknowledge").unwrap();
+ assert!(card.bottom() <= replaces.top());
+ assert!(replaces.bottom() <= kept.top());
+ assert!(kept.bottom() <= ack.top());
+ assert!(crate::scenario::rect_of("dialog:ok").is_some());
+ assert!(!h.app.render_workspace.view.library.review.as_ref().unwrap().acknowledged);
}
}
@@ -652,6 +969,9 @@ fn clearing_physical_stage_preserves_unsaved_camera_background_and_output_intent
assert_eq!(h.app.render_workspace.view.inspector.page, Page::Background);
h.step(&json!({"click":{"handle":"render:stage-clear"}})).unwrap();
h.frames(3);
+ assert_eq!(h.app.render_workspace.view.draft.stage.len(), 1);
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ h.frames(3);
assert_eq!(setups::snapshot(&h.app).unwrap(), expected, "clearing stage must keep the unsaved numerical draft, not reload an older one");
assert_eq!(h.app.session.doc.render.setups[&name], expected);
assert_eq!(h.app.session.doc.features, geometry);
diff --git a/crates/ui-egui/src/render_workspace_library.rs b/crates/ui-egui/src/render_workspace_library.rs
index d471718874..186b61cdb9 100644
--- a/crates/ui-egui/src/render_workspace_library.rs
+++ b/crates/ui-egui/src/render_workspace_library.rs
@@ -1,5 +1,8 @@
//! Existing Render-panel library browser. Engine commands own catalog resolution,
//! assignments and saved resources; this view owns only search and request drafts.
+#[path = "render_workspace_library_review.rs"]
+pub(super) mod review;
+
use super::{ImageMethod, materials, setups};
use crate::{SolveApp, theme::Tokens, ui_kit};
use serde_json::{Value, json};
@@ -23,16 +26,15 @@ pub(super) struct View {
target_query: String,
targets: Vec<materials::Target>,
target: Option<materials::Target>,
+ picked_target: Option<String>,
target_revision: Option<u64>,
target_document: Option<Weak<Document>>,
- acknowledge_projection: bool,
- replace_environment: bool,
- replace_studio: bool,
- replace_surface: bool,
- include_cards: bool,
+ pub(super) review: Option<review::Draft>,
+ removal: Option<review::Removal>,
+ look_tab: usize,
+ light_scope: usize,
physical_name: String,
- physical_ack: bool,
- physical_plan: Option<Value>,
+
center: [f64; 3],
extent: f64,
availability: String,
@@ -84,16 +86,15 @@ impl Default for View {
target_query: String::new(),
targets: Vec::new(),
target: None,
+ picked_target: None,
target_revision: None,
target_document: None,
- acknowledge_projection: false,
- replace_environment: false,
- replace_studio: false,
- replace_surface: false,
- include_cards: true,
+ review: None,
+ removal: None,
+ look_tab: 0,
+ light_scope: 0,
physical_name: "Reference material".into(),
- physical_ack: false,
- physical_plan: None,
+
center: [0.0; 3],
extent: 1000.0,
availability: "all".into(),
@@ -135,9 +136,35 @@ fn refresh(app: &mut SolveApp, view: &mut View) -> Result<(), String> {
.collect();
view.total = view.entries.len();
view.next = None;
- } else if view.collection == 3 || view.kind == "appearances" {
+ } else if view.collection == 3 || matches!(view.kind.as_str(), "appearances" | "selene_appearances" | "materials") && view.look_tab == 0 {
let reply = app.run(if view.collection == 3 { "appearance.list" } else { "appearance.library" }, json!({}))?;
view.entries = reply[if view.collection == 3 { "in_design" } else { "appearances" }].as_array().cloned().unwrap_or_default();
+ for entry in &mut view.entries {
+ entry["library_kind"] = json!("appearances");
+ }
+ if view.collection == 0 {
+ for kind in ["selene_appearances", "materials"] {
+ let reply = app.run("render.library.list", json!({"kind":kind,"limit":128}))?;
+ for mut entry in reply["items"].as_array().cloned().unwrap_or_default() {
+ let detail = app.run("render.library.describe", json!({"kind":kind,"id":entry["id"]}))?;
+ entry["resource"] = detail["resource"].clone();
+ entry["projection"] = detail["projection"].clone();
+ entry["library_kind"] = json!(kind);
+ view.entries.push(entry);
+ }
+ }
+ }
+ view.total = view.entries.len();
+ view.next = None;
+ } else if view.light_scope == 3 && matches!(view.kind.as_str(), "scenes" | "selene_shots" | "lighting" | "environments") {
+ view.entries.clear();
+ for kind in ["scenes", "selene_shots", "lighting", "environments"] {
+ let reply = app.run("render.library.list", json!({"kind":kind,"query":view.query,"limit":128}))?;
+ for mut entry in reply["items"].as_array().cloned().unwrap_or_default() {
+ entry["library_kind"] = json!(kind);
+ view.entries.push(entry);
+ }
+ }
view.total = view.entries.len();
view.next = None;
} else {
@@ -157,9 +184,6 @@ fn refresh(app: &mut SolveApp, view: &mut View) -> Result<(), String> {
view.document = Some(Arc::downgrade(&app.session.doc));
view.loaded = true;
// Search/page changes preserve the independently inspected resource.
- view.acknowledge_projection = false;
- view.physical_ack = false;
- view.physical_plan = None;
Ok(())
}
fn current_target(app: &SolveApp, view: &View) -> bool {
@@ -240,6 +264,8 @@ const KINDS: &[(&str, &str)] = &[
("capabilities", "render.library_capabilities"),
];
+const LOOK_KINDS: &[&str] = &["appearances", "materials", "selene_appearances"];
+
fn switch_kind(view: &mut View, kind: &str) {
if view.kind == kind || !KINDS.iter().any(|(value, _)| *value == kind) {
return;
@@ -272,22 +298,32 @@ fn switch_kind(view: &mut View, kind: &str) {
view.category.clear();
view.preview = None;
view.preview_error = None;
- view.physical_plan = None;
- view.acknowledge_projection = false;
- view.physical_ack = false;
}
pub(super) fn open_category(app: &mut SolveApp, kind: &str) {
// Explicit catalog browsing retains read-only Inspector workflows on the library stage.
+ let stage = match kind {
+ "native_scenes" | "rigs" | "hdr" | "scenes" | "selene_shots" | "lighting" | "environments" => "light",
+ "quality" | "capabilities" => "output",
+ _ => "look",
+ };
let page = app.render_workspace.view.inspector.page;
- let _ = app.run("view.render_stage", json!({"stage":"look"}));
+ let _ = app.run("view.render_stage", json!({"stage":stage}));
app.render_workspace.view.inspector.page = page;
switch_kind(&mut app.render_workspace.view.library, kind);
- app.render_workspace.view.library.collection = 0;
+ let view = &mut app.render_workspace.view.library;
+ view.collection = 0;
+ view.look_tab = usize::from(matches!(kind, "surfaces" | "physical_profiles"));
+ view.light_scope = match kind {
+ "rigs" => 1,
+ "hdr" | "environments" => 2,
+ "scenes" | "selene_shots" | "lighting" => 3,
+ _ => 0,
+ };
app.ui.show_browser = true;
let _ = app.run("view.render_browser", json!({"open":true}));
app.tree.panel_collapsed = false;
}
-fn choose(app: &mut SolveApp, view: &mut View, kind: &str, id: &str) -> Result<(), String> {
+pub(super) fn choose(app: &mut SolveApp, view: &mut View, kind: &str, id: &str) -> Result<(), String> {
switch_kind(view, kind);
let detail = describe(app, kind, id)?;
let display = detail["resource"]["name"].as_str().or_else(|| detail["resource"]["designation"].as_str()).unwrap_or(id).to_string();
@@ -296,10 +332,6 @@ fn choose(app: &mut SolveApp, view: &mut View, kind: &str, id: &str) -> Result<(
view.selected = Some(id.into());
view.preview = None;
view.preview_error = None;
- view.acknowledge_projection = false;
- view.physical_ack = false;
- view.physical_plan = None;
- app.render_workspace.view.inspector.clear_resource_reviews();
let key = (kind.to_string(), id.to_string());
app.preferences.render_library_recent.retain(|old| old != &key);
app.preferences.render_library_recent.push_front(key.clone());
@@ -322,6 +354,19 @@ fn choose(app: &mut SolveApp, view: &mut View, kind: &str, id: &str) -> Result<(
Ok(())
}
+fn choose_in_stage(app: &mut SolveApp, view: &mut View, kind: &str, id: &str) -> Result<(), String> {
+ // A stage scope can combine several catalog kinds. Inspecting a tile keeps
+ // that scope's search and category, rather than navigating to another catalog.
+ let query = view.query.clone();
+ let category = view.category.clone();
+ let offset = view.offset;
+ choose(app, view, kind, id)?;
+ view.query = query;
+ view.category = category;
+ view.offset = offset;
+ Ok(())
+}
+
/// Resolve previews and Inspector metadata through the same public catalog commands.
fn look_signature(entry: &Value) -> Value {
json!([entry["name"], entry["color"], entry["opacity"], entry["pbr"]])
@@ -437,16 +482,40 @@ pub(super) fn card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) {
let mut side = app.preferences.render_browser_side.clone();
let mut width = app.preferences.render_browser_width;
let stage = app.render_workspace.view.stage;
- let title = app.tr(stage_title(stage)).to_string();
- let mut layout = app.render_workspace.view.library.layout;
+ if stage == super::Stage::Look {
+ let view = &mut app.render_workspace.view.library;
+ let compatible = if view.look_tab == 1 {
+ matches!(view.kind.as_str(), "surfaces" | "physical_profiles")
+ } else {
+ LOOK_KINDS.contains(&view.kind.as_str())
+ };
+ if !compatible {
+ let kind = if view.look_tab == 1 { "surfaces" } else { "appearances" };
+ switch_kind(view, kind);
+ view.collection = 0;
+ }
+ }
+ let title = app
+ .tr(if stage == super::Stage::Look && app.render_workspace.view.library.look_tab == 1 {
+ "render.stage_panels.surfaces_references"
+ } else {
+ stage_title(stage)
+ })
+ .to_string();
+ let mut mode = if app.render_workspace.view.library.look_tab == 1 { 2 } else { app.render_workspace.view.library.layout };
let mut actions = |ui: &mut egui::Ui| {
ui_kit::catalog_scope(ui, |ui| {
ui_kit::segmented_icons(
ui,
- &mut layout,
+ &mut mode,
&[
ui_kit::IconSegment { key: "render:library-grid", icon: "grid", tip: crate::i18n::tr("render.library_grid").into() },
ui_kit::IconSegment { key: "render:library-list", icon: "list", tip: crate::i18n::tr("render.library_list").into() },
+ ui_kit::IconSegment {
+ key: "render:library-panel",
+ icon: "library",
+ tip: crate::i18n::tr("render.stage_panels.surfaces_references").into(),
+ },
],
&[],
)
@@ -468,7 +537,13 @@ pub(super) fn card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) {
&mut side,
&mut width,
|ui| match stage {
- super::Stage::Look => ui_kit::catalog_scope(ui, |ui| browse_contents(app, ui, true)),
+ super::Stage::Look => ui_kit::catalog_scope(ui, |ui| {
+ if app.render_workspace.view.library.look_tab == 0 {
+ browse_contents(app, ui, true);
+ } else {
+ surface_panel(app, ui);
+ }
+ }),
super::Stage::Light => light_panel(app, ui),
super::Stage::Output => super::inspector::size_presets(app, ui),
super::Stage::Frame => {
@@ -477,7 +552,15 @@ pub(super) fn card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) {
}
},
);
- app.render_workspace.view.library.layout = layout;
+ let look_tab = usize::from(mode == 2);
+ if mode < 2 {
+ app.render_workspace.view.library.layout = mode;
+ }
+ if look_tab != app.render_workspace.view.library.look_tab {
+ switch_kind(&mut app.render_workspace.view.library, if look_tab == 0 { "appearances" } else { "surfaces" });
+ app.render_workspace.view.library.collection = 0;
+ app.render_workspace.view.library.look_tab = look_tab;
+ }
app.preferences.render_browser_width = width;
let requested =
response.as_ref().and_then(|r| r.inner.1).map(str::to_string).or_else(|| (app.preferences.render_browser_side != side).then(|| side.clone()));
@@ -501,49 +584,201 @@ fn stage_title(stage: super::Stage) -> &'static str {
}
}
+fn restore_view(app: &mut SolveApp, mut view: View) {
+ if let Some(review) = app.render_workspace.view.library.review.take() {
+ view.review = Some(review);
+ }
+ if let Some(removal) = app.render_workspace.view.library.removal.take() {
+ view.removal = Some(removal);
+ }
+ app.render_workspace.view.library = view;
+}
+
+const LIGHT_SCOPES: &[(&str, &str)] = &[
+ ("native_scenes", "render.stage_panels.studios"),
+ ("rigs", "render.stage_panels.rigs"),
+ ("hdr", "render.stage_panels.environments"),
+ ("scenes", "render.stage_panels.specifications"),
+ ("mine", "render.stage_panels.mine"),
+];
+
fn light_panel(app: &mut SolveApp, ui: &mut egui::Ui) {
- egui::ScrollArea::vertical().id_salt("render_light_resources").auto_shrink([false, false]).show(ui, |ui| {
- for (kind, heading) in [("native_scenes", "render.library_native_scenes"), ("hdr", "render.library_hdr")] {
- ui_kit::text(ui, app.tr(heading), ui_kit::Text::Inline);
- let reply = match app.run("render.library.list", json!({"kind":kind,"limit":128})) {
- Ok(reply) => reply,
- Err(error) => {
+ let mut view = std::mem::take(&mut app.render_workspace.view.library);
+ let previous = view.light_scope;
+ let labels: Vec<_> = LIGHT_SCOPES.iter().map(|(_, key)| app.tr(key)).collect();
+ ui_kit::choice_row(ui, app.tr("render.stage_panels.scope"), "render_light_scope", &mut view.light_scope, &labels);
+ let compatible = match view.light_scope {
+ 0 => view.kind == "native_scenes",
+ 1 => view.kind == "rigs",
+ 2 => view.kind == "hdr",
+ 3 => matches!(view.kind.as_str(), "scenes" | "selene_shots" | "lighting" | "environments"),
+ 4 => true,
+ _ => false,
+ };
+ if previous != view.light_scope || !compatible {
+ if let Some((kind, _)) = LIGHT_SCOPES.get(view.light_scope)
+ && *kind != "mine"
+ {
+ switch_kind(&mut view, kind);
+ }
+ view.collection = 0;
+ }
+ if view.light_scope == 4 {
+ ui.add_enabled_ui(false, |ui| {
+ ui_kit::search_field(ui, ui.id().with("render_mine_search"), &mut view.query, app.tr("render.stage_panels.search_studios"));
+ ui_kit::button(ui, app.tr("render.stage_panels.apply"), ui_kit::Button::Normal);
+ });
+ ui_kit::text(ui, app.tr("render.stage_panels.mine_pending"), ui_kit::Text::Note("render:mine:reason"));
+ restore_view(app, view);
+ return;
+ }
+ catalog_search(app, ui, &mut view, "render.stage_panels.search_studios");
+ let reason = if view.light_scope == 3 { Some(app.tr("render.library_specification_only").to_string()) } else { light_reason(app, &view.kind) };
+ let layout = ui_kit::CatalogLayout::new(ui, "render:light:catalog", 0);
+ layout.body(ui, |ui| {
+ let identities: Vec<_> = view.entries.iter().map(|e| format!("render:light:{}", e["id"].as_str().unwrap_or(""))).collect();
+ let tiles: Vec<_> = view
+ .entries
+ .iter()
+ .zip(&identities)
+ .map(|(entry, identity)| ui_kit::SphereTile {
+ id: identity,
+ name: entry["name"].as_str().unwrap_or(""),
+ sphere: ui_kit::Sphere { color: Tokens::get().body, kind: ui_kit::FinishKind::Metal, opacity: None },
+ selected: view.selected.as_deref() == entry["id"].as_str(),
+ users: 0,
+ tip: entry["name"].as_str().unwrap_or(""),
+ badge: Some(tile_badge(app, entry)),
+ })
+ .collect();
+ if let Some(entry) = ui_kit::sphere_grid(ui, &tiles).and_then(|index| view.entries.get(index)).cloned()
+ && let Some(id) = entry["id"].as_str()
+ {
+ let kind = entry["library_kind"].as_str().unwrap_or(&view.kind).to_string();
+ if let Err(error) = choose_in_stage(app, &mut view, &kind, id) {
+ app.set_status(error, true);
+ }
+ }
+ if view.light_scope == 3
+ && let Some(detail) = &view.details
+ {
+ ui_kit::text(ui, detail["resource"]["description"].as_str().unwrap_or(""), ui_kit::Text::Note("render:specification"));
+ }
+ });
+ layout.footer(ui, |ui| {
+ catalog_pages(app, ui, &mut view);
+ if let Some(reason) = &reason {
+ ui_kit::text(ui, reason, ui_kit::Text::Note("render:light:reason"));
+ }
+ let apply = ui_kit::button(ui, app.tr("render.stage_panels.apply"), ui_kit::Button::Enabled(view.selected.is_some() && reason.is_none()));
+ crate::scenario::publish_target("render:light:review", apply.rect);
+ if apply.clicked()
+ && let Some(id) = view.selected.clone()
+ && let Err(error) = refresh_targets(app, &mut view).and_then(|()| review::light(app, &view, &id))
+ {
+ app.set_status(error, true);
+ }
+ ui_kit::catalog_footer_with_tip(ui, app.tr("render.stage_layout.studio_note"), app.tr("render.stage_panels.studio_note"));
+ });
+ restore_view(app, view);
+}
+
+fn catalog_search(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, hint: &str) {
+ let search = ui_kit::search_field(ui, ui.id().with("render_stage_catalog_search"), &mut view.query, app.tr(hint));
+ crate::scenario::publish_target("render:library-search", search.rect);
+ let end = view.query.char_indices().nth(128).map_or(view.query.len(), |(at, _)| at);
+ view.query.truncate(end);
+ if search.changed() {
+ view.offset = 0;
+ view.loaded = false;
+ }
+ let changed =
+ view.revision != Some(app.session.revision) || view.document.as_ref().is_none_or(|doc| !Weak::ptr_eq(doc, &Arc::downgrade(&app.session.doc)));
+ if (!view.loaded || changed)
+ && let Err(error) = refresh(app, view)
+ {
+ view.loaded = true;
+ app.set_status(error, true);
+ }
+}
+fn catalog_pages(app: &SolveApp, ui: &mut egui::Ui, view: &mut View) {
+ if view.offset > 0 || view.next.is_some() {
+ ui.horizontal(|ui| {
+ if ui_kit::button(ui, app.tr("render.library_previous"), ui_kit::Button::Enabled(view.offset > 0)).clicked() {
+ view.offset = view.offset.saturating_sub(48);
+ view.loaded = false;
+ }
+ if ui_kit::button(ui, app.tr("render.library_next"), ui_kit::Button::Enabled(view.next.is_some())).clicked() {
+ view.offset = view.next.unwrap_or(view.offset);
+ view.loaded = false;
+ }
+ });
+ }
+}
+fn surface_panel(app: &mut SolveApp, ui: &mut egui::Ui) {
+ let mut view = std::mem::take(&mut app.render_workspace.view.library);
+ let mut scope = usize::from(view.kind == "physical_profiles");
+ if ui_kit::segmented(
+ ui,
+ &mut scope,
+ &[app.tr("render.stage_panels.surfaces"), app.tr("render.stage_panels.references")],
+ ui_kit::Segments { compact: true, proportional: true, targets: &["render:surfaces", "render:references"], ..Default::default() },
+ ) {
+ switch_kind(&mut view, if scope == 0 { "surfaces" } else { "physical_profiles" });
+ }
+ catalog_search(app, ui, &mut view, "render.stage_panels.search_surfaces");
+ let layout = ui_kit::CatalogLayout::new(ui, "render:surface:catalog", 3);
+ layout.body(ui, |ui| {
+ for entry in view.entries.clone() {
+ let id = entry["id"].as_str().unwrap_or("");
+ let label = entry["name"].as_str().or_else(|| entry["resource"]["designation"].as_str()).unwrap_or(id);
+ let mut item = ui_kit::MenuItem::new(id, label, "grid");
+ item.highlighted = view.selected.as_deref() == Some(id);
+ let response =
+ item.search_row(ui, &view.query, short_availability(app, entry.pointer("/projection/status").and_then(Value::as_str)), None);
+ crate::scenario::publish_target(&format!("render:library:{id}"), response.rect);
+ if response.clicked() {
+ let kind = view.kind.clone();
+ if let Err(error) = choose_in_stage(app, &mut view, &kind, id) {
app.set_status(error, true);
- continue;
}
- };
- let entries = reply["items"].as_array().cloned().unwrap_or_default();
- let ids: Vec<_> = entries.iter().map(|e| format!("render:light:{}", e["id"].as_str().unwrap_or(""))).collect();
- let tiles: Vec<_> = entries
- .iter()
- .zip(&ids)
- .map(|(entry, id)| ui_kit::SphereTile {
- id,
- name: entry["name"].as_str().unwrap_or(""),
- sphere: ui_kit::Sphere { color: Tokens::get().body, kind: ui_kit::FinishKind::Metal, opacity: None },
- selected: false,
- users: 0,
- tip: entry["name"].as_str().unwrap_or(""),
- })
- .collect();
- let reason = light_reason(app, kind);
- let grid = ui.add_enabled_ui(reason.is_none(), |ui| ui_kit::sphere_grid(ui, &tiles));
- if let Some(reason) = reason {
- grid.response.on_disabled_hover_text(reason);
}
- if let Some(entry) = grid.inner.and_then(|index| entries.get(index))
- && let Some(id) = entry["id"].as_str()
- && let Err(error) = apply_light(app, kind, id)
- {
- app.set_status(error, true);
+ }
+ });
+ layout.footer(ui, |ui| {
+ catalog_pages(app, ui, &mut view);
+ if let Some(id) = view.selected.clone() {
+ if scope == 0 {
+ ui_kit::divider(ui, "surface:rule");
+ ui_kit::text(ui, app.tr("render.stage_panels.source_note"), ui_kit::Text::Note("surface:note"));
+ source_preview(app, ui, &mut view, &id);
+ surface_controls(app, ui, &mut view, &id);
+ if let Some(detail) = view.details.clone() {
+ let title = app.tr("render.library_details").to_string();
+ ui_kit::section(ui, ("surface:inspect", &id), &title, false, |ui| {
+ if let Some(description) = detail["resource"]["description"].as_str() {
+ ui_kit::text(ui, description, ui_kit::Text::Note("surface:description"));
+ }
+ for source in detail["sources"].as_array().into_iter().flatten().take(128) {
+ if let Some(url) = source["url"].as_str() {
+ ui.hyperlink_to(source["title"].as_str().unwrap_or(url), url);
+ }
+ }
+ if ui_kit::button(ui, app.tr("render.copy_request"), ui_kit::Button::Normal).clicked() {
+ ui.ctx().copy_text(serde_json::to_string_pretty(&detail).unwrap_or_default());
+ }
+ });
+ }
+ } else if let Some(detail) = view.details.clone() {
+ physical_controls(app, ui, &mut view, &id, &detail);
}
}
});
+ restore_view(app, view);
}
-
fn light_reason(app: &SolveApp, kind: &str) -> Option<String> {
- if kind == "native_scenes" && app.render_workspace.view.method != ImageMethod::GpuRaytrace {
- return Some(app.tr("render.studio_tiles_require_gpu").into());
+ if matches!(kind, "native_scenes" | "rigs") && app.render_workspace.view.method != ImageMethod::GpuRaytrace {
+ return Some(app.tr("render.stage_panels.gpu_required").into());
}
if app.render_workspace.view.method == ImageMethod::Raster {
return Some(app.tr("render.environment_tiles_require_raytrace").into());
@@ -551,24 +786,116 @@ fn light_reason(app: &SolveApp, kind: &str) -> Option<String> {
patch(app).err()
}
-fn apply_light(app: &mut SolveApp, kind: &str, id: &str) -> Result<(), String> {
- if let Some(reason) = light_reason(app, kind) {
- return Err(reason);
- }
- let set = patch(app)?;
- let name = app.render_workspace.view.name.clone();
- let (command, request) = if kind == "native_scenes" {
- (
- "render.preset.apply",
- json!({"id":id,"name":name,"set":set,"expected_revision":app.session.revision,
- "replace_lighting_and_environment":true,"replace_stage":true}),
- )
- } else {
- ("render.library.environment.apply", json!({"id":id,"name":name,"set":set,"replace_environment":true}))
- };
- app.run(command, request)?;
- setups::load(app);
- Ok(())
+fn surface_controls(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, id: &str) {
+ let picked = app.session.selection.iter().find_map(|selection| match selection {
+ solidcraft_engine::Sel::Body { name } | solidcraft_engine::Sel::Face { body: name, .. } => Some(name.clone()),
+ _ => None,
+ });
+ if !current_target(app, view) {
+ let previous = view.target.clone();
+ match refresh_targets(app, view) {
+ Ok(()) => view.target = previous.filter(|target| view.targets.contains(target)),
+ Err(error) => app.set_status(error, true),
+ }
+ }
+ if picked != view.picked_target || view.target.is_none() {
+ if let Some(name) = &picked {
+ view.target = view.targets.iter().find(|target| target.name == *name).cloned();
+ }
+ view.picked_target = picked;
+ }
+ let target_row = ui_kit::row(ui, app.tr("render.stage_panels.target"), |ui| {
+ let label = view.target.as_ref().map_or(app.tr("render.material_choose_body"), |target| target.name.as_str());
+ let label = label.to_string();
+ ui_kit::dropdown_menu(ui, "render_surface_target", &label, |ui| {
+ for target in &view.targets {
+ if ui_kit::list_picker(ui, &target.name, &target.name, view.target.as_ref() == Some(target)).clicked() {
+ view.target = Some(target.clone());
+ ui.close();
+ }
+ }
+ })
+ });
+ crate::scenario::publish_target("render:surface:target", target_row.rect);
+ ui_kit::row(ui, app.tr("render.stage_panels.plane"), |ui| {
+ ui_kit::segmented(
+ ui,
+ &mut view.mapping_plane,
+ &["xy", "yz", "zx"],
+ ui_kit::Segments { compact: true, targets: &["render:surface:xy", "render:surface:yz", "render:surface:zx"], ..Default::default() },
+ );
+ });
+ ui_kit::row(ui, app.tr("render.stage_panels.repeat"), |ui| {
+ let repeat = ui_kit::number_field(ui, &mut view.mapping_scale, 0.001..=1000.0, 0.01, " ×");
+ crate::scenario::publish_target("render:surface:repeat", repeat.rect);
+ });
+ let supported = view
+ .details
+ .as_ref()
+ .is_some_and(|detail| matches!(detail["projection"]["status"].as_str(), Some("implemented_pending_batch_validation" | "native_appearance")));
+ let enabled = supported && current_target(app, view);
+ let gpu = app.render_workspace.view.method == ImageMethod::GpuRaytrace;
+ let mut requested = None;
+ ui.horizontal(|ui| {
+ if ui_kit::button(ui, app.tr("render.stage_panels.use_uniform"), ui_kit::Button::Enabled(enabled)).clicked() {
+ requested = Some(0);
+ }
+ if ui_kit::button(ui, app.tr("render.stage_panels.use_maps"), ui_kit::Button::Enabled(enabled && gpu)).clicked() {
+ requested = Some(1);
+ }
+ });
+ if ui_kit::button(ui, app.tr("render.stage_panels.save_maps"), ui_kit::Button::Enabled(enabled && gpu && patch(app).is_ok())).clicked() {
+ requested = Some(2);
+ }
+ if !gpu {
+ ui_kit::text(ui, app.tr("render.stage_panels.gpu_required"), ui_kit::Text::Note("surface:gpu:reason"));
+ }
+ if !supported {
+ ui_kit::text(ui, app.tr("render.library_specification_only"), ui_kit::Text::Note("surface:reference:reason"));
+ }
+ if let (Some(mode), Some(target)) = (requested, view.target.clone()) {
+ let result = (|| -> Result<(), String> {
+ let label = view.details.as_ref().and_then(|d| d["resource"]["name"].as_str()).unwrap_or(id).to_string();
+ let plane = ["xy", "yz", "zx"].get(view.mapping_plane).copied().unwrap_or("xy");
+ let (plan, action) = if mode == 0 {
+ (
+ view.details.clone().unwrap_or_default(),
+ review::Apply::Command {
+ id: "render.library.appearance.apply".into(),
+ params: json!({"id":id,"variant":"uniform_opaque","bodies":[target.name]}),
+ },
+ )
+ } else {
+ let surface = json!({"id":id,"body_index":target.ordinal,"body_name":target.name,"scale":view.mapping_scale,"plane":plane});
+ let plan = app.run("render.library.surface.prepare", surface.clone())?;
+ let action = if mode == 2 {
+ review::Apply::Command {
+ id: "render.library.surface.bind".into(),
+ params: json!({"name":app.render_workspace.view.name,"set":patch(app)?,"surface":surface,"replace":true}),
+ }
+ } else {
+ review::Apply::Maps { id: id.into(), target, plane: plane.into(), scale: view.mapping_scale }
+ };
+ (plan, action)
+ };
+ review::open(
+ app,
+ if mode == 0 {
+ "uniform"
+ } else if mode == 2 {
+ "saved_maps"
+ } else {
+ "maps"
+ },
+ label,
+ plan,
+ action,
+ )
+ })();
+ if let Err(error) = result {
+ app.set_status(error, true);
+ }
+ }
}
fn selected_looks(app: &mut SolveApp) -> Vec<Value> {
@@ -654,7 +981,6 @@ fn apply_look(app: &mut SolveApp, entry: &Value) -> Result<(), String> {
fn browse_contents(app: &mut SolveApp, ui: &mut egui::Ui, stage_card: bool) {
let mut view = std::mem::take(&mut app.render_workspace.view.library);
- let t = Tokens::get();
let document_changed =
view.revision != Some(app.session.revision) || view.document.as_ref().is_none_or(|doc| !Weak::ptr_eq(doc, &Arc::downgrade(&app.session.doc)));
if (!view.loaded || document_changed)
@@ -663,7 +989,12 @@ fn browse_contents(app: &mut SolveApp, ui: &mut egui::Ui, stage_card: bool) {
view.loaded = true;
app.set_status(error, true);
}
- let hint = crate::i18n::format("render.search_appearances", &[("count", &view.total.to_string())]);
+ let count = if stage_card && matches!(view.collection, 1 | 2) {
+ view.entries.iter().filter(|entry| LOOK_KINDS.contains(&entry["library_kind"].as_str().unwrap_or("appearances"))).count()
+ } else {
+ view.total
+ };
+ let hint = crate::i18n::format("render.search_appearances", &[("count", &count.to_string())]);
let query = if view.collection == 0 { &mut view.query } else { &mut view.collection_query };
let search = ui_kit::search_field(ui, ui.id().with("render_library_search"), query, &hint);
query.truncate(query.char_indices().nth(128).map_or(query.len(), |(at, _)| at));
@@ -732,17 +1063,16 @@ fn browse_contents(app: &mut SolveApp, ui: &mut egui::Ui, stage_card: bool) {
)
})
.collect();
+ if stage_card {
+ entries.retain(|(kind, _, _)| LOOK_KINDS.contains(&kind.as_str()));
+ }
egui::ScrollArea::horizontal().id_salt("render_library_chips").scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysHidden).show(
ui,
|ui| {
ui.horizontal(|ui| {
- for (id, label) in [
- ("", "ui.all"),
- ("metal", "render.category_metal"),
- ("plastic", "render.category_plastic"),
- ("paint", "render.category_paint"),
- ("wood", "render.category_wood"),
- ] {
+ for (id, label) in
+ [("", "ui.all"), ("metal", "render.category_metal"), ("plastic", "render.category_plastic"), ("paint", "render.category_paint")]
+ {
if ui_kit::choice_chip(ui, &format!("render-library-{id}"), app.tr(label), view.category == id).clicked() {
view.category = id.into();
}
@@ -799,12 +1129,11 @@ fn browse_contents(app: &mut SolveApp, ui: &mut egui::Ui, stage_card: bool) {
})
.collect();
let identities: Vec<_> = entries.iter().map(|(_, id, _)| format!("render:library:{id}")).collect();
- let footer = t.control_height * if view.collection == 0 && view.kind != "appearances" { 3.0 } else { 1.0 };
- let height = (ui.available_height() - footer).max(t.control_height);
+ let layout = ui_kit::CatalogLayout::new(ui, "render:library:catalog", 0);
let mut selected = None;
- egui::ScrollArea::vertical().id_salt(("render_library_items", &view.kind, view.collection)).max_height(height).auto_shrink([false, false]).show(
- ui,
- |ui| {
+ // Keep each catalog/collection's independent scroll position.
+ ui.push_id((&view.kind, view.collection), |ui| {
+ layout.body(ui, |ui| {
if entries.is_empty() {
ui_kit::text(ui, app.tr("render.library_empty"), ui_kit::Text::Note("render.library_empty"));
}
@@ -820,19 +1149,10 @@ fn browse_contents(app: &mut SolveApp, ui: &mut egui::Ui, stage_card: bool) {
selected: view.kind == *kind && view.selected.as_ref() == Some(id),
users: usage_for(entry, &used).map_or_else(|| user_count(entry), user_count),
tip,
+ badge: Some(tile_badge(app, entry)),
})
.collect();
- if applicable_count > 0 {
- ui_kit::text(ui, app.tr("render.library_applicable"), ui_kit::Text::Inline);
- selected = ui_kit::sphere_grid(ui, tiles.get(..applicable_count).unwrap_or_default());
- }
- if applicable_count < tiles.len() {
- if applicable_count > 0 {
- ui_kit::text(ui, app.tr("render.library_other"), ui_kit::Text::Inline);
- }
- let other = ui_kit::sphere_grid(ui, tiles.get(applicable_count..).unwrap_or_default()).map(|i| i + applicable_count);
- selected = selected.or(other);
- }
+ selected = ui_kit::sphere_grid(ui, &tiles);
} else {
for (index, ((kind, id, entry), tip)) in entries.iter().zip(&tips).enumerate() {
if index == 0 && applicable_count > 0 {
@@ -858,62 +1178,100 @@ fn browse_contents(app: &mut SolveApp, ui: &mut egui::Ui, stage_card: bool) {
}
}
}
- },
- );
- if !stage_card || view.kind != "appearances" {
- let menu = ui_kit::dropdown_menu(ui, "render_library_filters", app.tr("render.library_filters"), |ui| {
- if view.collection == 0 {
- for &(kind, key) in KINDS {
- let r = ui_kit::list_picker(ui, kind, app.tr(key), view.kind == kind);
- crate::scenario::publish_target(&format!("render:library-kind:{kind}"), r.rect);
- if r.clicked() {
- switch_kind(&mut view, kind);
+ });
+ });
+ layout.footer(ui, |ui| {
+ if !stage_card {
+ let menu = ui_kit::dropdown_menu(ui, "render_library_filters", app.tr("render.library_filters"), |ui| {
+ if view.collection == 0 {
+ for &(kind, key) in KINDS {
+ let r = ui_kit::list_picker(ui, kind, app.tr(key), view.kind == kind);
+ crate::scenario::publish_target(&format!("render:library-kind:{kind}"), r.rect);
+ if r.clicked() {
+ switch_kind(&mut view, kind);
+ ui.close();
+ }
+ }
+ ui_kit::divider(ui, "render-library-availability");
+ }
+ for (id, key) in [
+ ("all", "render.library_all_states"),
+ ("usable", "render.library_usable"),
+ ("specification", "render.library_specs"),
+ ("blocked", "render.library_blocked"),
+ ] {
+ if ui_kit::list_picker(ui, id, app.tr(key), view.availability == id).clicked() {
+ view.availability = id.into();
+ view.offset = 0;
+ view.loaded = false;
ui.close();
}
}
- ui_kit::divider(ui, "render-library-availability");
+ });
+ crate::scenario::publish_target("render:library-category", menu.rect);
+ if view.collection == 0 && view.kind != "appearances" {
+ ui.horizontal(|ui| {
+ if ui_kit::button(ui, app.tr("render.library_previous"), ui_kit::Button::Enabled(view.offset > 0)).clicked() {
+ view.offset = view.offset.saturating_sub(48);
+ view.loaded = false;
+ }
+ if ui_kit::button(ui, app.tr("render.library_next"), ui_kit::Button::Enabled(view.next.is_some())).clicked() {
+ view.offset = view.next.unwrap_or(view.offset);
+ view.loaded = false;
+ }
+ });
}
- for (id, key) in [
- ("all", "render.library_all_states"),
- ("usable", "render.library_usable"),
- ("specification", "render.library_specs"),
- ("blocked", "render.library_blocked"),
- ] {
- if ui_kit::list_picker(ui, id, app.tr(key), view.availability == id).clicked() {
- view.availability = id.into();
- view.offset = 0;
- view.loaded = false;
- ui.close();
+ }
+ if let Some((kind, id, entry)) = selected.and_then(|index| entries.get(index)) {
+ let result = if stage_card { choose_in_stage(app, &mut view, kind, id) } else { choose(app, &mut view, kind, id) }.and_then(|()| {
+ if !stage_card {
+ return Ok(());
}
- }
- });
- crate::scenario::publish_target("render:library-category", menu.rect);
- if view.collection == 0 && view.kind != "appearances" {
- ui.horizontal(|ui| {
- if ui_kit::button(ui, app.tr("render.library_previous"), ui_kit::Button::Enabled(view.offset > 0)).clicked() {
- view.offset = view.offset.saturating_sub(48);
- view.loaded = false;
+ if kind == "appearances" {
+ return apply_look(app, entry);
}
- if ui_kit::button(ui, app.tr("render.library_next"), ui_kit::Button::Enabled(view.next.is_some())).clicked() {
- view.offset = view.next.unwrap_or(view.offset);
- view.loaded = false;
+ if kind == "selene_appearances" {
+ let bodies: Vec<_> = app
+ .session
+ .selection
+ .iter()
+ .filter_map(|selection| match selection {
+ solidcraft_engine::Sel::Body { name } => Some(name.clone()),
+ _ => None,
+ })
+ .collect();
+ if !bodies.is_empty() {
+ return review::open(
+ app,
+ "uniform",
+ entry["name"].as_str().unwrap_or(id).into(),
+ view.details.clone().unwrap_or_default(),
+ review::Apply::Command {
+ id: "render.library.appearance.apply".into(),
+ params: json!({"id":id,"variant":"uniform_opaque","bodies":bodies}),
+ },
+ );
+ }
+ if !app.session.selection.is_empty() {
+ return Err(app.tr("render.material_choose_body").to_string());
+ }
}
+ Ok(())
});
+ if let Err(error) = result {
+ app.set_status(error, true);
+ }
}
- }
- if let Some((kind, id, entry)) = selected.and_then(|index| entries.get(index)) {
- let result =
- choose(app, &mut view, kind, id).and_then(|()| if stage_card && kind == "appearances" { apply_look(app, entry) } else { Ok(()) });
- if let Err(error) = result {
- app.set_status(error, true);
+ if stage_card {
+ ui_kit::catalog_footer_with_tip(ui, app.tr("render.stage_layout.appearance_note"), app.tr("render.stage_panels.paint_pending"));
+ if view.kind == "materials" {
+ ui_kit::text(ui, app.tr("render.library_specification_only"), ui_kit::Text::Note("appearance:reference:reason"));
+ }
+ } else {
+ ui_kit::text(ui, app.tr("render.library_inspect_only"), ui_kit::Text::Note("render.library_inspect_only"));
}
- }
- if stage_card {
- ui_kit::catalog_footer(ui, app.tr("render.library_apply_hint"));
- } else {
- ui_kit::text(ui, app.tr("render.library_inspect_only"), ui_kit::Text::Note("render.library_inspect_only"));
- }
- app.render_workspace.view.library = view;
+ });
+ restore_view(app, view);
}
pub(super) fn selected_kind(app: &SolveApp, kind: &str) -> bool {
@@ -930,6 +1288,26 @@ pub(super) fn inspect_kinds(app: &mut SolveApp, ui: &mut egui::Ui, kinds: &[&str
ui_kit::text(ui, app.tr("render.library_select_hint"), ui_kit::Text::Note("render.library_select_hint"));
}
}
+
+pub(super) fn inspect_appearance(app: &mut SolveApp, ui: &mut egui::Ui) {
+ if app.render_workspace.view.library.kind == "appearances" {
+ inspect(app, ui);
+ }
+}
+
+/// Interactive command activation can review the specification selected by S5.
+pub(super) fn review_selected_quality(app: &mut SolveApp) -> Result<(), String> {
+ let id = app.render_workspace.view.library.selected.clone().filter(|_| app.render_workspace.view.library.kind == "quality");
+ if let Some(id) = id {
+ super::review_resource(app, "render.quality.prepare", &id)?;
+ }
+ Ok(())
+}
+
+pub(super) fn review_open(app: &SolveApp) -> bool {
+ let view = &app.render_workspace.view.library;
+ view.review.is_some() || view.removal.is_some()
+}
pub(super) fn inspect(app: &mut SolveApp, ui: &mut egui::Ui) {
let mut view = std::mem::take(&mut app.render_workspace.view.library);
if let Some(id) = view.selected.clone() {
@@ -998,13 +1376,10 @@ pub(super) fn inspect(app: &mut SolveApp, ui: &mut egui::Ui) {
} else {
ui_kit::text(ui, app.tr("render.library_select_hint"), ui_kit::Text::Note("render.library_select_hint"));
}
- app.render_workspace.view.library = view;
+ restore_view(app, view);
}
fn source_preview(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, id: &str) {
- if view.preview.as_ref().is_none_or(|preview| preview.id != id)
- && view.preview_error.is_none()
- && ui_kit::button(ui, app.tr("render.library_source_preview"), ui_kit::Button::Normal).clicked()
- {
+ if view.preview.as_ref().is_none_or(|preview| preview.id != id) && view.preview_error.is_none() {
let result = (|| -> Result<SourcePreview, String> {
let reply = app.run("render.library.preview", json!({"id":id}))?;
let bytes: Vec<u8> = serde_json::from_value(reply["bytes"].clone()).map_err(|e| e.to_string())?;
@@ -1032,8 +1407,7 @@ fn source_preview(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, id: &s
}
}
if let Some(preview) = &view.preview {
- ui.add(egui::Image::new(&preview.texture).max_size(egui::vec2(ui.available_width(), 180.0)).shrink_to_fit());
- ui_kit::text(ui, app.tr("render.library_source_preview_help"), ui_kit::Text::Note("render.library_source_preview_help"));
+ ui.add(egui::Image::new(&preview.texture).max_size(egui::vec2(ui.available_width(), 64.0)).shrink_to_fit());
}
if let Some(error) = &view.preview_error {
ui.small(error);
@@ -1123,130 +1497,16 @@ fn resource_controls(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, id:
"native_scenes" => super::inspector::scene_resource(app, ui, id),
"quality" => super::inspector::quality_resource(app, ui, id),
"physical_profiles" => physical_controls(app, ui, view, id, &detail),
- "surfaces" | "selene_appearances" => {
- target_controls(app, ui, view);
- ui_kit::checkbox(ui, app.tr("render.library_uniform_ack"), &mut view.acknowledge_projection);
- if ui_kit::button(
- ui,
- app.tr("render.library_apply_uniform"),
- ui_kit::Button::Enabled(current_target(app, view) && view.acknowledge_projection),
- )
- .clicked()
- && let Some(target) = view.target.clone()
- {
- match app.run("render.library.appearance.apply", json!({"id":id,"variant":"uniform_opaque","bodies":[target.name]})) {
- Ok(_) => {
- view.target_revision = None;
- app.set_status(app.tr("render.library_applied").to_string(), false);
- }
- Err(e) => app.set_status(e, true),
- }
+ "surfaces" | "selene_appearances" => surface_controls(app, ui, view, id),
+ "hdr" | "rigs" => {
+ let reason = light_reason(app, &view.kind);
+ if let Some(reason) = &reason {
+ ui_kit::text(ui, reason, ui_kit::Text::Note("render:light:reason"));
}
- if view.kind == "surfaces" {
- ui_kit::text(ui, app.tr("render.library_maps_help"), ui_kit::Text::Note("render.library_maps_help"));
- ui_kit::checkbox(ui, app.tr("render.replace_saved_surface"), &mut view.replace_surface);
- ui.label(app.tr("render.mapping_scale"));
- ui_kit::number_field(ui, &mut view.mapping_scale, 0.001..=1000.0, 0.01, " x");
- ui_kit::segmented(ui, &mut view.mapping_plane, &["XY", "YZ", "ZX"], Default::default());
- let candidate = patch(app);
- let enabled = current_target(app, view) && app.render_workspace.view.method == ImageMethod::GpuRaytrace && candidate.is_ok();
- if ui_kit::button(ui, app.tr("render.library_save_maps"), ui_kit::Button::Enabled(enabled)).clicked()
- && let (Some(target), Ok(set)) = (view.target.clone(), candidate)
- {
- let name = app.render_workspace.view.name.clone();
- match app.run("render.library.surface.bind",json!({"name":name,"set":set,"surface":{"id":id,"body_index":target.ordinal,"body_name":target.name,"scale":view.mapping_scale,"plane":(["xy","yz","zx"].get(view.mapping_plane).copied().unwrap_or("xy"))},"replace":view.replace_surface})) {
- Ok(_)=>{setups::load(app);view.target_revision=None;app.set_status(app.tr("render.library_applied").to_string(),false);},
- Err(e)=>app.set_status(e,true),
- }
- }
-
- let enabled = current_target(app, view) && app.render_workspace.view.method == ImageMethod::GpuRaytrace;
- if ui_kit::button(ui, app.tr("render.library_apply_maps"), ui_kit::Button::Enabled(enabled)).clicked()
- && let Some(target) = view.target.clone()
- {
- match materials::install_library_surface(
- app,
- id,
- target,
- ["xy", "yz", "zx"].get(view.mapping_plane).copied().unwrap_or("xy"),
- view.mapping_scale,
- ) {
- Ok(()) => app.set_status(app.tr("render.library_applied").to_string(), false),
- Err(e) => app.set_status(e, true),
- }
- }
- }
- }
- "hdr" => {
- ui_kit::text(ui, app.tr("render.library_hdr_help"), ui_kit::Text::Note("render.library_hdr_help"));
- ui_kit::checkbox(ui, app.tr("render.library_replace_environment"), &mut view.replace_environment);
- let candidate = patch(app);
- if let Err(e) = &candidate {
- ui.small(e);
- }
- let enabled = candidate.is_ok() && app.render_workspace.view.method != ImageMethod::Raster;
- if ui_kit::button(ui, app.tr("render.library_apply_hdr"), ui_kit::Button::Enabled(enabled)).clicked()
- && let Ok(set) = candidate
- {
- let name = app.render_workspace.view.name.clone();
- match app
- .run("render.library.environment.apply", json!({"id":id,"name":name,"set":set,"replace_environment":view.replace_environment}))
- {
- Ok(_) => {
- setups::load(app);
- app.set_status(app.tr("render.library_applied").to_string(), false);
- }
- Err(e) => app.set_status(e, true),
- }
- }
- }
- "rigs" => {
- let blocked = detail["projection"]["status"] == "blocked";
- if blocked {
- ui.colored_label(Tokens::get().warning, app.tr("render.library_blocked"));
- return;
- }
- ui_kit::text(ui, app.tr("render.library_rig_help"), ui_kit::Text::Note("render.library_rig_help"));
- if ui_kit::button(ui, app.tr("render.library_scene_bounds"), ui_kit::Button::Normal).clicked()
- && let Err(e) = refresh_targets(app, view)
+ if ui_kit::button(ui, app.tr("render.stage_panels.apply"), ui_kit::Button::Enabled(reason.is_none())).clicked()
+ && let Err(error) = review::light(app, view, id)
{
- app.set_status(e, true);
- }
- ui.label(app.tr("render.library_center"));
- for c in &mut view.center {
- ui_kit::number_field(ui, c, -1e12..=1e12, 1.0, " mm");
- }
- ui.label(app.tr("render.library_extent"));
- ui_kit::number_field(ui, &mut view.extent, 0.001..=1e6, 1.0, " mm");
- let cards = detail["projection"]["passive_cards"].as_u64().unwrap_or(0);
- if cards > 0 {
- ui_kit::checkbox(ui, app.tr("render.include_rig_cards"), &mut view.include_cards);
- if !view.include_cards {
- ui_kit::checkbox(ui, app.tr("render.library_emitters_only_ack"), &mut view.acknowledge_projection);
- }
- }
- ui_kit::checkbox(ui, app.tr("render.library_replace_studio"), &mut view.replace_studio);
- let candidate = patch(app);
- let enabled = !blocked
- && (cards == 0 || view.include_cards || view.acknowledge_projection)
- && view.replace_studio
- && candidate.is_ok()
- && app.render_workspace.view.method == ImageMethod::GpuRaytrace;
- if ui_kit::button(ui, app.tr("render.library_apply_studio"), ui_kit::Button::Enabled(enabled)).clicked()
- && let Ok(set) = candidate
- {
- let name = app.render_workspace.view.name.clone();
- let rig = json!({"id":id,"variant":if cards==0 || view.include_cards {"complete"} else {"emitters_only"},"center_mm":view.center,"subject_extent_mm":view.extent});
- match app.run(
- "render.library.studio.apply",
- json!({"rig":rig,"name":name,"set":set,"replace_lighting_and_environment":true,"replace_stage":true}),
- ) {
- Ok(_) => {
- setups::load(app);
- app.set_status(app.tr("render.library_applied").to_string(), false);
- }
- Err(e) => app.set_status(e, true),
- }
+ app.set_status(error, true);
}
}
_ => {
@@ -1324,17 +1584,14 @@ pub(super) fn stage_content(app: &mut SolveApp, ui: &mut egui::Ui) {
&& let Ok(set) = candidate
{
let name = app.render_workspace.view.name.clone();
- match app.run("render.stage.ground", json!({"name":name,"set":set})) {
- Ok(_) => setups::load(app),
- Err(e) => app.set_status(e, true),
- }
+ review::command(app, "render.stage.ground", json!({"name":name,"set":set,"replace_stage":true}));
}
let clear = ui_kit::button(ui, app.tr("render.clear_stage"), ui_kit::Button::Enabled(!empty && patch(app).is_ok()));
crate::scenario::publish_target("render:stage-clear", clear.rect);
if clear.clicked() {
let name = app.render_workspace.view.name.clone();
- match patch(app).and_then(|set| app.run("render.stage.clear", json!({"name":name,"set":set})).map(|_| ())) {
- Ok(()) => setups::load(app),
+ match patch(app) {
+ Ok(set) => review::remove(app, "render.stage.clear", json!({"name":name,"set":set})),
Err(error) => app.set_status(error, true),
}
}
@@ -1381,18 +1638,13 @@ fn physical_controls(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, id:
}
ui.label(app.tr("render.physical_material_name"));
ui_kit::bounded_cell_editor(ui, ui.id().with("physical_reference_name"), &mut view.physical_name, "", false, 128);
- ui_kit::checkbox(ui, app.tr("render.physical_acknowledge"), &mut view.physical_ack);
- if ui_kit::button(ui, app.tr("render.physical_prepare_plan"), ui_kit::Button::Enabled(view.physical_ack)).clicked() {
- match app.run("render.library.physical.prepare", json!({"id":id,"name":view.physical_name,"acknowledge_reference":true})) {
- Ok(plan) => view.physical_plan = Some(plan),
- Err(e) => app.set_status(e, true),
- }
- }
- if let Some(plan) = &view.physical_plan {
- ui_kit::text(ui, app.tr("render.physical_plan_only"), ui_kit::Text::Note("render.physical_plan_only"));
- let text = serde_json::to_string_pretty(plan).unwrap_or_default();
- if ui_kit::button(ui, app.tr("render.physical_copy_plan"), ui_kit::Button::Normal).clicked() {
- ui.ctx().copy_text(text);
+ if ui_kit::button(ui, app.tr("render.stage_panels.prepare_plan"), ui_kit::Button::Normal).clicked() {
+ let result =
+ app.run("render.library.physical.prepare", json!({"id":id,"name":view.physical_name,"acknowledge_reference":true})).and_then(|plan| {
+ review::open(app, "physical", resource["designation"].as_str().unwrap_or(id).into(), plan.clone(), review::Apply::Physical(plan))
+ });
+ if let Err(error) = result {
+ app.set_status(error, true);
}
}
}
@@ -1408,6 +1660,17 @@ fn short_availability<'a>(app: &'a SolveApp, status: Option<&str>) -> &'a str {
})
}
+fn tile_badge<'a>(app: &'a SolveApp, entry: &Value) -> &'a str {
+ app.tr(match entry.pointer("/projection/status").and_then(Value::as_str) {
+ Some("native_appearance" | "native_composition") => "render.stage_panels.badge_native",
+ Some("implemented_pending_batch_validation") => "render.stage_panels.badge_projection",
+ Some("blocked") => "render.stage_panels.badge_blocked",
+ Some("specification_only") => "render.stage_panels.badge_specification",
+ None if entry["library_kind"] == "appearances" && entry["available"] != false => "render.stage_panels.badge_native",
+ _ => "render.stage_panels.badge_reference",
+ })
+}
+
fn availability_label<'a>(app: &'a SolveApp, status: Option<&str>) -> &'a str {
app.tr(match status {
Some("native_appearance") => "render.library_appearance_available",
@@ -1599,58 +1862,25 @@ mod studio_browser_tests {
}
#[test]
- fn light_tiles_apply_existing_studio_and_environment_commands_with_one_undo_each() {
+ fn light_tiles_select_then_review_and_apply_with_one_undo() {
let mut h = Harness::new();
h.app.run("solid.box", json!({"length":20,"width":15,"height":10,"body_name":"Sample"})).unwrap();
super::super::enter(&mut h.app, true).unwrap();
let unchanged = h.app.session.doc.to_json();
- h.app.render_workspace.view.method = ImageMethod::Raster;
- assert!(apply_light(&mut h.app, "native_scenes", "NATIVE-STUDIO-001").is_err());
- assert_eq!(h.app.session.doc.to_json(), unchanged);
- h.app.render_workspace.view.method = ImageMethod::GpuRaytrace;
+ assert!(light_reason(&h.app, "native_scenes").is_some());
+ super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
h.app.run("view.render_stage", json!({"stage":"light"})).unwrap();
h.frames(4);
let undo = h.app.session.undo.len();
h.step(&json!({"click":{"handle":"render:light:NATIVE-STUDIO-001"}})).unwrap();
- assert_eq!(h.app.session.undo.len(), undo + 1);
- let name = h.app.render_workspace.view.name.clone();
- assert!(!h.app.session.doc.render.setups[&name].stage.is_empty());
- h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), unchanged);
- h.app.render_workspace.view = super::super::ViewState::default();
- super::super::select_image_method(&mut h.app, ImageMethod::GpuRaytrace);
- h.app.run("view.render_stage", json!({"stage":"light"})).unwrap();
- h.frames(4);
- let panel = h.app.shell.workspace_panels["render:appearances"].0;
- for _ in 0..40 {
- let tile = crate::scenario::rect_of("render:light:HDR-001").unwrap();
- if tile.top() >= panel.top() + Tokens::get().form_header_height && tile.bottom() <= panel.bottom() {
- break;
- }
- h.frame_with(vec![
- egui::Event::PointerMoved(panel.center()),
- egui::Event::MouseWheel {
- unit: egui::MouseWheelUnit::Point,
- delta: egui::vec2(0.0, -80.0),
- modifiers: egui::Modifiers::default(),
- phase: egui::TouchPhase::Move,
- },
- ]);
- h.frames(4);
- }
- h.frame_with(vec![egui::Event::MouseWheel {
- unit: egui::MouseWheelUnit::Point,
- delta: egui::Vec2::ZERO,
- modifiers: egui::Modifiers::default(),
- phase: egui::TouchPhase::End,
- }]);
- h.frames(30);
- let tile = crate::scenario::rect_of("render:light:HDR-001").unwrap();
- assert!(panel.contains_rect(tile), "HDR tile must be reachable through the panel scroll area");
- assert!(light_reason(&h.app, "hdr").is_none(), "HDR is disabled: {:?}", light_reason(&h.app, "hdr"));
- h.step(&json!({"click":{"handle":"render:light:HDR-001"}})).unwrap();
- assert_eq!(h.app.session.undo.len(), undo + 1, "HDR click: {:?}; tile: {tile:?}; panel: {panel:?}", h.app.status);
- assert!(!h.app.session.doc.render.resources.is_empty());
+ h.step(&json!({"click":{"handle":"render:light:review"}})).unwrap();
+ assert!(h.app.render_workspace.view.library.review.is_some());
+ assert_eq!(h.app.session.undo.len(), undo);
+ h.step(&json!({"click":{"handle":"render:review:acknowledge"}})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
+ assert_eq!(h.app.session.undo.len(), undo + 1);
+ assert!(!h.app.render_workspace.view.draft.stage.is_empty());
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.to_json(), unchanged);
}
diff --git a/crates/ui-egui/src/render_workspace_library_review.rs b/crates/ui-egui/src/render_workspace_library_review.rs
new file mode 100644
index 0000000000..3d0c1ad6a5
--- /dev/null
+++ b/crates/ui-egui/src/render_workspace_library_review.rs
@@ -0,0 +1,313 @@
+//! Captured review plans. Preparing/closing never mutates the design.
+use super::*;
+
+#[derive(Clone, Debug)]
+pub(in crate::render_workspace) enum Apply {
+ Command { id: String, params: Value },
+ Maps { id: String, target: materials::Target, plane: String, scale: f64 },
+ Quality(Value),
+ Physical(Value),
+}
+
+#[derive(Clone, Debug)]
+pub(in crate::render_workspace) struct Draft {
+ pub variant: &'static str,
+ pub name: String,
+ pub plan: Value,
+ pub action: Apply,
+ pub acknowledged: bool,
+ pub bounds: bool,
+ pub emitters_only: bool,
+ pub center: [f64; 3],
+ pub extent: f64,
+ revision: u64,
+ document: Weak<Document>,
+ snapshot: Value,
+ shot: String,
+ method: ImageMethod,
+}
+
+impl Draft {
+ fn current(&self, app: &SolveApp) -> bool {
+ self.revision == app.session.revision
+ && self.shot == app.render_workspace.view.name
+ && self.method == app.render_workspace.view.method
+ && Weak::ptr_eq(&self.document, &Arc::downgrade(&app.session.doc))
+ && patch(app).ok().as_ref() == Some(&self.snapshot)
+ }
+}
+
+pub(in crate::render_workspace) fn open(app: &mut SolveApp, variant: &'static str, name: String, plan: Value, action: Apply) -> Result<(), String> {
+ let snapshot = patch(app)?;
+ app.render_workspace.view.library.review = Some(Draft {
+ variant,
+ name,
+ plan,
+ action,
+ acknowledged: false,
+ bounds: true,
+ emitters_only: false,
+ center: [0.0; 3],
+ extent: 1000.0,
+ revision: app.session.revision,
+ document: Arc::downgrade(&app.session.doc),
+ snapshot,
+ shot: app.render_workspace.view.name.clone(),
+ method: app.render_workspace.view.method,
+ });
+ Ok(())
+}
+
+pub(in crate::render_workspace) fn quality(app: &mut SolveApp, id: &str) -> Result<(), String> {
+ if app.render_workspace.view.method != ImageMethod::GpuRaytrace {
+ return Err(app.tr("render.stage_panels.gpu_required").into());
+ }
+ let plan = app.run("render.quality.prepare", json!({"id":id,"variant":"fixed_samples_png","acknowledge_omissions":true}))?;
+ open(app, "quality", plan["name"].as_str().unwrap_or(id).into(), plan.clone(), Apply::Quality(plan))
+}
+
+pub(in crate::render_workspace) fn light(app: &mut SolveApp, view: &View, id: &str) -> Result<(), String> {
+ if let Some(reason) = light_reason(app, &view.kind) {
+ return Err(reason);
+ }
+ let set = patch(app)?;
+ let name = app.render_workspace.view.name.clone();
+ let label = view.details.as_ref().and_then(|d| d["resource"]["name"].as_str()).unwrap_or(id).to_string();
+ match view.kind.as_str() {
+ "native_scenes" => {
+ let mut params = json!({"id":id,"name":name,"set":set,"expected_revision":app.session.revision});
+ let plan = app.run("render.preset.resolve", params.clone())?;
+ params["replace_lighting_and_environment"] = json!(true);
+ params["replace_stage"] = json!(true);
+ open(app, "studio", label, plan, Apply::Command { id: "render.preset.apply".into(), params })
+ }
+ "hdr" => open(
+ app,
+ "environment",
+ label,
+ view.details.clone().unwrap_or_default(),
+ Apply::Command {
+ id: "render.library.environment.apply".into(),
+ params: json!({"id":id,"name":name,"set":set,"replace_environment":true}),
+ },
+ ),
+ "rigs" => {
+ let rig = json!({"id":id,"variant":"complete","center_mm":view.center,"subject_extent_mm":view.extent});
+ let plan = app.run("render.library.studio.prepare", rig.clone())?;
+ open(
+ app,
+ "rig",
+ label,
+ plan,
+ Apply::Command {
+ id: "render.library.studio.apply".into(),
+ params: json!({"rig":rig,"name":name,"set":set,"replace_lighting_and_environment":true,"replace_stage":true}),
+ },
+ )?;
+ if let Some(draft) = &mut app.render_workspace.view.library.review {
+ draft.center = view.center;
+ draft.extent = view.extent;
+ }
+ Ok(())
+ }
+ _ => Err(app.tr("render.library_specification_only").into()),
+ }
+}
+
+pub(in crate::render_workspace) fn command(app: &mut SolveApp, id: &str, params: Value) {
+ let result = open(app, "stage", app.tr("render.passive_stage").into(), Value::Null, Apply::Command { id: id.into(), params });
+ if let Err(error) = result {
+ app.set_status(error, true);
+ }
+}
+
+fn apply(app: &mut SolveApp, draft: &mut Draft) -> Result<(), String> {
+ if !draft.current(app) || !draft.acknowledged {
+ return Err(app.tr("render.review_stale").into());
+ }
+ match &mut draft.action {
+ Apply::Command { id, params } => {
+ if draft.variant == "rig" {
+ params["rig"]["center_mm"] = json!(draft.center);
+ params["rig"]["subject_extent_mm"] = json!(draft.extent);
+ params["rig"]["variant"] = json!(if draft.emitters_only { "emitters_only" } else { "complete" });
+ app.run("render.library.studio.prepare", params["rig"].clone())?;
+ }
+ app.run(id, params.clone())?;
+ if id.as_str() != "render.library.appearance.apply" {
+ setups::load(app);
+ }
+ }
+ Apply::Maps { id, target, plane, scale } => materials::install_library_surface(app, id, target.clone(), plane, *scale)?,
+ Apply::Quality(plan) => {
+ super::super::inspector::apply_quality(app, plan)?;
+ setups::save(app)?;
+ }
+ Apply::Physical(_) => {}
+ }
+ Ok(())
+}
+
+pub(in crate::render_workspace) fn dialog(app: &mut SolveApp, ctx: &egui::Context) {
+ let Some(mut draft) = app.render_workspace.view.library.review.take() else { return };
+ let current = draft.current(app);
+ let title = app.tr(&format!("render.stage_panels.review_{}", draft.variant)).to_string();
+ let subtitle = if draft.variant == "rig" {
+ let emitters = draft.plan["lighting"]["area_lights"].as_array().map_or(0, Vec::len) + usize::from(!draft.plan["lighting"]["sun"].is_null());
+ let cards = draft.plan["stage"].as_array().map_or(0, Vec::len);
+ crate::i18n::format("render.stage_panels.rig_summary", &[("emitters", &emitters.to_string()), ("cards", &cards.to_string())])
+ } else {
+ app.tr(&format!("render.stage_panels.subtitle_{}", draft.variant)).to_string()
+ };
+ let replaces = app.tr(&format!("render.stage_panels.replaces_{}", draft.variant)).to_string();
+ let kept = app.tr(if draft.variant == "quality" { "render.stage_panels.kept_quality" } else { "render.stage_panels.kept_fields" }).to_string();
+ let acknowledgement = app
+ .tr(match draft.variant {
+ "studio" => "render.stage_panels.studio_ack",
+ "rig" => "render.library_replace_studio",
+ "physical" => "render.physical_acknowledge",
+ "quality" => "render.stage_panels.quality_ack",
+ "stage" => "render.replace_ground",
+ _ => "render.stage_panels.acknowledge",
+ })
+ .to_string();
+ let apply_label = app
+ .tr(match draft.variant {
+ "studio" => "render.stage_panels.apply_studio",
+ "rig" => "render.stage_panels.fit_save",
+ "physical" => "ui.close",
+ "quality" => "render.stage_panels.use_budget",
+ _ => "render.stage_panels.apply",
+ })
+ .to_string();
+ let physical_notice = app.tr("render.physical_plan_only").to_string();
+ let review = ui_kit::ReviewAndApply {
+ title: &title,
+ name: &draft.name,
+ subtitle: &subtitle,
+ replaces: &replaces,
+ kept: &kept,
+ acknowledgement: &acknowledgement,
+ apply: &apply_label,
+ copy: draft.variant == "physical",
+ notice: (draft.variant == "physical").then_some(physical_notice.as_str()),
+ };
+ let (closed, answer) = review.show(ctx, current, &mut draft.acknowledged, |ui| {
+ if !current {
+ ui_kit::text(ui, app.tr("render.review_stale"), ui_kit::Text::Error("review:stale"));
+ }
+ match draft.variant {
+ "rig" => {
+ let mut changed = false;
+ ui_kit::row(ui, app.tr("render.stage_panels.centre"), |ui| {
+ ui.horizontal(|ui| {
+ for (axis, coordinate) in draft.center.iter_mut().enumerate() {
+ let field = ui_kit::number_field(ui, coordinate, -1e12..=1e12, 1.0, " mm");
+ changed |= field.changed();
+ crate::scenario::publish_target(&format!("render:review:center:{axis}"), field.rect);
+ }
+ });
+ });
+ ui_kit::row(ui, app.tr("render.stage_panels.extent"), |ui| {
+ let field = ui_kit::number_field(ui, &mut draft.extent, 0.001..=1e6, 1.0, " mm");
+ changed |= field.changed();
+ crate::scenario::publish_target("render:review:extent", field.rect);
+ });
+ let bounds = ui_kit::checkbox(ui, app.tr("render.stage_panels.captured_bounds"), &mut draft.bounds);
+ crate::scenario::publish_target("render:review:bounds", bounds.rect);
+ if bounds.changed() && draft.bounds {
+ let mut targets = View::default();
+ if let Err(error) = refresh_targets(app, &mut targets) {
+ app.set_status(error, true);
+ }
+ draft.center = targets.center;
+ draft.extent = targets.extent;
+ }
+ if changed {
+ draft.bounds = false;
+ }
+ let omit = ui_kit::checkbox(ui, app.tr("render.library_emitters_only_ack"), &mut draft.emitters_only);
+ crate::scenario::publish_target("render:review:emitters-only", omit.rect);
+ }
+ "quality" => {
+ ui_kit::text(ui, app.tr("render.quality_projection_help"), ui_kit::Text::Note("review:quality"));
+ ui_kit::row(ui, app.tr("render.stage_panels.projects"), |ui| {
+ ui_kit::text(
+ ui,
+ &format!(
+ "{} × {} · {} spp · {} {}",
+ draft.plan["settings"]["width"],
+ draft.plan["settings"]["height"],
+ draft.plan["gpu_options"]["samples"],
+ app.tr("render.stage_panels.depth"),
+ draft.plan["gpu_options"]["max_depth"]
+ ),
+ ui_kit::Text::Inline,
+ );
+ });
+ ui_kit::text(ui, app.tr("render.stage_panels.omits"), ui_kit::Text::Note("review:omits"));
+ ui_kit::text(ui, app.tr("render.stage_panels.quality_omissions"), ui_kit::Text::Note("review:omissions"));
+ }
+ "physical" => {
+ ui_kit::row(ui, app.tr("render.stage_panels.reference"), |ui| {
+ ui_kit::text(ui, &draft.name, ui_kit::Text::Inline);
+ });
+ let count = draft.plan["extended_profile"]["properties"].as_array().map_or(0, Vec::len);
+ let candidates = crate::i18n::format("render.stage_panels.candidate_summary", &[("count", &count.to_string())]);
+ ui_kit::text(ui, &candidates, ui_kit::Text::Note("review:candidates"));
+ ui_kit::text(ui, app.tr("render.stage_panels.partial_reference"), ui_kit::Text::Note("review:partial"));
+ }
+ _ => {}
+ }
+ });
+ if answer == ui_kit::Action::Apply
+ && let Apply::Physical(plan) = &draft.action
+ {
+ ctx.copy_text(serde_json::to_string_pretty(plan).unwrap_or_default());
+ }
+ if answer == ui_kit::Action::Ok {
+ if let Err(error) = apply(app, &mut draft) {
+ app.set_status(error, true);
+ draft.acknowledged = false;
+ app.render_workspace.view.library.review = Some(draft);
+ }
+ } else if !closed && answer != ui_kit::Action::Cancel {
+ app.render_workspace.view.library.review = Some(draft);
+ }
+}
+
+#[derive(Clone, Debug)]
+pub(in crate::render_workspace) struct Removal {
+ command: String,
+ params: Value,
+ revision: u64,
+ document: Weak<Document>,
+}
+pub(in crate::render_workspace) fn remove(app: &mut SolveApp, command: &str, params: Value) {
+ app.render_workspace.view.library.removal =
+ Some(Removal { command: command.into(), params, revision: app.session.revision, document: Arc::downgrade(&app.session.doc) });
+}
+pub(in crate::render_workspace) fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
+ let Some(pending) = app.render_workspace.view.library.removal.take() else { return };
+ if pending.revision != app.session.revision || !Weak::ptr_eq(&pending.document, &Arc::downgrade(&app.session.doc)) {
+ return;
+ }
+ let stage = pending.command == "render.stage.clear";
+ let title = app.tr(if stage { "render.stage_panels.remove_stage_title" } else { "render.stage_panels.remove_optics_title" }).to_string();
+ let message = app.tr(if stage { "render.stage_panels.remove_stage_help" } else { "render.stage_panels.remove_optics_help" }).to_string();
+ let label = app.tr(if stage { "render.stage_panels.remove_stage" } else { "render.stage_panels.remove_optics" }).to_string();
+ let (closed, answer) = ui_kit::Confirm::new(egui::Id::new("render_resource_removal"), "delete", &title)
+ .tone(ui_kit::Tone::Danger)
+ .actions(&label, app.tr("render.stage_panels.keep"), None)
+ .show(ctx, true, |ui| {
+ ui_kit::text(ui, &message, ui_kit::Text::Note("remove:message"));
+ });
+ if answer == ui_kit::Action::Ok {
+ match app.run(&pending.command, pending.params) {
+ Ok(_) => setups::load(app),
+ Err(error) => app.set_status(error, true),
+ }
+ } else if !closed && answer != ui_kit::Action::Cancel {
+ app.render_workspace.view.library.removal = Some(pending);
+ }
+}
diff --git a/crates/ui-egui/src/render_workspace_ribbon.rs b/crates/ui-egui/src/render_workspace_ribbon.rs
index 1e9bc3eff3..8c2bc09309 100644
--- a/crates/ui-egui/src/render_workspace_ribbon.rs
+++ b/crates/ui-egui/src/render_workspace_ribbon.rs
@@ -255,7 +255,10 @@ fn navigate(app: &mut SolveApp, id: &str) -> Result<(), String> {
"render.settings.apply" => inspector::restore_camera(app)?,
"render.camera.fit" => inspector::fit_subject(app)?,
"render.camera.get" | "render.camera.set" => focus(app, Page::Camera, None),
- "render.quality.prepare" => focus(app, Page::Output, Some("quality")),
+ "render.quality.prepare" => {
+ focus(app, Page::Output, Some("quality"));
+ library::review_selected_quality(app)?;
+ }
"render.status" | "render.backends" => focus(app, Page::Diagnostics, None),
_ => return Err(crate::i18n::tr("render.error_interactive_command").into()),
}
diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs
index 131b90de66..fda7245079 100644
--- a/crates/ui-egui/src/ui_kit/gallery.rs
+++ b/crates/ui-egui/src/ui_kit/gallery.rs
@@ -279,6 +279,41 @@ const ELEMENTS: &[Element] = &[
Segments { disabled_reasons: &[Some("waiting for the quality contract"), None], ..Default::default() },
);
}),
+ element!("review_and_apply", |ui, state| {
+ ReviewAndApply {
+ title: "Review native studio",
+ name: "Soft enveloping studio",
+ subtitle: "Native studio · whole scene",
+ replaces: "Lighting, environment, exposure and stage",
+ kept: "Camera, sampling, dimensions, optical bindings and geometry",
+ acknowledgement: "Confirm replacing saved state",
+ apply: "Apply studio",
+ copy: false,
+ notice: None,
+ }
+ .content(ui, &mut state.checked, |_| {});
+ }),
+ element!("catalog_footer_height", |ui, _| {
+ let expected = catalog_footer_height(ui);
+ catalog_footer(ui, "Click to apply to the selection.");
+ assert_eq!(crate::scenario::rect_of("catalog:footer").unwrap().height(), expected);
+ }),
+ element!("catalog_footer_with_tip", |ui, _| {
+ catalog_footer_with_tip(ui, "Click to apply to the selection.", "Paint and drag assignment are not supported yet.");
+ }),
+ element!("catalog_layout", |ui, _| {
+ ui.allocate_ui(egui::vec2(ui.available_width(), 300.0), |ui| {
+ let layout = CatalogLayout::new(ui, "gallery:catalog", 3);
+ layout.body(ui, |ui| {
+ for index in 0..12 {
+ MenuItem::new("catalog_item", &format!("Surface {index}"), "grid").search_row(ui, "", "Authored map", None);
+ }
+ });
+ layout.footer(ui, |ui| {
+ catalog_footer(ui, "Select a surface to review.");
+ });
+ });
+ }),
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 {
@@ -288,6 +323,7 @@ const ELEMENTS: &[Element] = &[
selected: id.ends_with('b'),
users: 1,
tip: "Satin",
+ badge: None,
});
sphere_grid(ui, &tiles);
}),
@@ -299,6 +335,7 @@ const ELEMENTS: &[Element] = &[
selected: true,
users: 3,
tip: "Satin metal",
+ badge: Some("Library"),
}
.show(ui);
}),
diff --git a/crates/ui-egui/src/ui_kit/layout.rs b/crates/ui-egui/src/ui_kit/layout.rs
index ece263b3b2..ebdd89cfa0 100644
--- a/crates/ui-egui/src/ui_kit/layout.rs
+++ b/crates/ui-egui/src/ui_kit/layout.rs
@@ -57,22 +57,90 @@ pub(super) fn in_catalog(ui: &Ui) -> bool {
ui.stack().iter().any(|node| node.tags().contains("sc_catalog"))
}
-/// Quiet full-width library footer with the shared information glyph.
-pub(crate) fn catalog_footer(ui: &mut Ui, text: &str) {
+/// One-line library footer with the shared information glyph.
+pub(crate) fn catalog_footer_height(ui: &Ui) -> f32 {
let t = Tokens::get();
- let (rect, _) = ui.allocate_exact_size(vec2(ui.available_width(), t.control_height), egui::Sense::hover());
+ let line = ui.fonts_mut(|fonts| fonts.row_height(&egui::FontId::proportional(t.font_small)));
+ (line + t.space_16).max(t.control_height)
+}
+
+/// Single-line catalog note. Attach further guidance to the returned response.
+pub(crate) fn catalog_footer(ui: &mut Ui, text: &str) -> Response {
+ let t = Tokens::get();
+ let (rect, response) = ui.allocate_exact_size(vec2(ui.available_width(), catalog_footer_height(ui)), egui::Sense::hover());
t.secondary_hline(ui.painter(), rect.x_range(), rect.top(), t.dialog_rule);
- let icon = egui::Rect::from_center_size(egui::pos2(rect.left() + t.space_6, rect.center().y), vec2(t.space_12, t.space_12));
+ let icon =
+ egui::Rect::from_center_size(egui::pos2(rect.left() + t.space_6, rect.top() + t.space_8 + t.font_small * 0.5), vec2(t.space_12, t.space_12));
ui.painter().circle_stroke(icon.center(), t.space_4, t.control_border_stroke(t.form_dim));
ui.painter().text(icon.center(), egui::Align2::CENTER_CENTER, "i", crate::fonts::semibold(t.font_badge), t.form_dim);
- paint_text(
- ui,
- egui::Rect::from_min_max(egui::pos2(icon.right() + t.space_6, rect.top()), rect.max),
- text,
- egui::FontId::proportional(t.font_small),
- t.form_dim,
- false,
- );
+ let mut job =
+ egui::text::LayoutJob::simple(text.to_owned(), egui::FontId::proportional(t.font_small), t.form_dim, (rect.width() - t.space_24).max(1.0));
+ job.wrap.max_rows = 1;
+ let galley = ui.painter().layout_job(job);
+ ui.painter().galley(rect.left_top() + vec2(t.space_24, t.space_8), galley, t.form_dim);
+ response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Label, ui.is_enabled(), text));
+ crate::scenario::publish_rect("catalog:footer", rect);
+ response
+}
+
+/// A short note with further guidance on its information icon and text.
+pub(crate) fn catalog_footer_with_tip(ui: &mut Ui, text: &str, tip: &str) {
+ catalog_footer(ui, text).on_hover_text(tip);
+}
+
+/// A filling catalog body above a measured, bottom-anchored footer. Long detail
+/// cards scroll independently so the body retains its requested minimum height.
+pub(crate) struct CatalogLayout {
+ id: egui::Id,
+ key: String,
+ bounds: egui::Rect,
+ footer_height: f32,
+ min_body_height: f32,
+}
+
+impl CatalogLayout {
+ pub(crate) fn new(ui: &Ui, id: &str, min_rows: usize) -> Self {
+ let key = id.to_owned();
+ let id = ui.make_persistent_id(id);
+ let t = Tokens::get();
+ let min_body_height = min_rows as f32 * (t.control_height + t.space_10) + min_rows.saturating_sub(1) as f32 * ui.spacing().item_spacing.y;
+ Self {
+ id,
+ key,
+ bounds: ui.available_rect_before_wrap(),
+ footer_height: ui.data(|data| data.get_temp::<f32>(id)).unwrap_or(0.0),
+ min_body_height,
+ }
+ }
+
+ pub(crate) fn body<R>(&self, ui: &mut Ui, add: impl FnOnce(&mut Ui) -> R) -> R {
+ let gap = ui.spacing().item_spacing.y;
+ let height = (ui.available_height() - self.footer_height - gap).max(self.min_body_height).min(ui.available_height()).max(0.0);
+ let scroll = egui::ScrollArea::vertical()
+ .id_salt(self.id.with("body"))
+ .max_height(height)
+ .min_scrolled_height(0.0)
+ .auto_shrink([false, false])
+ .show(ui, add);
+ scenario::publish_rect(&format!("{}:body", self.key), scroll.inner_rect);
+ scroll.inner
+ }
+
+ pub(crate) fn footer(&self, ui: &mut Ui, add: impl FnOnce(&mut Ui)) {
+ let scroll = egui::ScrollArea::vertical()
+ .id_salt(self.id.with("footer"))
+ .max_height(ui.available_height().max(0.0))
+ .min_scrolled_height(0.0)
+ .auto_shrink([false, true])
+ .show(ui, add);
+ let height = scroll.content_size.y;
+ ui.data_mut(|data| data.insert_temp(self.id, height));
+ if (height - self.footer_height).abs() > 0.5 {
+ ui.ctx().request_discard("catalog footer measurement changed");
+ }
+ scenario::publish_rect(&format!("{}:content", self.key), self.bounds);
+ scenario::publish_rect(&format!("{}:footer", self.key), scroll.inner_rect);
+ }
}
/// Read the enclosing row accessibility label. Tokens: `none`.
diff --git a/crates/ui-egui/src/ui_kit/mod.rs b/crates/ui-egui/src/ui_kit/mod.rs
index f930058996..8b4c04773f 100644
--- a/crates/ui-egui/src/ui_kit/mod.rs
+++ b/crates/ui-egui/src/ui_kit/mod.rs
@@ -32,6 +32,7 @@ mod preferences_navigation;
mod preferences_small;
mod radial;
mod reports;
+mod review;
mod search;
mod shortcuts;
mod sphere;
@@ -77,6 +78,7 @@ pub(crate) use preferences_navigation::*;
pub(crate) use preferences_small::*;
pub(crate) use radial::{RADIAL_RADIUS, radial_menu};
pub(crate) use reports::*;
+pub(crate) use review::ReviewAndApply;
pub(crate) use search::{CommandSearch, SearchBadge, SearchFieldGeometry};
pub(crate) use shortcuts::*;
#[cfg(test)]
diff --git a/crates/ui-egui/src/ui_kit/review.rs b/crates/ui-egui/src/ui_kit/review.rs
new file mode 100644
index 0000000000..03ee38b2cc
--- /dev/null
+++ b/crates/ui-egui/src/ui_kit/review.rs
@@ -0,0 +1,66 @@
+//! Shared review composition for operations that replace saved rendering state.
+use super::{Action, Confirm, Sphere, Text, checkbox, list_frame, sphere_thumbnail, text};
+use crate::i18n::tr;
+
+/// Content varies; the card, impact rows, acknowledgement and modal actions do not.
+pub(crate) struct ReviewAndApply<'a> {
+ pub title: &'a str,
+ pub name: &'a str,
+ pub subtitle: &'a str,
+ pub replaces: &'a str,
+ pub kept: &'a str,
+ pub acknowledgement: &'a str,
+ pub apply: &'a str,
+ pub copy: bool,
+ pub notice: Option<&'a str>,
+}
+
+impl ReviewAndApply<'_> {
+ pub(crate) fn show(&self, ctx: &egui::Context, valid: bool, acknowledged: &mut bool, content: impl FnOnce(&mut egui::Ui)) -> (bool, Action) {
+ Confirm::new(egui::Id::new("render_review_apply"), "inspect", self.title)
+ .actions(self.apply, tr("ui.cancel"), self.copy.then(|| tr("render.physical_copy_plan")))
+ .secondary_left()
+ .show(ctx, valid && *acknowledged, |ui| self.content(ui, acknowledged, content))
+ }
+
+ pub(crate) fn content(&self, ui: &mut egui::Ui, acknowledged: &mut bool, content: impl FnOnce(&mut egui::Ui)) {
+ list_frame(ui, "review:card", |ui| {
+ ui.horizontal(|ui| {
+ sphere_thumbnail(
+ ui,
+ "review:sphere",
+ Sphere { color: crate::theme::Tokens::get().body, kind: super::FinishKind::Satin, opacity: None },
+ 40.0,
+ );
+ ui.vertical(|ui| {
+ text(ui, self.name, Text::Heading("review:name"));
+ text(ui, self.subtitle, Text::Note("review:subtitle"));
+ });
+ });
+ });
+ if let Some(notice) = self.notice {
+ let t = crate::theme::Tokens::get();
+ egui::Frame::NONE.fill(t.accent_soft).corner_radius(t.control_radius).inner_margin(egui::Margin::same(t.space_8 as i8)).show(ui, |ui| {
+ text(ui, notice, Text::Note("review:physical"));
+ });
+ }
+ content(ui);
+ for (label, value, key) in
+ [(tr("render.stage_panels.replaces"), self.replaces, "review:replaces"), (tr("render.stage_panels.kept"), self.kept, "review:kept")]
+ {
+ // Impact text wraps independently of ordinary one-line form rows.
+ ui.horizontal_top(|ui| {
+ ui.vertical(|ui| {
+ ui.set_width(crate::theme::Tokens::get().space_16 * 4.0);
+ text(ui, label, Text::Inline);
+ });
+ ui.vertical(|ui| {
+ ui.set_width(ui.available_width());
+ text(ui, value, Text::Note(key));
+ });
+ });
+ }
+ let ack = checkbox(ui, self.acknowledgement, acknowledged);
+ crate::scenario::publish_target("render:review:acknowledge", ack.rect);
+ }
+}
diff --git a/crates/ui-egui/src/ui_kit/sphere.rs b/crates/ui-egui/src/ui_kit/sphere.rs
index 29cfbd37af..ae50ce2d31 100644
--- a/crates/ui-egui/src/ui_kit/sphere.rs
+++ b/crates/ui-egui/src/ui_kit/sphere.rs
@@ -236,7 +236,7 @@ pub(crate) fn sphere_preview_with_source<R>(
})
}
-/// A catalog sample: 48 pt sphere in a 56 pt cell, two-line caption and optional
+/// A catalog sample: a token-sized sphere, two-line caption and optional
/// usage badge. The surrounding chrome follows the active workspace accent.
pub(crate) struct SphereTile<'a> {
pub id: &'a str,
@@ -245,43 +245,54 @@ pub(crate) struct SphereTile<'a> {
pub selected: bool,
pub users: usize,
pub tip: &'a str,
+ pub badge: Option<&'a str>,
}
impl SphereTile<'_> {
pub(crate) fn show(&self, ui: &mut Ui) -> Response {
let t = Tokens::get();
let accent = crate::theme::TabAccent::current(ui.ctx());
- let side = t.control_height * 2.0;
- let height = side + t.space_3 + t.font_small * 2.5 + t.space_4;
+ let side = t.control_height + t.space_6;
+ let line_height = ui.fonts_mut(|fonts| fonts.row_height(&crate::fonts::semibold(t.font_small)));
+ let height = t.space_16 + side + t.space_6 + line_height * 2.0 + t.space_3;
let (rect, _) = ui.allocate_exact_size(vec2(ui.available_width(), height), Sense::hover());
let response = ui.interact(rect, ui.make_persistent_id(self.id), Sense::click());
- let cell = Rect::from_min_size(pos2(rect.center().x - side / 2.0, rect.top() + t.space_4), vec2(side, side));
+ let cell = rect;
ui.painter().rect_filled(cell, t.radius_xl, t.control_fill);
ui.painter().rect_stroke(cell, t.radius_xl, t.control_border_stroke(t.dialog_rule), egui::StrokeKind::Inside);
if self.selected || response.hovered() || response.has_focus() {
- ui.painter().rect_stroke(cell.expand(t.space_2), t.radius_xl, egui::Stroke::new(t.space_2, accent.ink), egui::StrokeKind::Outside);
+ ui.painter().rect_stroke(cell, t.radius_xl, egui::Stroke::new(t.space_2, accent.ink), egui::StrokeKind::Inside);
+ }
+ let preview = Rect::from_min_size(pos2(rect.center().x - side / 2.0, rect.top() + t.space_16), vec2(side, side));
+ paint_sphere(ui, preview, self.sphere);
+ if let Some(badge) = self.badge {
+ ui.painter().text(
+ cell.left_top() + vec2(t.space_4, t.space_4),
+ egui::Align2::LEFT_TOP,
+ badge,
+ crate::fonts::semibold(t.font_badge),
+ t.form_dim,
+ );
}
- paint_sphere(ui, cell.shrink(t.space_4), self.sphere);
if self.users > 0 {
let text = if self.users > 99 { "99+".into() } else { self.users.to_string() };
let galley = ui.painter().layout_no_wrap(text, crate::fonts::semibold(t.font_badge), t.on_accent);
let width = (galley.size().x + t.space_8).max(t.space_16);
- let badge = Rect::from_min_size(pos2(cell.right() + t.space_2 - width, cell.top() - t.space_2), vec2(width, t.space_16));
+ let badge = Rect::from_min_size(pos2(cell.right() - t.space_4 - width, cell.top() + t.space_2), vec2(width, t.space_16));
ui.painter().rect_filled(badge, t.radius_lg, accent.ink);
ui.painter().galley(badge.center() - galley.size() / 2.0, galley, t.on_accent);
}
- let label = Rect::from_min_max(pos2(rect.left(), cell.bottom() + t.space_3), rect.max);
+ let label = Rect::from_min_max(pos2(rect.left() + t.space_3, preview.bottom() + t.space_6), rect.max - vec2(t.space_3, t.space_3));
let font = if self.selected { crate::fonts::semibold(t.font_small) } else { egui::FontId::proportional(t.font_small) };
let mut job = egui::text::LayoutJob::simple(self.name.to_owned(), font, t.form_ink, label.width());
job.halign = egui::Align::Center;
job.wrap.max_rows = 2;
job.wrap.break_anywhere = false;
let galley = ui.painter().layout_job(job);
- ui.painter().with_clip_rect(ui.clip_rect().intersect(label)).galley(
- pos2(label.center().x - galley.rect.center().x, label.top() - galley.rect.top()),
- galley,
- t.form_ink,
- );
+ let label_pos = pos2(label.center().x - galley.rect.center().x, label.top() - galley.rect.top());
+ scenario::publish_rect(&format!("{}:label", self.id), label);
+ scenario::publish_rect(&format!("{}:galley", self.id), galley.rect.translate(label_pos.to_vec2()));
+ ui.painter().with_clip_rect(ui.clip_rect().intersect(label)).galley(label_pos, galley, t.form_ink);
response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Button, ui.is_enabled(), self.selected, self.name));
scenario::publish_target(self.id, rect);
let mut tip = egui::Tooltip::for_enabled(&response);
@@ -297,7 +308,7 @@ impl SphereTile<'_> {
pub(crate) fn sphere_grid(ui: &mut Ui, tiles: &[SphereTile<'_>]) -> Option<usize> {
let t = Tokens::get();
let mut clicked = None;
- ui.spacing_mut().item_spacing = vec2(t.space_2, t.space_8);
+ ui.spacing_mut().item_spacing = vec2(t.space_8, t.space_8);
for (row, chunk) in tiles.chunks(3).enumerate() {
ui.columns(3, |columns| {
for (column, tile) in chunk.iter().enumerate() {
diff --git a/crates/ui-egui/src/ui_kit/sphere_tests.rs b/crates/ui-egui/src/ui_kit/sphere_tests.rs
index b1e673867e..2b70f52dbd 100644
--- a/crates/ui-egui/src/ui_kit/sphere_tests.rs
+++ b/crates/ui-egui/src/ui_kit/sphere_tests.rs
@@ -73,13 +73,19 @@ fn tiles_keep_three_columns_cell_sphere_badge_and_selection_in_both_themes() {
|ui| {
ui.set_width(240.0);
super::super::scope(ui, |ui| {
- let tiles = ["a", "b", "c"].map(|id| SphereTile {
+ let tiles = [
+ ("a", "Aluminum - Anodized"),
+ ("b", "Stainless Steel - Polished"),
+ ("c", "Neutral product studio with a very long descriptive label"),
+ ]
+ .map(|(id, name)| SphereTile {
id,
- name: "Satin",
+ name,
sphere: Sphere { color: t.render_accent, kind: FinishKind::Satin, opacity: None },
selected: id == "b",
users: usize::from(id == "a"),
tip: "Hover details",
+ badge: Some("native"),
});
assert!(sphere_grid(ui, &tiles).is_none());
});
@@ -104,8 +110,20 @@ fn tiles_keep_three_columns_cell_sphere_badge_and_selection_in_both_themes() {
}
assert_eq!(output.shapes.iter().map(|shape| meshes(&shape.shape)).sum::<usize>(), 3);
let accent = crate::theme::TabAccent::current(&ctx);
- assert!(output.shapes.iter().any(|shape| matches!(&shape.shape,egui::Shape::Rect(r) if r.stroke.color==accent.ink && r.rect.width()==60.0)));
- assert!(output.shapes.iter().any(|shape| matches!(&shape.shape,egui::Shape::Rect(r) if r.rect.size()==vec2(56.0,56.0))));
+ assert!(
+ output.shapes.iter().any(|shape| matches!(&shape.shape,egui::Shape::Rect(r) if r.stroke.color==accent.ink && r.rect.width()==b.width()))
+ );
+ for id in ["a", "b", "c"] {
+ let tile = crate::scenario::rect_of(id).unwrap();
+ let label = crate::scenario::rect_of(&format!("{id}:label")).unwrap();
+ let galley = crate::scenario::rect_of(&format!("{id}:galley")).unwrap();
+ assert!(tile.contains_rect(label) && label.expand(0.1).contains_rect(galley));
+ }
+ let long_caption = crate::test_support::text_shapes(&output).find(|text| text.galley.job.text.starts_with("Neutral product")).unwrap();
+ assert_eq!(long_caption.galley.rows.len(), 2);
+ assert!(long_caption.galley.elided);
+ assert_eq!(long_caption.galley.job.wrap.overflow_character, Some('…'));
+ assert!(output.shapes.iter().any(|shape| matches!(&shape.shape,egui::Shape::Text(text) if text.galley.job.text=="native")));
}
}
diff --git a/docs/render-workspace.md b/docs/render-workspace.md
index d35126e07f..1933ff8c86 100644
--- a/docs/render-workspace.md
+++ b/docs/render-workspace.md
@@ -47,14 +47,37 @@ sphere grid or list. Resources used in the design or matching a selected look's
finish family or category appear first. Clicking a look applies through
`appearance.assign` to selected bodies, faces or components; with no target it
only inspects. Favorites and recent history live in user preferences. Explicit
-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 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.
+catalog navigation opens the corresponding stage library.
+
+Look also offers **Surfaces and references**. Surfaces/References segments and search
+lead to authored surface rows with availability badges. Selecting a surface loads
+its bounded source-map preview; Target, Plane and Repeat precede Use uniform,
+Use GPU maps and Save maps. GPU actions remain faded with a reason on other methods.
+Physical profiles retain their properties and sources; Prepare creation plan opens
+a read-only review with acknowledgement and Copy plan. It creates no material.
+
+Light hosts **Studios and environments**: a Scope dropdown, search and three-column
+tiles for Studios, Rigs, Environments and read-only Specifications. Mine remains
+visible with the reason that personal studio saving is unavailable. Clicking selects;
+Apply prepares a review without changing the method or saved settings.
+
+The shared `ui_kit::ReviewAndApply` dialog presents a resource card, Replaces/Kept,
+variant controls and explicit acknowledgement before applying. Studio, rig fit,
+environment, ground/stage, physical plan, fixed quality budget and uniform/spatial
+maps use this composition. A captured review expires when the document, revision,
+shot, method or settings change. Rig fitting offers centre, extent, captured bounds
+and emitters-only projection. Quality review reports projected dimensions, samples,
+depth and omissions; `render.quality.prepare` remains reachable through command
+activation. S5 can call `render_workspace::review_resource(app,
+"render.quality.prepare", id)` for its selected specification.
+Programmatic commands continue to execute without opening dialogs.
+
+Remove shot uses the existing shared `Confirm`; remove stage and saved optics now
+also use it. Resource removal confirmations expire after a document revision change.
+
+Confirmed reviews run `render.preset.apply`, `render.library.studio.apply` or
+`render.library.environment.apply`, preserving validation and undo. Studios require an explicitly selected
+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`
diff --git a/docs/ui-kit.md b/docs/ui-kit.md
index 6aa7076f6f..c442755d3d 100644
--- a/docs/ui-kit.md
+++ b/docs/ui-kit.md
@@ -28,6 +28,13 @@ rules. Its compass is 110 pt; the 48 pt Shots strip clears the docks by 8 pt.
## Composition and rules
+| Component | Contract |
+| --- | --- |
+| `ReviewAndApply` | Shared resource card, wrapping Replaces/Kept rows, variant content, acknowledgement, Cancel and a gated apply action. Physical plans offer Copy plan. Composes `Confirm`. Gallery: `review_and_apply`. |
+| `SphereTile::badge` | Optional availability text on a three-column library tile, alongside the user-count badge. Uses theme tokens. |
+| `catalog_footer`, `catalog_footer_with_tip`, `catalog_footer_height` | One-line information note with ellipsis and full guidance on hover; optional separate tooltip text. |
+| `CatalogLayout` | Fills the remaining panel height with a scroll body above a measured bottom footer. Optional minimum search-row count keeps lists usable while a long detail card scrolls independently. |
+
- Every outer host uses `ui_kit::Container` with a semantic `Surface`. The shell
publishes the layout once per frame; `Container::floating()` and `frame()` own
adaptive placement policy and chrome. `Panel`, `Window`, `Confirm` and `Menu`
@@ -160,7 +167,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera
| `list_picker` | Selectable row with caller identity and native checked state | `control_height`, form selection tokens |
| `thumbnail_choice`, `ThumbnailChoice`, `add_choice` | Shared selection-chip variant with 52 × 30 preview, selected tab accent, modified dot, progress ring and dashed add action for bottom strips; `Panel::strip_contents` reserves right actions and scrolls choices | `control_height`, spacing, radii, `TabAccent`, control/semantic tokens |
| `popup_list`, `PopupOption` | Focus-neutral suggestions; owner retains keyboard routing | `space_2`, `form_label_width`, `control_height`, form tokens |
-| sphere: `sphere_thumbnail`, `SphereTile`, `sphere_grid`, `sphere_preview` | Deterministic lit material samples; matte/satin/gloss/metal/glass finishes. Catalog tiles centre a 48 pt sphere in a 56 pt rounded cell with a two-line name, active-tab selection ring, user-count badge and shared Container tooltip. The grid owns three columns and token gaps. The Inspector preview composes a sphere, name, informational chips and replacement action in the shared list card. | `control_height`, `radius_xl`, `space_2/3/4/8/16`, `font_small/badge`, `control_fill`, `dialog_rule`, active-tab accent, `on_accent` |
+| sphere: `sphere_thumbnail`, `SphereTile`, `sphere_grid`, `sphere_preview`, `sphere_preview_with_source` | Deterministic lit material samples; matte/satin/gloss/metal/glass finishes. Catalog tiles centre a token-sized sphere above two full lines of text with an optional source badge, active-tab selection ring, user-count badge and shared Container tooltip. The grid owns three columns and token gaps. The Inspector preview composes a sphere, name, informational chips and replacement action in the shared list card; the source variant supports an interactive inheritance menu. | `control_height`, `radius_xl`, `space_2/3/4/6/8/16`, `font_small/badge`, `control_fill`, `dialog_rule`, active-tab accent, `on_accent` |
| `color_swatch`, `swatch_grid`, `color_thumbnail` | 30 pt draggable samples, 6 pt grid step gap, selected outer ring and checker pattern under transparent colours; caller payloads retained; local-library thumbnails use 16 pt | `control_height/radius`, `border`, `form_primary`, `control_fill`, `space_2/6/8` |
| `assistant_entry`, `AssistantEntryState` | Application-bar chat icon with quiet, ready, busy, auth, stopped and approval count marks; caller owns state and target | `app_bar`, `agent_ok/busy`, `warning/error`, `font_badge` |
| actions: `button`, `Button` | Secondary action: `Normal`, `Small`, or `Enabled(bool)` | native sizing, form font/control tokens |
@@ -721,6 +728,15 @@ For CPU-rendered review images, run
`catalog_scope` supplies compact catalog metrics to the shared search field, segments,
icon segments and category chips. `catalog_footer` draws the quiet information hint.
+`CatalogLayout::new(ui, id, min_rows)` reserves the measured footer height and gives
+`body` all remaining space without shrinking to its items. Call `footer` after
+`body`; changes to the footer's natural height request another layout pass.
+Use `min_rows = 3` for a search list with selected-item details below it; the
+detail card scrolls when necessary. The kit publishes `{id}:content`, `:body`
+and `:footer` rectangles for layout checks.
+`SphereTile` reserves two full font rows below the sphere. Names wrap at word
+boundaries with an ellipsis after the second line; `{id}:label` and `:galley`
+expose the caption allocation and laid-out text bounds.
Catalog title marks use the active workspace accent; tile captions, usage badges and
selection outlines share the sphere widgets. Feature code supplies data and commands,
while the kit owns every dimension, colour and inset.