diff --git a/assets/locales/pending/render-appearance-editor.json b/assets/locales/pending/render-appearance-editor.json new file mode 100644 index 000000000..0f1160122 --- /dev/null +++ b/assets/locales/pending/render-appearance-editor.json @@ -0,0 +1,330 @@ +{ + "en": { + "render.appearance_editor.glass": "Glass and absorption", + "render.appearance_editor.coat": "Clear coat", + "render.appearance_editor.maps": "Maps", + "render.appearance_editor.saved": "Saved with this shot", + "render.appearance_editor.reflections": "Reflections", + "render.appearance_editor.glass_enable": "Use physical glass on this body", + "render.appearance_editor.recipe": "Recipe", + "render.appearance_editor.boundary": "Boundary", + "render.appearance_editor.closed": "Closed solid", + "render.appearance_editor.thin": "Thin sheet", + "render.appearance_editor.box": "Box", + "render.appearance_editor.choose_image": "Choose image…", + "render.appearance_editor.temporary": "These optics are temporary on this tab. Save them to keep them with the shot.", + "render.appearance_editor.save": "Save these optics", + "render.appearance_editor.remove": "Remove saved", + "render.appearance_editor.replace": "Replace this body's saved optics", + "render.appearance_editor.revalidate": "Revalidate this body", + "render.appearance_editor.remove_title": "Remove saved optics?", + "render.appearance_editor.remove_note": "Remove the saved optics from this shot. Geometry and assigned looks are kept.", + "render.appearance_editor.gpu_reason": "Needs GPU path tracing.", + "render.appearance_editor.cpu_reason": "Needs CPU ray tracing.", + "render.appearance_editor.body_reason": "Optical bindings target one whole body. Pick Body to edit these controls.", + "render.appearance_editor.save_reason": "Saving these optics needs physical glass on a current GPU body. Coat and local image maps remain temporary.", + "render.appearance_editor.glass_note": "Closed glass uses geometric distance. It cannot share a body with clear coat or maps.", + "render.appearance_editor.thickness_reason": "Thickness applies to thin sheets; closed glass uses geometric distance.", + "render.appearance_editor.scatter_reason": "Interior scattering needs a closed solid boundary.", + "render.appearance_editor.ior": "IOR", + "render.appearance_editor.absorption": "Absorption", + "render.appearance_editor.thickness": "Thickness", + "render.appearance_editor.weight": "Weight", + "render.appearance_editor.base_colour": "Base colour", + "render.appearance_editor.normal": "Normal", + "render.appearance_editor.origin": "Origin", + "render.appearance_editor.u_repeat": "U repeat", + "render.appearance_editor.v_repeat": "V repeat", + "render.appearance_editor.normal_strength": "Normal strength", + "render.appearance_editor.v_up": "Texture V points upward", + "render.appearance_editor.saved_state": "These optics are saved with this shot.", + "render.appearance_editor.reflection_sampling": "Sampling for all reflective bodies" + }, + "de": { + "render.appearance_editor.glass": "Glas und Absorption", + "render.appearance_editor.coat": "Klarlack", + "render.appearance_editor.maps": "Texturen", + "render.appearance_editor.saved": "Mit dieser Aufnahme gespeichert", + "render.appearance_editor.reflections": "Reflexionen", + "render.appearance_editor.glass_enable": "Physikalisches Glas für diesen Körper verwenden", + "render.appearance_editor.recipe": "Rezept", + "render.appearance_editor.boundary": "Grenzfläche", + "render.appearance_editor.closed": "Geschlossener Körper", + "render.appearance_editor.thin": "Dünne Schicht", + "render.appearance_editor.box": "Quader", + "render.appearance_editor.choose_image": "Bild wählen…", + "render.appearance_editor.temporary": "Diese Optik gilt vorübergehend in diesem Tab. Speichern Sie sie mit der Aufnahme.", + "render.appearance_editor.save": "Diese Optik speichern", + "render.appearance_editor.remove": "Gespeicherte entfernen", + "render.appearance_editor.replace": "Gespeicherte Optik dieses Körpers ersetzen", + "render.appearance_editor.revalidate": "Diesen Körper erneut prüfen", + "render.appearance_editor.remove_title": "Gespeicherte Optik entfernen?", + "render.appearance_editor.remove_note": "Die gespeicherte Optik wird aus dieser Aufnahme entfernt. Geometrie und zugewiesene Looks bleiben erhalten.", + "render.appearance_editor.gpu_reason": "Benötigt GPU-Pfadverfolgung.", + "render.appearance_editor.cpu_reason": "Benötigt CPU-Strahlverfolgung.", + "render.appearance_editor.body_reason": "Optische Bindungen gelten für einen ganzen Körper. Wählen Sie Körper, um diese Einstellungen zu bearbeiten.", + "render.appearance_editor.save_reason": "Zum Speichern wird physikalisches Glas auf einem aktuellen GPU-Körper benötigt. Klarlack und lokale Bildtexturen bleiben vorübergehend.", + "render.appearance_editor.glass_note": "Geschlossenes Glas verwendet geometrische Abstände. Es kann nicht mit Klarlack oder Texturen auf demselben Körper kombiniert werden.", + "render.appearance_editor.thickness_reason": "Dicke gilt für dünne Schichten; geschlossenes Glas verwendet geometrische Abstände.", + "render.appearance_editor.scatter_reason": "Innere Streuung benötigt einen geschlossenen Körper.", + "render.appearance_editor.ior": "IOR", + "render.appearance_editor.absorption": "Absorption", + "render.appearance_editor.thickness": "Dicke", + "render.appearance_editor.weight": "Gewicht", + "render.appearance_editor.base_colour": "Grundfarbe", + "render.appearance_editor.normal": "Normale", + "render.appearance_editor.origin": "Ursprung", + "render.appearance_editor.u_repeat": "U-Wiederholung", + "render.appearance_editor.v_repeat": "V-Wiederholung", + "render.appearance_editor.normal_strength": "Normalenstärke", + "render.appearance_editor.v_up": "Textur-V zeigt nach oben", + "render.appearance_editor.saved_state": "Diese Optik ist mit dieser Aufnahme gespeichert.", + "render.appearance_editor.reflection_sampling": "Abtastung für alle reflektierenden Körper" + }, + "ja": { + "render.appearance_editor.glass": "ガラスと吸収", + "render.appearance_editor.coat": "クリアコート", + "render.appearance_editor.maps": "マップ", + "render.appearance_editor.saved": "このショットに保存", + "render.appearance_editor.reflections": "反射", + "render.appearance_editor.glass_enable": "このボディに物理ガラスを使用", + "render.appearance_editor.recipe": "レシピ", + "render.appearance_editor.boundary": "境界", + "render.appearance_editor.closed": "閉じたソリッド", + "render.appearance_editor.thin": "薄板", + "render.appearance_editor.box": "ボックス", + "render.appearance_editor.choose_image": "画像を選択…", + "render.appearance_editor.temporary": "この光学設定はこのタブで一時的に使用されます。ショットに保持するには保存してください。", + "render.appearance_editor.save": "この光学設定を保存", + "render.appearance_editor.remove": "保存済みを削除", + "render.appearance_editor.replace": "このボディの保存済み光学設定を置換", + "render.appearance_editor.revalidate": "このボディを再検証", + "render.appearance_editor.remove_title": "保存済み光学設定を削除しますか?", + "render.appearance_editor.remove_note": "このショットから保存済み光学設定を削除します。形状と割り当てた外観は保持されます。", + "render.appearance_editor.gpu_reason": "GPUパストレーシングが必要です。", + "render.appearance_editor.cpu_reason": "CPUレイトレーシングが必要です。", + "render.appearance_editor.body_reason": "光学設定はボディ全体に適用されます。編集するにはボディを選択してください。", + "render.appearance_editor.save_reason": "保存には現在のGPUボディの物理ガラスが必要です。コートとローカル画像マップは一時設定のままです。", + "render.appearance_editor.glass_note": "閉じたガラスは形状から距離を求めます。同じボディにクリアコートやマップを併用できません。", + "render.appearance_editor.thickness_reason": "厚さは薄板に適用されます。閉じたガラスは形状から距離を求めます。", + "render.appearance_editor.scatter_reason": "内部散乱には閉じたソリッド境界が必要です。", + "render.appearance_editor.ior": "IOR", + "render.appearance_editor.absorption": "吸収", + "render.appearance_editor.thickness": "厚さ", + "render.appearance_editor.weight": "重み", + "render.appearance_editor.base_colour": "ベースカラー", + "render.appearance_editor.normal": "法線", + "render.appearance_editor.origin": "原点", + "render.appearance_editor.u_repeat": "Uリピート", + "render.appearance_editor.v_repeat": "Vリピート", + "render.appearance_editor.normal_strength": "法線強度", + "render.appearance_editor.v_up": "テクスチャのVは上向き", + "render.appearance_editor.saved_state": "この光学設定はこのショットに保存されています。", + "render.appearance_editor.reflection_sampling": "すべての反射ボディのサンプリング" + }, + "zh": { + "render.appearance_editor.glass": "玻璃与吸收", + "render.appearance_editor.coat": "清漆涂层", + "render.appearance_editor.maps": "贴图", + "render.appearance_editor.saved": "随此镜头保存", + "render.appearance_editor.reflections": "反射", + "render.appearance_editor.glass_enable": "对此实体使用物理玻璃", + "render.appearance_editor.recipe": "配方", + "render.appearance_editor.boundary": "边界", + "render.appearance_editor.closed": "封闭实体", + "render.appearance_editor.thin": "薄片", + "render.appearance_editor.box": "长方体", + "render.appearance_editor.choose_image": "选择图像…", + "render.appearance_editor.temporary": "这些光学设置仅在此标签页临时生效。保存后可随镜头保留。", + "render.appearance_editor.save": "保存这些光学设置", + "render.appearance_editor.remove": "移除已保存设置", + "render.appearance_editor.replace": "替换此实体已保存的光学设置", + "render.appearance_editor.revalidate": "重新验证此实体", + "render.appearance_editor.remove_title": "移除已保存的光学设置?", + "render.appearance_editor.remove_note": "从此镜头中移除已保存的光学设置。几何形状和已分配的外观保持不变。", + "render.appearance_editor.gpu_reason": "需要 GPU 路径追踪。", + "render.appearance_editor.cpu_reason": "需要 CPU 光线追踪。", + "render.appearance_editor.body_reason": "光学绑定针对单个完整实体。选择实体后可编辑这些控件。", + "render.appearance_editor.save_reason": "保存需要当前 GPU 实体上的物理玻璃。清漆和本地图像贴图仍为临时设置。", + "render.appearance_editor.glass_note": "封闭玻璃使用几何距离。同一实体不能同时使用清漆或贴图。", + "render.appearance_editor.thickness_reason": "厚度适用于薄片;封闭玻璃使用几何距离。", + "render.appearance_editor.scatter_reason": "内部散射需要封闭实体边界。", + "render.appearance_editor.ior": "IOR", + "render.appearance_editor.absorption": "吸收", + "render.appearance_editor.thickness": "厚度", + "render.appearance_editor.weight": "权重", + "render.appearance_editor.base_colour": "基础颜色", + "render.appearance_editor.normal": "法线", + "render.appearance_editor.origin": "原点", + "render.appearance_editor.u_repeat": "U 重复", + "render.appearance_editor.v_repeat": "V 重复", + "render.appearance_editor.normal_strength": "法线强度", + "render.appearance_editor.v_up": "纹理 V 轴朝上", + "render.appearance_editor.saved_state": "这些光学设置已随此镜头保存。", + "render.appearance_editor.reflection_sampling": "所有反射实体的采样" + }, + "ko": { + "render.appearance_editor.glass": "유리와 흡수", + "render.appearance_editor.coat": "클리어 코트", + "render.appearance_editor.maps": "맵", + "render.appearance_editor.saved": "이 샷에 저장됨", + "render.appearance_editor.reflections": "반사", + "render.appearance_editor.glass_enable": "이 바디에 물리 유리 사용", + "render.appearance_editor.recipe": "레시피", + "render.appearance_editor.boundary": "경계", + "render.appearance_editor.closed": "닫힌 솔리드", + "render.appearance_editor.thin": "얇은 시트", + "render.appearance_editor.box": "상자", + "render.appearance_editor.choose_image": "이미지 선택…", + "render.appearance_editor.temporary": "이 광학 설정은 이 탭에서 임시로 사용됩니다. 샷과 함께 유지하려면 저장하세요.", + "render.appearance_editor.save": "이 광학 설정 저장", + "render.appearance_editor.remove": "저장된 설정 제거", + "render.appearance_editor.replace": "이 바디의 저장된 광학 설정 교체", + "render.appearance_editor.revalidate": "이 바디 다시 검증", + "render.appearance_editor.remove_title": "저장된 광학 설정을 제거할까요?", + "render.appearance_editor.remove_note": "이 샷에서 저장된 광학 설정을 제거합니다. 형상과 지정된 외관은 유지됩니다.", + "render.appearance_editor.gpu_reason": "GPU 경로 추적이 필요합니다.", + "render.appearance_editor.cpu_reason": "CPU 광선 추적이 필요합니다.", + "render.appearance_editor.body_reason": "광학 바인딩은 하나의 전체 바디를 대상으로 합니다. 편집하려면 바디를 선택하세요.", + "render.appearance_editor.save_reason": "저장하려면 현재 GPU 바디에 물리 유리가 필요합니다. 코트와 로컬 이미지 맵은 임시로 유지됩니다.", + "render.appearance_editor.glass_note": "닫힌 유리는 형상 거리를 사용합니다. 같은 바디에 클리어 코트나 맵을 함께 사용할 수 없습니다.", + "render.appearance_editor.thickness_reason": "두께는 얇은 시트에 적용됩니다. 닫힌 유리는 형상 거리를 사용합니다.", + "render.appearance_editor.scatter_reason": "내부 산란에는 닫힌 솔리드 경계가 필요합니다.", + "render.appearance_editor.ior": "IOR", + "render.appearance_editor.absorption": "흡수", + "render.appearance_editor.thickness": "두께", + "render.appearance_editor.weight": "가중치", + "render.appearance_editor.base_colour": "기본 색상", + "render.appearance_editor.normal": "노멀", + "render.appearance_editor.origin": "원점", + "render.appearance_editor.u_repeat": "U 반복", + "render.appearance_editor.v_repeat": "V 반복", + "render.appearance_editor.normal_strength": "노멀 강도", + "render.appearance_editor.v_up": "텍스처 V가 위쪽을 향함", + "render.appearance_editor.saved_state": "이 광학 설정은 이 샷과 함께 저장되어 있습니다.", + "render.appearance_editor.reflection_sampling": "모든 반사 바디의 샘플링" + }, + "ar": { + "render.appearance_editor.glass": "الزجاج والامتصاص", + "render.appearance_editor.coat": "طبقة شفافة", + "render.appearance_editor.maps": "الخرائط", + "render.appearance_editor.saved": "محفوظ مع هذه اللقطة", + "render.appearance_editor.reflections": "الانعكاسات", + "render.appearance_editor.glass_enable": "استخدم زجاجًا فيزيائيًا على هذا الجسم", + "render.appearance_editor.recipe": "الوصفة", + "render.appearance_editor.boundary": "الحدود", + "render.appearance_editor.closed": "جسم مصمت مغلق", + "render.appearance_editor.thin": "صفيحة رقيقة", + "render.appearance_editor.box": "مربع", + "render.appearance_editor.choose_image": "اختر صورة…", + "render.appearance_editor.temporary": "هذه الخصائص البصرية مؤقتة في هذا التبويب. احفظها لتبقى مع اللقطة.", + "render.appearance_editor.save": "حفظ هذه الخصائص البصرية", + "render.appearance_editor.remove": "إزالة المحفوظ", + "render.appearance_editor.replace": "استبدال الخصائص البصرية المحفوظة لهذا الجسم", + "render.appearance_editor.revalidate": "إعادة التحقق من هذا الجسم", + "render.appearance_editor.remove_title": "إزالة الخصائص البصرية المحفوظة؟", + "render.appearance_editor.remove_note": "أزل الخصائص البصرية المحفوظة من هذه اللقطة. تبقى الهندسة والمظاهر المعيّنة.", + "render.appearance_editor.gpu_reason": "يتطلب تتبّع المسار على بطاقة الرسومات.", + "render.appearance_editor.cpu_reason": "يتطلب تتبّع الأشعة على المعالج.", + "render.appearance_editor.body_reason": "الربط البصري يستهدف جسمًا كاملًا واحدًا. اختر «جسم» لتحرير هذه الضوابط.", + "render.appearance_editor.save_reason": "يتطلب حفظ هذه الخصائص البصرية زجاجًا فيزيائيًا على جسم حالي في بطاقة الرسومات. تبقى الطبقة الشفافة وخرائط الصور المحلية مؤقتة.", + "render.appearance_editor.glass_note": "يستخدم الزجاج المغلق المسافة الهندسية. لا يمكن أن يشارك جسمًا مع طبقة شفافة أو خرائط.", + "render.appearance_editor.thickness_reason": "السماكة تنطبق على الصفائح الرقيقة؛ الزجاج المغلق يستخدم المسافة الهندسية.", + "render.appearance_editor.scatter_reason": "التشتت الداخلي يتطلب حدًّا لجسم مصمت مغلق.", + "render.appearance_editor.ior": "معامل الانكسار", + "render.appearance_editor.absorption": "الامتصاص", + "render.appearance_editor.thickness": "السماكة", + "render.appearance_editor.weight": "الوزن", + "render.appearance_editor.base_colour": "اللون الأساسي", + "render.appearance_editor.normal": "العادي", + "render.appearance_editor.origin": "الأصل", + "render.appearance_editor.u_repeat": "تكرار U", + "render.appearance_editor.v_repeat": "تكرار V", + "render.appearance_editor.normal_strength": "قوة العادي", + "render.appearance_editor.v_up": "محور V للنسيج يشير للأعلى", + "render.appearance_editor.saved_state": "هذه الخصائص البصرية محفوظة مع هذه اللقطة.", + "render.appearance_editor.reflection_sampling": "أخذ العينات لكل الأجسام العاكسة" + }, + "he": { + "render.appearance_editor.glass": "זכוכית וספיגה", + "render.appearance_editor.coat": "ציפוי שקוף", + "render.appearance_editor.maps": "מפות", + "render.appearance_editor.saved": "נשמר עם הצילום הזה", + "render.appearance_editor.reflections": "השתקפויות", + "render.appearance_editor.glass_enable": "השתמש בזכוכית פיזיקלית בגוף זה", + "render.appearance_editor.recipe": "מתכון", + "render.appearance_editor.boundary": "גבול", + "render.appearance_editor.closed": "גוף מלא סגור", + "render.appearance_editor.thin": "יריעה דקה", + "render.appearance_editor.box": "תיבה", + "render.appearance_editor.choose_image": "בחר תמונה…", + "render.appearance_editor.temporary": "האופטיקה הזו זמנית בלשונית זו. שמור אותה כדי לשמור אותה עם הצילום.", + "render.appearance_editor.save": "שמור אופטיקה זו", + "render.appearance_editor.remove": "הסר את השמורה", + "render.appearance_editor.replace": "החלף את האופטיקה השמורה של גוף זה", + "render.appearance_editor.revalidate": "אמת מחדש גוף זה", + "render.appearance_editor.remove_title": "להסיר את האופטיקה השמורה?", + "render.appearance_editor.remove_note": "הסר את האופטיקה השמורה מהצילום הזה. הגאומטריה והמראות שהוקצו נשמרים.", + "render.appearance_editor.gpu_reason": "דורש מעקב נתיב ב-GPU.", + "render.appearance_editor.cpu_reason": "דורש מעקב קרניים במעבד.", + "render.appearance_editor.body_reason": "קישורים אופטיים מכוונים לגוף שלם אחד. בחר גוף כדי לערוך את הבקרות האלה.", + "render.appearance_editor.save_reason": "שמירת האופטיקה הזו דורשת זכוכית פיזיקלית בגוף GPU עדכני. הציפוי ומפות התמונה המקומיות נשארים זמניים.", + "render.appearance_editor.glass_note": "זכוכית סגורה משתמשת במרחק גאומטרי. אי אפשר לשלב אותה עם ציפוי שקוף או מפות באותו גוף.", + "render.appearance_editor.thickness_reason": "עובי חל על יריעות דקות; זכוכית סגורה משתמשת במרחק גאומטרי.", + "render.appearance_editor.scatter_reason": "פיזור פנימי דורש גבול של גוף מלא סגור.", + "render.appearance_editor.ior": "מקדם שבירה", + "render.appearance_editor.absorption": "ספיגה", + "render.appearance_editor.thickness": "עובי", + "render.appearance_editor.weight": "משקל", + "render.appearance_editor.base_colour": "צבע בסיס", + "render.appearance_editor.normal": "נורמל", + "render.appearance_editor.origin": "מקור", + "render.appearance_editor.u_repeat": "חזרת U", + "render.appearance_editor.v_repeat": "חזרת V", + "render.appearance_editor.normal_strength": "עוצמת נורמל", + "render.appearance_editor.v_up": "ציר V של הטקסטורה פונה כלפי מעלה", + "render.appearance_editor.saved_state": "האופטיקה הזו נשמרת עם הצילום הזה.", + "render.appearance_editor.reflection_sampling": "דגימה לכל הגופים המחזירים" + }, + "vi": { + "render.appearance_editor.glass": "Kính và hấp thụ", + "render.appearance_editor.coat": "Lớp phủ trong", + "render.appearance_editor.maps": "Bản đồ", + "render.appearance_editor.saved": "Lưu cùng cảnh chụp này", + "render.appearance_editor.reflections": "Phản xạ", + "render.appearance_editor.glass_enable": "Dùng kính vật lý trên thân này", + "render.appearance_editor.recipe": "Công thức", + "render.appearance_editor.boundary": "Biên", + "render.appearance_editor.closed": "Khối đặc kín", + "render.appearance_editor.thin": "Tấm mỏng", + "render.appearance_editor.box": "Hộp", + "render.appearance_editor.choose_image": "Chọn ảnh…", + "render.appearance_editor.temporary": "Các thuộc tính quang học này chỉ tạm thời trên tab này. Hãy lưu để giữ cùng cảnh chụp.", + "render.appearance_editor.save": "Lưu các thuộc tính quang học này", + "render.appearance_editor.remove": "Gỡ bản đã lưu", + "render.appearance_editor.replace": "Thay thuộc tính quang học đã lưu của thân này", + "render.appearance_editor.revalidate": "Kiểm tra lại thân này", + "render.appearance_editor.remove_title": "Gỡ thuộc tính quang học đã lưu?", + "render.appearance_editor.remove_note": "Gỡ thuộc tính quang học đã lưu khỏi cảnh chụp này. Hình học và diện mạo đã gán được giữ lại.", + "render.appearance_editor.gpu_reason": "Cần dò đường đi của tia bằng GPU.", + "render.appearance_editor.cpu_reason": "Cần dò tia bằng CPU.", + "render.appearance_editor.body_reason": "Liên kết quang học nhắm vào một thân hoàn chỉnh. Hãy chọn Thân để chỉnh các điều khiển này.", + "render.appearance_editor.save_reason": "Lưu các thuộc tính quang học này cần kính vật lý trên một thân GPU hiện hành. Lớp phủ và bản đồ ảnh cục bộ vẫn tạm thời.", + "render.appearance_editor.glass_note": "Kính kín dùng khoảng cách hình học. Không thể dùng chung thân với lớp phủ trong hoặc bản đồ.", + "render.appearance_editor.thickness_reason": "Độ dày áp dụng cho tấm mỏng; kính kín dùng khoảng cách hình học.", + "render.appearance_editor.scatter_reason": "Tán xạ bên trong cần biên là khối đặc kín.", + "render.appearance_editor.ior": "Chiết suất", + "render.appearance_editor.absorption": "Hấp thụ", + "render.appearance_editor.thickness": "Độ dày", + "render.appearance_editor.weight": "Trọng số", + "render.appearance_editor.base_colour": "Màu cơ bản", + "render.appearance_editor.normal": "Pháp tuyến", + "render.appearance_editor.origin": "Gốc", + "render.appearance_editor.u_repeat": "Lặp U", + "render.appearance_editor.v_repeat": "Lặp V", + "render.appearance_editor.normal_strength": "Cường độ pháp tuyến", + "render.appearance_editor.v_up": "Trục V của kết cấu hướng lên", + "render.appearance_editor.saved_state": "Các thuộc tính quang học này được lưu cùng cảnh chụp này.", + "render.appearance_editor.reflection_sampling": "Lấy mẫu cho mọi thân phản chiếu" + } +} diff --git a/assets/locales/pending/render-appearance-inspector-ui.json b/assets/locales/pending/render-appearance-inspector-ui.json new file mode 100644 index 000000000..d656415b9 --- /dev/null +++ b/assets/locales/pending/render-appearance-inspector-ui.json @@ -0,0 +1,272 @@ +{ + "en": { + "render.inspector_advanced": "Advanced", + "render.inspector_all_users": "All {count} users", + "render.inspector_applies_to": "Applies to", + "render.inspector_both_users": "Both users", + "render.inspector_chain": "Where this look comes from", + "render.inspector_colour": "Colour", + "render.inspector_edit": "Edit", + "render.inspector_finish": "Finish", + "render.inspector_from_material": "From Material", + "render.inspector_gloss": "Gloss", + "render.inspector_material": "Material", + "render.inspector_matte": "Matte", + "render.inspector_metal": "Metal", + "render.inspector_opacity": "Opacity", + "render.inspector_opaque_help": "Finish and optical fields use opaque PBR (opacity 1). Lower opacity uses scalar shading.", + "render.inspector_pick_target": "Pick a target of this type to inspect its appearance.", + "render.inspector_remove": "Remove override", + "render.inspector_replace": "Replace…", + "render.inspector_reset": "Reset", + "render.inspector_satin": "Satin", + "render.inspector_save_library": "Save to library…", + "render.inspector_set_all": "Mixed appearances. Editing sets the look on all selected targets.", + "render.inspector_soon": "Soon", + "render.inspector_target_limit": "Select at most 10000 targets to inspect appearances.", + "render.inspector_textures": "Textures", + "render.inspector_this_body": "This body", + "render.inspector_this_component": "This component", + "render.inspector_this_face": "This face", + "render.inspector_this_target": "This target", + "render.inspector_used_by": "Used by {count}", + "render.shell_tab_lighting": "LIGHTING", + "view.render_inspector": "Render Inspector" + }, + "de": { + "render.inspector_advanced": "Erweitert", + "render.inspector_all_users": "Alle {count} Nutzer", + "render.inspector_applies_to": "Anwenden auf", + "render.inspector_both_users": "Beide Nutzer", + "render.inspector_chain": "Herkunft dieses Aussehens", + "render.inspector_colour": "Farbe", + "render.inspector_edit": "Bearbeiten", + "render.inspector_finish": "Oberfläche", + "render.inspector_from_material": "Vom Material", + "render.inspector_gloss": "Glanz", + "render.inspector_material": "Material", + "render.inspector_matte": "Matt", + "render.inspector_metal": "Metall", + "render.inspector_opacity": "Deckkraft", + "render.inspector_opaque_help": "Oberfläche und optische Felder verwenden opakes PBR (Deckkraft 1). Geringere Deckkraft verwendet skalare Schattierung.", + "render.inspector_pick_target": "Ein Ziel dieses Typs wählen, um sein Aussehen zu prüfen.", + "render.inspector_remove": "Überschreibung entfernen", + "render.inspector_replace": "Ersetzen…", + "render.inspector_reset": "Zurücksetzen", + "render.inspector_satin": "Seidenmatt", + "render.inspector_save_library": "In Bibliothek speichern…", + "render.inspector_set_all": "Gemischtes Aussehen. Eine Bearbeitung weist das Aussehen allen gewählten Zielen zu.", + "render.inspector_soon": "Demnächst", + "render.inspector_target_limit": "Zum Prüfen des Aussehens höchstens 10000 Ziele auswählen.", + "render.inspector_textures": "Texturen", + "render.inspector_this_body": "Dieser Körper", + "render.inspector_this_component": "Diese Komponente", + "render.inspector_this_face": "Diese Fläche", + "render.inspector_this_target": "Dieses Ziel", + "render.inspector_used_by": "Verwendet von {count}", + "view.render_inspector": "Render-Inspektor" + }, + "ja": { + "render.inspector_advanced": "詳細", + "render.inspector_all_users": "すべての{count}箇所", + "render.inspector_applies_to": "適用先", + "render.inspector_both_users": "両方の使用先", + "render.inspector_chain": "外観の継承元", + "render.inspector_colour": "色", + "render.inspector_edit": "編集", + "render.inspector_finish": "仕上げ", + "render.inspector_from_material": "材料から継承", + "render.inspector_gloss": "光沢", + "render.inspector_material": "材料", + "render.inspector_matte": "つや消し", + "render.inspector_metal": "金属", + "render.inspector_opacity": "不透明度", + "render.inspector_opaque_help": "仕上げと光学特性には不透明PBR(不透明度1)を使用します。不透明度を下げるとスカラーシェーディングになります。", + "render.inspector_pick_target": "この種類の対象を選択して外観を確認します。", + "render.inspector_remove": "上書きを削除", + "render.inspector_replace": "置換…", + "render.inspector_reset": "リセット", + "render.inspector_satin": "半光沢", + "render.inspector_save_library": "ライブラリに保存…", + "render.inspector_set_all": "外観が混在しています。編集すると選択したすべての対象に外観を設定します。", + "render.inspector_soon": "近日公開", + "render.inspector_target_limit": "外観の確認対象は10000個以下にしてください。", + "render.inspector_textures": "テクスチャ", + "render.inspector_this_body": "このボディ", + "render.inspector_this_component": "このコンポーネント", + "render.inspector_this_face": "この面", + "render.inspector_this_target": "この対象", + "render.inspector_used_by": "使用箇所: {count}", + "render.shell_tab_lighting": "ライティング", + "view.render_inspector": "レンダーインスペクター" + }, + "zh": { + "render.inspector_advanced": "高级", + "render.inspector_all_users": "全部 {count} 个使用者", + "render.inspector_applies_to": "应用范围", + "render.inspector_both_users": "两个使用对象", + "render.inspector_chain": "此外观的来源", + "render.inspector_colour": "颜色", + "render.inspector_edit": "编辑", + "render.inspector_finish": "表面处理", + "render.inspector_from_material": "来自材质", + "render.inspector_gloss": "光泽", + "render.inspector_material": "材质", + "render.inspector_matte": "哑光", + "render.inspector_metal": "金属", + "render.inspector_opacity": "不透明度", + "render.inspector_opaque_help": "表面处理和光学字段使用不透明 PBR(不透明度为 1)。降低不透明度会使用标量着色。", + "render.inspector_pick_target": "拾取此类型的目标以检查其外观。", + "render.inspector_remove": "移除覆盖", + "render.inspector_replace": "替换…", + "render.inspector_reset": "重置", + "render.inspector_satin": "缎面", + "render.inspector_save_library": "保存到库…", + "render.inspector_set_all": "外观混合。编辑会将外观设置到所有选定目标。", + "render.inspector_soon": "即将推出", + "render.inspector_target_limit": "最多选择 10000 个目标以检查外观。", + "render.inspector_textures": "纹理", + "render.inspector_this_body": "此实体", + "render.inspector_this_component": "此组件", + "render.inspector_this_face": "此面", + "render.inspector_this_target": "此目标", + "render.inspector_used_by": "由 {count} 个对象使用", + "render.shell_tab_lighting": "灯光", + "view.render_inspector": "渲染检查器" + }, + "ko": { + "render.inspector_advanced": "고급", + "render.inspector_all_users": "사용 대상 {count}개 모두", + "render.inspector_applies_to": "적용 범위", + "render.inspector_both_users": "두 사용 대상", + "render.inspector_chain": "외관 출처", + "render.inspector_colour": "색상", + "render.inspector_edit": "편집", + "render.inspector_finish": "마감", + "render.inspector_from_material": "재질에서 상속", + "render.inspector_gloss": "유광", + "render.inspector_material": "재질", + "render.inspector_matte": "무광", + "render.inspector_metal": "금속", + "render.inspector_opacity": "불투명도", + "render.inspector_opaque_help": "마감 및 광학 필드는 불투명 PBR(불투명도 1)을 사용합니다. 불투명도를 낮추면 스칼라 음영을 사용합니다.", + "render.inspector_pick_target": "이 유형의 대상을 선택하여 외관을 확인하세요.", + "render.inspector_remove": "재정의 제거", + "render.inspector_replace": "바꾸기…", + "render.inspector_reset": "초기화", + "render.inspector_satin": "반광", + "render.inspector_save_library": "라이브러리에 저장…", + "render.inspector_set_all": "외관이 혼합되어 있습니다. 편집하면 선택한 모든 대상에 외관을 설정합니다.", + "render.inspector_soon": "출시 예정", + "render.inspector_target_limit": "외관을 확인할 대상을 10000개 이하로 선택하세요.", + "render.inspector_textures": "텍스처", + "render.inspector_this_body": "이 바디", + "render.inspector_this_component": "이 구성요소", + "render.inspector_this_face": "이 면", + "render.inspector_this_target": "이 대상", + "render.inspector_used_by": "사용 대상 {count}개", + "view.render_inspector": "렌더 검사기" + }, + "ar": { + "render.inspector_advanced": "متقدم", + "render.inspector_all_users": "كل المستخدمين ({count})", + "render.inspector_applies_to": "ينطبق على", + "render.inspector_both_users": "كلا المستخدمين", + "render.inspector_chain": "من أين يأتي هذا المظهر", + "render.inspector_colour": "اللون", + "render.inspector_edit": "تحرير", + "render.inspector_finish": "اللمسة النهائية", + "render.inspector_from_material": "من المادة", + "render.inspector_gloss": "لمعان", + "render.inspector_material": "المادة", + "render.inspector_matte": "مطفأ", + "render.inspector_metal": "معدن", + "render.inspector_opacity": "العتامة", + "render.inspector_opaque_help": "تستخدم اللمسة النهائية والحقول البصرية PBR معتمًا (عتامة 1). العتامة الأقل تستخدم تظليلًا قياسيًا.", + "render.inspector_pick_target": "اختر هدفًا من هذا النوع لفحص مظهره.", + "render.inspector_remove": "إزالة التجاوز", + "render.inspector_replace": "استبدال…", + "render.inspector_reset": "إعادة تعيين", + "render.inspector_satin": "ساتان", + "render.inspector_save_library": "حفظ في المكتبة…", + "render.inspector_set_all": "مظاهر مختلطة. التحرير يضبط المظهر على كل الأهداف المحددة.", + "render.inspector_soon": "قريبًا", + "render.inspector_target_limit": "حدّد 10000 هدف كحد أقصى لفحص المظاهر.", + "render.inspector_textures": "الخامات", + "render.inspector_this_body": "هذا الجسم", + "render.inspector_this_component": "هذا المكوّن", + "render.inspector_this_face": "هذا الوجه", + "render.inspector_this_target": "هذا الهدف", + "render.inspector_used_by": "مستخدَم من {count}", + "render.shell_tab_lighting": "الإضاءة", + "view.render_inspector": "مفتش التصيير" + }, + "he": { + "render.inspector_advanced": "מתקדם", + "render.inspector_all_users": "כל {count} המשתמשים", + "render.inspector_applies_to": "חל על", + "render.inspector_both_users": "שני המשתמשים", + "render.inspector_chain": "מהיכן המראה הזה מגיע", + "render.inspector_colour": "צבע", + "render.inspector_edit": "עריכה", + "render.inspector_finish": "גימור", + "render.inspector_from_material": "מחומר", + "render.inspector_gloss": "ברק", + "render.inspector_material": "חומר", + "render.inspector_matte": "מט", + "render.inspector_metal": "מתכת", + "render.inspector_opacity": "אטימות", + "render.inspector_opaque_help": "שדות הגימור והאופטיקה משתמשים ב-PBR אטום (אטימות 1). אטימות נמוכה יותר משתמשת בהצללה סקלרית.", + "render.inspector_pick_target": "בחר יעד מסוג זה כדי לבדוק את המראה שלו.", + "render.inspector_remove": "הסר עקיפה", + "render.inspector_replace": "החלף…", + "render.inspector_reset": "איפוס", + "render.inspector_satin": "סאטן", + "render.inspector_save_library": "שמור בספרייה…", + "render.inspector_set_all": "מראות מעורבים. העריכה קובעת את המראה בכל היעדים שנבחרו.", + "render.inspector_soon": "בקרוב", + "render.inspector_target_limit": "בחר עד 10000 יעדים כדי לבדוק מראות.", + "render.inspector_textures": "טקסטורות", + "render.inspector_this_body": "גוף זה", + "render.inspector_this_component": "רכיב זה", + "render.inspector_this_face": "פאה זו", + "render.inspector_this_target": "יעד זה", + "render.inspector_used_by": "בשימוש של {count}", + "render.shell_tab_lighting": "תאורה", + "view.render_inspector": "מפקח רינדור" + }, + "vi": { + "render.inspector_advanced": "Nâng cao", + "render.inspector_all_users": "Cả {count} người dùng", + "render.inspector_applies_to": "Áp dụng cho", + "render.inspector_both_users": "Cả hai người dùng", + "render.inspector_chain": "Diện mạo này đến từ đâu", + "render.inspector_colour": "Màu", + "render.inspector_edit": "Sửa", + "render.inspector_finish": "Hoàn thiện", + "render.inspector_from_material": "Từ vật liệu", + "render.inspector_gloss": "Bóng", + "render.inspector_material": "Vật liệu", + "render.inspector_matte": "Mờ", + "render.inspector_metal": "Kim loại", + "render.inspector_opacity": "Độ đục", + "render.inspector_opaque_help": "Các trường hoàn thiện và quang học dùng PBR đục (độ đục 1). Độ đục thấp hơn dùng tô bóng vô hướng.", + "render.inspector_pick_target": "Chọn một đích thuộc loại này để xem diện mạo của nó.", + "render.inspector_remove": "Gỡ ghi đè", + "render.inspector_replace": "Thay…", + "render.inspector_reset": "Đặt lại", + "render.inspector_satin": "Satin", + "render.inspector_save_library": "Lưu vào thư viện…", + "render.inspector_set_all": "Diện mạo hỗn hợp. Chỉnh sửa sẽ đặt diện mạo cho mọi đích đã chọn.", + "render.inspector_soon": "Sắp có", + "render.inspector_target_limit": "Chọn tối đa 10000 đích để xem diện mạo.", + "render.inspector_textures": "Kết cấu", + "render.inspector_this_body": "Thân này", + "render.inspector_this_component": "Thành phần này", + "render.inspector_this_face": "Mặt này", + "render.inspector_this_target": "Đích này", + "render.inspector_used_by": "Được {count} dùng", + "render.shell_tab_lighting": "ÁNH SÁNG", + "view.render_inspector": "Bảng thuộc tính kết xuất" + } +} diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs index 0404ee67f..5e23781fe 100644 --- a/crates/engine/src/cmd/view_navigation.rs +++ b/crates/engine/src/cmd/view_navigation.rs @@ -55,6 +55,9 @@ CommandSpec::new("view.render_browser", "Render Browser", crate::checked!("view. .icon("list").noundo().doc_only() .contract(&BROWSER_CONTRACT).output(output_schema_for::) .params("open: bool; or by_look?: bool; search?: bool; query?: string (up to 1024 bytes) → validated transient Browser controls; never edits the design or opens a dialog"), +CommandSpec::new("view.render_inspector", "Render Inspector", render_inspector) + .icon("inspect").noundo().doc_only() + .params("visible: bool → {visible}; per-document Inspector visibility; never edits the design or opens a dialog"), CommandSpec::new("view.render_select", "Render selection", render_select) .icon("select").noundo().doc_only() .params("kind: nothing|environment|light|shot|output; id?: bounded nonempty string for light/shot → validated transient Browser focus; never edits the design or opens a dialog"), @@ -320,6 +323,16 @@ fn render_dock(_s: &mut Session, p: &Value) -> Result { serde_json::to_value(request).map_err(|e| bad("view.render_dock", e.to_string())) } +fn render_inspector(_s: &mut Session, p: &Value) -> Result { + #[derive(serde::Deserialize)] + #[serde(deny_unknown_fields)] + struct Request { + visible: bool, + } + let request: Request = serde_json::from_value(p.clone()).map_err(|e| bad("view.render_inspector", e.to_string()))?; + Ok(json!({"visible":request.visible})) +} + fn shots_strip(_s: &mut Session, p: &Value) -> Result { #[derive(serde::Deserialize)] #[serde(deny_unknown_fields)] @@ -1162,3 +1175,19 @@ fn render_browser_controls_validate_without_document_changes_or_evaluation() { assert!(std::sync::Arc::ptr_eq(&document, &session.doc)); assert_eq!(before, (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty())); } + +#[test] +fn render_inspector_visibility_is_validated_without_mutation() { + let mut session = Session::default(); + let before = session.doc.to_json(); + let revision = session.revision; + for visible in [false, true] { + assert_eq!(session.execute("view.render_inspector", &json!({"visible":visible})).unwrap(), json!({"visible":visible})); + } + for value in [json!({}), json!({"visible":null}), json!({"visible":"false"}), json!({"visible":true,"extra":1})] { + assert!(session.execute("view.render_inspector", &value).is_err()); + } + assert_eq!(session.doc.to_json(), before); + assert_eq!(session.revision, revision); + assert!(session.undo.is_empty()); +} diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs index ff532eaa4..395b7c7ee 100644 --- a/crates/ui-egui/src/browser.rs +++ b/crates/ui-egui/src/browser.rs @@ -902,6 +902,7 @@ fn render_card(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions) { bounds: crate::ui_kit::Panel::stack_first_bounds(bounds), fill_height: true, compact: crate::render_ui::compact(app, bounds.width()), + editor: false, enabled: true, header_actions: None, }, diff --git a/crates/ui-egui/src/dialogs_appearance.rs b/crates/ui-egui/src/dialogs_appearance.rs index 4d0d2cdec..798b2fe9e 100644 --- a/crates/ui-egui/src/dialogs_appearance.rs +++ b/crates/ui-egui/src/dialogs_appearance.rs @@ -239,7 +239,7 @@ pub fn start(app: &SolveApp, id: &str) -> Option<(Kind, Vec)> { } /// The command giving `targets` (bodies or faces) a look. -fn apply_params(targets: &[Sel], color: [u8; 3], opacity: f64, look: Option<&str>, pbr: Option) -> Option { +pub(crate) fn apply_params(targets: &[Sel], color: [u8; 3], opacity: f64, look: Option<&str>, pbr: Option) -> Option { let bodies: Vec = targets.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.clone()) } else { None }).collect(); let faces: Vec = targets .iter() @@ -304,7 +304,11 @@ pub(super) fn selected_params(k: &Ap, items: &[Sel]) -> Option { /// Removing an override restores the inherited component or material appearance. fn clear_params(k: &Ap, items: &[Sel]) -> Option { - let mut p = selected_params(k, items)?; + Some(without_look(selected_params(k, items)?)) +} + +/// Shared clear form for dialogs and the selection Inspector. +pub(crate) fn without_look(mut p: Value) -> Value { if let Some(obj) = p.as_object_mut() { obj.remove("appearance"); obj.remove("name"); @@ -312,7 +316,7 @@ fn clear_params(k: &Ap, items: &[Sel]) -> Option { obj.remove("opacity"); obj.remove("pbr"); } - Some(p) + p } /// What a swatch dropped now would land on: the face or body under the cursor in the viewport, @@ -360,6 +364,17 @@ fn in_design(app: &mut SolveApp) -> Vec<(Look, usize)> { out } +/// Replacement pickers share the dialog's design looks and admitted library recipes. +pub(crate) fn replacement_library(app: &mut SolveApp) -> Vec { + let mut looks: Vec<_> = in_design(app).into_iter().map(|(look, _)| look).collect(); + for look in library(app).into_iter().filter(preset_available) { + if !looks.iter().any(|saved| saved.name == look.name && saved.color == look.color && saved.opacity == look.opacity && saved.pbr == look.pbr) { + looks.push(look); + } + } + looks +} + fn c32(c: [u8; 3], opacity: f64) -> Color32 { Color32::from_rgba_unmultiplied(c[0], c[1], c[2], (opacity.clamp(0.0, 1.0) * 255.0) as u8) } diff --git a/crates/ui-egui/src/dialogs_library.rs b/crates/ui-egui/src/dialogs_library.rs index 58df6cd66..71fcccedf 100644 --- a/crates/ui-egui/src/dialogs_library.rs +++ b/crates/ui-egui/src/dialogs_library.rs @@ -31,6 +31,19 @@ fn editor<'a>(app: &'a mut SolveApp, token: &Arc<()>) -> Option<&'a mut Ap> { Arc::ptr_eq(&k.local.token, token).then_some(k) } +/// Parameterless UI activation of the existing export command. JSON execution never picks files. +pub(crate) fn start_export(app: &mut SolveApp) { + let origin = app.session.doc.clone(); + app.pick_save("my-library.solidcraft-library.json", &["json"], move |app, path| { + if let Some(path) = path + && Arc::ptr_eq(&origin, &app.session.doc) + && let Err(error) = app.run("library.export", json!({"path":path,"overwrite":false})) + { + app.set_status(error, true); + } + }); +} + fn save_library(app: &mut SolveApp, token: Arc<()>, overwrite: bool) { let origin = app.session.doc.clone(); app.pick_save("my-library.solidcraft-library.json", &["json"], move |app, path| { diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs index c30ea04a3..b957917b7 100644 --- a/crates/ui-egui/src/i18n.rs +++ b/crates/ui-egui/src/i18n.rs @@ -700,6 +700,10 @@ mod tests { // rather than requiring its spelling to differ from English. assert!(locale.0.messages().contains_key("toolbar.render_studio")); assert_eq!(locale.label("STUDIO"), locale.text("toolbar.render_studio")); + let english: Messages = serde_json::from_str(ENGLISH.source).unwrap(); + for id in english.keys().filter(|id| id.starts_with("render.inspector_")) { + assert!(locale.0.messages().contains_key(id), "{language}: {id}"); + } for id in [ "render.pick_label", "render.pick_body", diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index c20c0ac8b..40fd16eda 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -1061,6 +1061,9 @@ impl SolveApp { } _ => {} } + if id == "view.render_inspector" { + render_workspace::set_inspector_visible(self, v.get("visible").and_then(Value::as_bool).unwrap_or(true)); + } if id == "view.render_browser" { render_workspace::apply_browser_controls(self, v); } @@ -1355,6 +1358,10 @@ impl SolveApp { self.home.open = false; return; } + if id == "library.export" { + dialogs_library::start_export(self); + return; + } // A display toggle leaves the current modelling tool and camera in place. if matches!(id, "view.fit" | "view.home" | "view.spin" | "view.grid" | "view.ground_shadow" | "view.navigation_bar") { let _ = self.run(id, json!({})); diff --git a/crates/ui-egui/src/render_ui/appearance.rs b/crates/ui-egui/src/render_ui/appearance.rs new file mode 100644 index 000000000..5c5c7a03c --- /dev/null +++ b/crates/ui-egui/src/render_ui/appearance.rs @@ -0,0 +1,575 @@ +//! Selection-following appearance editor. All mutations use the appearance registry. +use crate::{SolveApp, dialogs_appearance, ui_kit}; +use serde_json::{Value, json}; +use solidcraft_engine::{ + Sel, + doc::{Document, appearance::Look, pbr_appearance::PbrParameters}, +}; +use std::sync::{Arc, Weak}; +use ui_kit::LookStep; + +#[derive(Clone, Debug, Default)] +pub(super) struct View { + selection: Vec, + mode: usize, + pick_mode: usize, + inspected: Option, + all_users: bool, + revision: Option, + document: Option>, + draft: Option, + saved: Option>>, + dirty: bool, + replace_search: String, + replacements: Vec, +} + +#[derive(Clone, Debug, Default)] +pub(super) struct Targets { + items: Vec, + components: Vec, +} +impl Targets { + fn params(&self, look: &Look) -> Option { + let mut params = dialogs_appearance::apply_params(&self.items, look.color, look.opacity, Some(&look.name), look.pbr) + .or_else(|| (!self.components.is_empty()).then(|| look_params(look)))?; + if !self.components.is_empty() { + // Assignment's existing target form accepts component names or string IDs. + params["components"] = json!(self.components.iter().map(u64::to_string).collect::>()); + } + Some(params) + } + fn queries(&self) -> Vec { + self.items + .iter() + .filter_map(|item| match item { + Sel::Body { name } => Some(json!({"body":name})), + Sel::Face { body, index, .. } => Some(json!({"body":body,"face":index})), + _ => None, + }) + .chain(self.components.iter().map(|id| json!({"component":id}))) + .collect() + } +} + +fn mode_step(mode: usize) -> LookStep { + match mode { + 1 => LookStep::Face, + 2 => LookStep::Component, + _ => LookStep::Body, + } +} +fn step_index(step: LookStep) -> usize { + match step { + LookStep::Face => 0, + LookStep::Body => 1, + LookStep::Component => 2, + LookStep::Material => 3, + } +} +pub(super) fn targets(app: &SolveApp, step: LookStep) -> Targets { + let mut targets = Targets::default(); + let state = app.session.world_state(); + for selection in &app.session.selection { + let body = match selection { + Sel::Body { name } | Sel::Face { body: name, .. } => state.body(name), + _ => None, + }; + match step { + LookStep::Face => { + if matches!(selection, Sel::Face { .. }) { + targets.items.push(selection.clone()); + } + } + LookStep::Body => { + if let Some(body) = body { + targets.items.push(Sel::Body { name: body.name.clone() }); + } + if let Sel::Occurrence { path } = selection + && let Ok(bodies) = app.session.occurrence_bodies(path, true) + { + for name in bodies { + targets.items.push(Sel::Body { name }); + if targets.items.len() > 10_000 { + return targets; + } + } + } + } + LookStep::Component => { + let component = body.map(|body| app.session.doc.model_body_component(body)).or_else(|| { + let Sel::Occurrence { path } = selection else { return None }; + app.session.occurrence_placement(path).ok().map(|placement| placement.component) + }); + if let Some(component) = component.filter(|id| *id != 0) { + targets.components.push(component); + } + } + LookStep::Material => {} + } + } + let mut unique = std::collections::BTreeSet::new(); + targets.items.retain(|item| match item { + Sel::Body { name } => unique.insert((name.clone(), None)), + Sel::Face { body, index, .. } => unique.insert((body.clone(), Some(*index))), + _ => false, + }); + targets.components.sort_unstable(); + targets.components.dedup(); + targets +} + +fn decode_look(value: &Value) -> Option { + Some(Look { + name: value.get("name")?.as_str()?.into(), + color: dialogs_appearance::parse_color(value.get("color")?)?, + opacity: value.get("opacity")?.as_f64()?, + pbr: value.get("pbr").filter(|v| !v.is_null()).and_then(|p| serde_json::from_value(p.clone()).ok()), + }) +} +pub(super) fn chains(app: &mut SolveApp, targets: &Targets) -> Result; 4]>, String> { + targets + .queries() + .into_iter() + .map(|target| { + let reply = app.session.execute("appearance.chain", &json!({"target":target})).map_err(|e| e.to_string())?; + let mut chain = [None, None, None, None]; + if let Some(steps) = reply.get("steps").and_then(Value::as_array) { + for (slot, step) in chain.iter_mut().zip(steps) { + *slot = step.get("look").and_then(decode_look); + } + } + Ok(chain) + }) + .collect() +} +fn look_params(look: &Look) -> Value { + json!({"name":look.name,"color":look.color,"opacity":look.opacity,"pbr":look.pbr}) +} +pub(super) fn users(app: &SolveApp, look: &Look) -> usize { + assigned_looks(app).filter(|l| *l == look).count() +} +fn assigned_looks(app: &SolveApp) -> impl Iterator { + let appearances = &app.session.doc.appearances; + appearances.bodies.values().chain(appearances.components.values()).chain(appearances.faces.iter().map(|f| &f.look)) +} +pub(super) fn assign(app: &mut SolveApp, targets: &Targets, from: &Look, to: &Look, all_users: bool) -> Result<(), String> { + if all_users { + app.run("appearance.replace", json!({"from":look_params(from),"to":look_params(to)}))?; + } else if let Some(params) = targets.params(to) { + app.run("appearance.assign", params)?; + } + Ok(()) +} +pub(super) fn clear(app: &mut SolveApp, targets: &Targets, look: &Look) -> Result<(), String> { + if let Some(params) = targets.params(look) { + app.run("appearance.assign", dialogs_appearance::without_look(params))?; + } + Ok(()) +} + +// The same validated response used by the existing material/appearance editors. +pub(super) fn finish(look: &mut Look, index: usize) -> Result<(), String> { + let (metallic, roughness) = match index { + 0 => (0.0, 0.85), + 1 => (0.0, 0.5), + 2 => (0.0, 0.12), + _ => (1.0, 0.32), + }; + look.pbr = Some(PbrParameters::new(metallic, roughness, look.pbr.unwrap_or_default().dielectric_ior()).map_err(|e| e.to_string())?); + look.opacity = 1.0; + Ok(()) +} +fn finish_index(look: &Look) -> usize { + let p = look.pbr.unwrap_or_default(); + if p.metallic() >= 0.5 { + 3 + } else if p.roughness() >= 0.7 { + 0 + } else if p.roughness() <= 0.2 { + 2 + } else { + 1 + } +} +fn sphere(look: &Look) -> ui_kit::Sphere { + super::super::library::tile_sphere(&look_params(look)) +} +pub(super) fn mixed(looks: &[Look], value: impl Fn(&Look) -> T) -> bool { + looks.first().is_some_and(|first| looks.iter().skip(1).any(|look| value(look) != value(first))) +} +pub(super) fn inspected_look(chain: &[Option; 4], step: Option) -> Option<&Look> { + chain.iter().skip(step.map_or(0, step_index)).flatten().next() +} +fn source_step(chain: &[Option; 4], inspected: Option) -> Option { + chain + .iter() + .enumerate() + .skip(inspected.map_or(0, step_index)) + .find_map(|(index, look)| look.as_ref().and_then(|_| LookStep::ALL.get(index)).copied()) +} +fn ended(response: &egui::Response, ui: &egui::Ui) -> bool { + response.drag_stopped() + || response.lost_focus() + || response.changed() && !response.has_focus() && !ui.input(|i| i.pointer.any_down()) && !ui.ctx().egui_wants_keyboard_input() +} + +pub(super) fn scope_label(app: &SolveApp) -> &str { + app.tr(match app.session.selection.last() { + Some(Sel::Occurrence { .. }) => "render.pick_component", + Some(Sel::Face { .. }) => "render.pick_face", + _ => "render.pick_body", + }) +} + +pub(super) fn reset(app: &mut SolveApp) { + let view = &app.render_workspace.view.inspector.selection_appearance; + if view.selection != app.session.selection || view.document.as_ref().is_none_or(|d| !Weak::ptr_eq(d, &Arc::downgrade(&app.session.doc))) { + return; + } + let step = view.inspected.unwrap_or(mode_step(view.mode)); + let selected = targets(app, step); + if let Some(saved) = view.saved.clone() { + let single_targets = selected + .items + .into_iter() + .map(|item| Targets { items: vec![item], components: vec![] }) + .chain(selected.components.into_iter().map(|id| Targets { items: vec![], components: vec![id] })); + for (target, look) in single_targets.zip(saved) { + let result = + if let Some(look) = look { assign(app, &target, &look, &look, false) } else { clear(app, &target, &Look::custom([0; 3], 1.0)) }; + if let Err(error) = result { + app.set_status(error, true); + break; + } + } + app.render_workspace.view.inspector.selection_appearance.revision = None; + } +} + +pub(super) fn remove(app: &mut SolveApp) { + let view = &app.render_workspace.view.inspector.selection_appearance; + let selected = targets(app, view.inspected.unwrap_or(mode_step(view.mode))); + if let Some(look) = view.draft.clone() { + if let Err(error) = clear(app, &selected, &look) { + app.set_status(error, true); + } + app.render_workspace.view.inspector.selection_appearance.revision = None; + } +} + +pub(super) fn footer(app: &mut SolveApp, ui: &mut egui::Ui) { + ui.horizontal(|ui| { + let enabled = !app.session.selection.is_empty(); + if ui_kit::icon_label_action(ui, app.tr("render.inspector_save_library"), Some("plus"), enabled, false) + .on_hover_text(app.tr_label("Export design library...")) + .clicked() + { + app.start("library.export"); + } + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + if ui_kit::text_button(ui, app.tr("render.inspector_reset"), enabled).clicked() { + reset(app); + } + }); + }); +} + +/// Returns false only when the explicit-target fallback should be shown. +pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) -> bool { + if app.session.selection.is_empty() { + app.render_workspace.view.inspector.selection_appearance = View::default(); + return false; + } + if app.session.selection.len() > 10_000 { + ui_kit::text(ui, app.tr("render.inspector_target_limit"), ui_kit::Text::Note("render.inspector_target_limit")); + return true; + } + let mut view = std::mem::take(&mut app.render_workspace.view.inspector.selection_appearance); + let pick_mode = if app.ui.pick_components { 2 } else { usize::from(!app.ui.pick_bodies) }; + if view.selection == app.session.selection && view.pick_mode != pick_mode { + view.mode = pick_mode; + view.inspected = None; + view.saved = None; + view.revision = None; + view.all_users = false; + } + view.pick_mode = pick_mode; + if view.selection != app.session.selection { + view.selection = app.session.selection.clone(); + view.mode = if app.ui.pick_components || view.selection.iter().any(|s| matches!(s, Sel::Occurrence { .. })) { + 2 + } else if view.selection.iter().any(|s| matches!(s, Sel::Face { .. })) { + 1 + } else { + 0 + }; + view.inspected = None; + view.saved = None; + view.revision = None; + view.all_users = false; + } + let options = [app.tr("render.pick_face"), app.tr("render.pick_body"), app.tr("render.pick_component")].map(str::to_owned); + let mut kind = match view.mode { + 0 => 1, + 1 => 0, + _ => 2, + }; + if ui_kit::segmented( + ui, + &mut kind, + &options.each_ref().map(String::as_str), + ui_kit::Segments { compact: true, dense: true, workspace_accent: true, icons: &["surface", "body", "component"], ..Default::default() }, + ) { + view.mode = match kind { + 0 => 1, + 1 => 0, + _ => 2, + }; + view.inspected = None; + view.saved = None; + view.revision = None; + view.all_users = false; + let mode = match view.mode { + 1 => "face", + 2 => "component", + _ => "body", + }; + let _ = app.run("select.filter", json!({"mode":mode})); + view.pick_mode = view.mode; + } + let selected_targets = targets(app, mode_step(view.mode)); + let t = crate::theme::Tokens::get(); + let result = ui_kit::settings_form(ui, t.form_label_width + t.space_8, |ui| draw(app, ui, &mut view, &selected_targets)); + if let Err(error) = result { + ui_kit::text(ui, &error, ui_kit::Text::Error("render:appearance:error")); + } + let body = if view.inspected.unwrap_or(mode_step(view.mode)) == LookStep::Body && selected_targets.items.len() == 1 { + match selected_targets.items.first() { + Some(Sel::Body { name }) => Some(name.as_str()), + _ => None, + } + } else { + None + }; + ui_kit::settings_form(ui, t.form_label_width + t.space_8, |ui| super::materials::selection_controls(app, ui, body)); + // Resource forms keep their existing explicit prepare/review/apply flow until + // the Surfaces and references editor owns them. They never duplicate optics. + let resource_kinds = ["surfaces", "materials", "selene_appearances", "physical_profiles"]; + if resource_kinds.iter().any(|kind| super::library::selected_kind(app, kind)) { + let title = app.tr("render.inspector_advanced").to_owned(); + ui_kit::editor_section(ui, "render:appearance:resources", &title, true, |ui| super::library::inspect_kinds(app, ui, &resource_kinds)); + } + app.render_workspace.view.inspector.selection_appearance = view; + true +} +fn draw(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, selected: &Targets) -> Result<(), String> { + if selected.items.len().saturating_add(selected.components.len()) > 10_000 { + return Err(app.tr("render.inspector_target_limit").into()); + } + let chains = chains(app, selected)?; + let Some(chain) = chains.first() else { + ui_kit::text(ui, app.tr("render.inspector_pick_target"), ui_kit::Text::Note("render.inspector_pick_target")); + return Ok(()); + }; + let default_color = crate::theme::Tokens::get().body; + let default = Look::custom([default_color.r(), default_color.g(), default_color.b()], 1.0); + let looks: Vec<_> = chains + .iter() + .enumerate() + .map(|(index, chain)| { + inspected_look(chain, view.inspected) + .cloned() + .or_else(|| { + selected.items.get(index).filter(|_| !matches!(view.inspected, Some(LookStep::Component | LookStep::Material))).and_then(|item| { + match item { + Sel::Body { name } | Sel::Face { body: name, .. } => { + app.session.world_state().body(name).and_then(|body| app.session.doc.model_display_look(body)) + } + _ => None, + } + }) + }) + .unwrap_or_else(|| default.clone()) + }) + .collect(); + let Some(from) = looks.first() else { return Ok(()) }; + if view.saved.is_none() { + view.saved = + Some(chains.iter().map(|chain| chain.get(step_index(view.inspected.unwrap_or(mode_step(view.mode)))).cloned().flatten()).collect()); + } + let is_mixed = mixed(&looks, Clone::clone); + let distinct: std::collections::BTreeSet<_> = looks.iter().map(|look| look_params(look).to_string()).collect(); + let count = + if !is_mixed { users(app, from) } else { assigned_looks(app).filter(|look| distinct.contains(&look_params(look).to_string())).count() }; + let active = source_step(chain, None).unwrap_or(mode_step(view.mode)); + let source_step = source_step(chain, view.inspected).unwrap_or(mode_step(view.mode)); + let replaceable = !is_mixed && count > 0 && source_step != LookStep::Material; + if !replaceable { + view.all_users = false; + } + if view.revision != Some(app.session.revision) || view.document.as_ref().is_none_or(|d| !Weak::ptr_eq(d, &Arc::downgrade(&app.session.doc))) { + view.draft = Some(from.clone()); + view.dirty = false; + view.revision = Some(app.session.revision); + view.document = Some(Arc::downgrade(&app.session.doc)); + view.replacements = dialogs_appearance::replacement_library(app); + } + let mut draft = view.draft.clone().unwrap_or_else(|| from.clone()); + let name = if is_mixed { app.tr("render.tree_mixed").to_owned() } else { from.name.clone() }; + let source = app.tr(if source_step == LookStep::Material { "render.inspector_material" } else { "render.library_in_design" }).to_owned(); + let used = crate::i18n::format("render.inspector_used_by", &[("count", &count.to_string())]); + let replacements = &view.replacements; + let ids: Vec<_> = (0..replacements.len()).map(|index| index.to_string()).collect(); + let handles: Vec<_> = ids.iter().map(|id| format!("render:appearance:replace:{id}")).collect(); + let options: Vec<_> = replacements + .iter() + .zip(&ids) + .zip(&handles) + .map(|((look, id), handle)| ui_kit::SearchOption { value: id, label: &look.name, handle: Some(handle) }) + .collect(); + let mut inspected = None; + let selected_step = view.inspected.unwrap_or(active); + let chain_labels = [app.tr("render.pick_face"), app.tr("render.pick_body"), app.tr("render.pick_component"), app.tr("render.inspector_material")]; + let replacement = ui_kit::sphere_preview_with_source( + ui, + "render:appearance:preview", + sphere(&draft), + &name, + &used, + |ui| { + let response = ui_kit::compact_dropdown_menu(ui, "render_appearance_chain", &source, |ui| { + ui.set_min_width(crate::theme::Tokens::get().form_label_width * 3.0); + if let Some(step) = + ui_kit::look_chain(ui, "render:appearance:chain", chain_labels, chain.each_ref().map(|l| l.as_ref().map(sphere)), selected_step) + { + inspected = Some(step); + ui.close(); + } + }); + crate::scenario::publish_target("render:appearance:chain-menu", response.rect.intersect(ui.clip_rect())); + response + }, + |ui| ui_kit::searchable_icon_dropdown(ui, "spin", app.tr("render.inspector_replace"), &mut view.replace_search, &options), + ); + if let Some(step) = inspected { + view.inspected = Some(step); + view.saved = None; + view.revision = None; + view.all_users = false; + return Ok(()); + } + if let Some(to) = replacement.and_then(|id| id.parse::().ok()).and_then(|index| replacements.get(index)) { + let to = Look { name: to.name.clone(), color: to.color, opacity: to.opacity, pbr: to.pbr }; + let step = view.inspected.filter(|step| *step != LookStep::Material).unwrap_or(mode_step(view.mode)); + let replace_targets = targets(app, step); + assign(app, &replace_targets, from, &to, view.all_users)?; + view.revision = None; + return Ok(()); + } + let step = view.inspected.unwrap_or(mode_step(view.mode)); + let mut scope = usize::from(view.all_users); + let all_label = crate::i18n::format("render.inspector_all_users", &[("count", &count.to_string())]); + let this_label = app + .tr(match step { + LookStep::Face => "render.inspector_this_face", + LookStep::Component => "render.inspector_this_component", + _ => "render.inspector_this_body", + }) + .to_owned(); + ui_kit::row(ui, app.tr("render.inspector_applies_to"), |ui| { + ui.add_enabled_ui(replaceable, |ui| { + ui_kit::segmented( + ui, + &mut scope, + &[&this_label, &all_label], + ui_kit::Segments { compact: true, small: true, workspace_accent: true, ..Default::default() }, + ) + }); + }); + view.all_users = scope == 1; + let edit_targets = targets(app, step); + let mut commit = false; + let edit_title = app.tr("render.inspector_edit").to_owned(); + ui_kit::editor_section(ui, "render:appearance:edit", &edit_title, true, |ui| { + if is_mixed { + ui_kit::text(ui, app.tr("render.inspector_set_all"), ui_kit::Text::Note("render.inspector_set_all")); + } + let editable = step != LookStep::Material && (!edit_targets.items.is_empty() || !edit_targets.components.is_empty()); + ui.add_enabled_ui(editable, |ui| { + ui_kit::row(ui, app.tr("render.inspector_colour"), |ui| { + let response = ui_kit::color_hex_field(ui, &mut draft.color, mixed(&looks, |l| l.color).then(|| app.tr("render.tree_mixed"))); + view.dirty |= response.changed(); + commit |= ended(&response, ui); + }); + let mut preset = finish_index(&draft); + let states = if mixed(&looks, |l| l.pbr) { [false; 4] } else { std::array::from_fn(|i| i == preset) }; + ui_kit::row(ui, app.tr("render.inspector_finish"), |ui| { + let labels = + ["render.inspector_matte", "render.inspector_satin", "render.inspector_gloss", "render.inspector_metal"].map(|key| app.tr(key)); + if ui_kit::segmented( + ui, + &mut preset, + &labels, + ui_kit::Segments { states: &states, compact: true, small: true, workspace_accent: true, ..Default::default() }, + ) { + if let Err(error) = finish(&mut draft, preset) { + app.set_status(error, true); + } else { + view.dirty = true; + commit = true; + } + } + }); + let mut p = draft.pbr.unwrap_or_default(); + let mut metallic = p.metallic(); + let mut roughness = p.roughness(); + let mut ior = p.dielectric_ior(); + let mut optical_edit = false; + for (key, value, range, mixed) in [ + ("appearance.metallic", &mut metallic, 0.0..=1.0, mixed(&looks, |l| l.pbr.unwrap_or_default().metallic())), + ("appearance.roughness", &mut roughness, 0.045..=1.0, mixed(&looks, |l| l.pbr.unwrap_or_default().roughness())), + ] { + ui_kit::row(ui, app.tr(key), |ui| { + let response = ui_kit::mixed_slider(ui, value, range, mixed.then(|| app.tr("render.tree_mixed"))); + view.dirty |= response.changed(); + optical_edit |= response.changed(); + commit |= ended(&response, ui); + }); + } + ui_kit::row(ui, app.tr("render.inspector_opacity"), |ui| { + let response = + ui_kit::mixed_slider(ui, &mut draft.opacity, 0.0..=1.0, mixed(&looks, |l| l.opacity).then(|| app.tr("render.tree_mixed"))); + view.dirty |= response.changed(); + commit |= ended(&response, ui); + if response.changed() && draft.opacity < 1.0 { + draft.pbr = None; + } + }); + ui_kit::row(ui, app.tr("render.appearance_editor.ior"), |ui| { + let response = ui_kit::mixed_scalar_field( + ui, + &mut ior, + 1.0..=3.0, + mixed(&looks, |l| l.pbr.unwrap_or_default().dielectric_ior()).then(|| app.tr("render.tree_mixed")), + ); + view.dirty |= response.changed(); + optical_edit |= response.changed(); + commit |= ended(&response, ui); + }); + ui_kit::text(ui, app.tr("render.inspector_opaque_help"), ui_kit::Text::Note("render.inspector_opaque_help")); + if optical_edit && let Ok(parameters) = PbrParameters::new(metallic, roughness, ior) { + p = parameters; + draft.pbr = Some(p); + draft.opacity = 1.0; + } + }); + }); + commit |= view.dirty && !ui.input(|i| i.pointer.any_down()) && !ui.ctx().egui_wants_keyboard_input(); + if commit && view.dirty && (draft != *from || is_mixed) { + assign(app, &edit_targets, from, &draft, view.all_users)?; + view.revision = None; + } + view.draft = Some(draft); + Ok(()) +} diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs index a3a71d5d4..17aced754 100644 --- a/crates/ui-egui/src/render_workspace.rs +++ b/crates/ui-egui/src/render_workspace.rs @@ -151,6 +151,7 @@ impl PathHost { } /// The samples slider's top end: 2^12 = 4096 samples per pixel. +#[cfg(test)] const MAX_SAMPLES_EXPONENT: u32 = 12; /// Setup times kept per adapter, at most. @@ -593,6 +594,7 @@ pub(crate) fn select_stage(app: &mut SolveApp, key: &str) { _ => return, }; app.render_workspace.view.stage = stage; + app.render_workspace.view.inspector.hidden = false; app.render_workspace.view.inspector.page = stage.page(); let sections: &[&str] = match stage { Stage::Look => &["objects"], @@ -627,6 +629,10 @@ pub(crate) fn job_ready(app: &SolveApp, id: &str) -> Result<(), String> { ribbon::action_ready(app, id) } +pub(crate) fn set_inspector_visible(app: &mut SolveApp, visible: bool) { + app.render_workspace.view.inspector.hidden = !visible; +} + pub fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { if crate::render_ui::focused(app) { return; @@ -766,18 +772,10 @@ fn method_selector(app: &mut SolveApp, ui: &mut egui::Ui) { }); crate::scenario::publish_handle("render:method", response.rect.center()); if image_host(app, app.render_workspace.view.method).is_err() { - if app.render_workspace.view.inspector.page == inspector::Page::All { - ui.small(app.tr("render.setup_offline_help")); - } else { - crate::ui_kit::text(ui, app.tr("render.setup_offline_help"), crate::ui_kit::Text::Note("render.setup_offline_help")); - } + crate::ui_kit::text(ui, app.tr("render.setup_offline_help"), crate::ui_kit::Text::Note("render.setup_offline_help")); } if app.render_workspace.view.method != ImageMethod::Raster { - if app.render_workspace.view.inspector.page == inspector::Page::All { - ui.small(app.tr("render.preview_image_settings_help")); - } else { - crate::ui_kit::text(ui, app.tr("render.preview_image_settings_help"), crate::ui_kit::Text::Note("render.preview_image_settings_help")); - } + crate::ui_kit::text(ui, app.tr("render.preview_image_settings_help"), crate::ui_kit::Text::Note("render.preview_image_settings_help")); } } @@ -830,6 +828,7 @@ fn cpu_lighting_controls(app: &mut SolveApp, ui: &mut egui::Ui) { crate::ui_kit::checkbox(ui, &shadows, &mut app.render_workspace.view.raytrace.shadows); } +#[cfg(test)] fn image_method_controls(app: &mut SolveApp, ui: &mut egui::Ui) { method_selector(app, ui); if app.render_workspace.view.method != ImageMethod::CpuRaytrace { @@ -843,6 +842,7 @@ fn image_method_controls(app: &mut SolveApp, ui: &mut egui::Ui) { cpu::controls(app, ui); } +#[cfg(test)] fn image_edit_controls(app: &mut SolveApp, ui: &mut egui::Ui) { ui.heading(app.tr("render.image_title")); let preview = app.tr("render.result_preview").to_string(); diff --git a/crates/ui-egui/src/render_workspace_cpu.rs b/crates/ui-egui/src/render_workspace_cpu.rs index 58a52730d..37ce0cfe3 100644 --- a/crates/ui-egui/src/render_workspace_cpu.rs +++ b/crates/ui-egui/src/render_workspace_cpu.rs @@ -127,7 +127,9 @@ pub(super) enum Environment { #[derive(Clone, Debug)] pub(super) struct View { + #[cfg(test)] pub selected_body: Option, + #[cfg(test)] pub body_filter: String, pub environment: Environment, pub hdr: hdr::Input, @@ -164,7 +166,9 @@ pub(super) struct Checked { impl Default for View { fn default() -> Self { Self { + #[cfg(test)] selected_body: None, + #[cfg(test)] body_filter: String::new(), environment: Environment::None, hdr: hdr::Input::default(), @@ -322,6 +326,7 @@ pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> { Ok(()) } +#[cfg(test)] pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { for (id, key, section) in [ ("render_cpu_reflections", "render.cpu_reflections", 0), @@ -338,6 +343,7 @@ pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { ui.small(app.tr("render.cpu_runtime_help")); } +#[cfg(test)] pub(super) fn reflection_controls(app: &mut SolveApp, ui: &mut egui::Ui) { ui.small(app.tr("render.cpu_reflection_help")); let entries = app.render_workspace.view.raytrace.reflections.as_ref().map(|r| r.bodies.clone()).unwrap_or_default(); @@ -413,13 +419,16 @@ pub(super) fn reflection_controls(app: &mut SolveApp, ui: &mut egui::Ui) { { app.set_status(error, true); } + reflection_sampling_controls(app, ui); +} + +/// Existing global reflection budget, shared during the Sampling-editor migration. +pub(super) fn reflection_sampling_controls(app: &mut SolveApp, ui: &mut egui::Ui) { let depth = app.tr("render.cpu_reflection_depth").to_string(); let samples = app.tr("render.cpu_reflection_samples").to_string(); if let Some(reflections) = &mut app.render_workspace.view.raytrace.reflections { - ui.label(depth); - ui_kit::number_field(ui, &mut reflections.max_bounces, 1..=8, 1.0, ""); - ui.label(samples); - ui_kit::number_field(ui, &mut reflections.samples, 1..=64, 1.0, ""); + ui_kit::row(ui, &depth, |ui| ui_kit::number_field(ui, &mut reflections.max_bounces, 1..=8, 1.0, "")); + ui_kit::row(ui, &samples, |ui| ui_kit::number_field(ui, &mut reflections.samples, 1..=64, 1.0, "")); } else { ui.small(app.tr("render.cpu_reflection_empty")); } diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs index 12fb80a21..67d4386d0 100644 --- a/crates/ui-egui/src/render_workspace_inspector.rs +++ b/crates/ui-egui/src/render_workspace_inspector.rs @@ -1,17 +1,19 @@ //! Contextual native Render UI. One workspace, existing command authority and shared controls. //! Page navigation is per document; unsupported backend capabilities never emit dummy parameters. use super::{ImageMethod, cpu, library, materials, setups, studio}; -use crate::{SolveApp, theme::Tokens, ui_kit}; +use crate::{SolveApp, ui_kit}; use serde_json::{Value, json}; use solidcraft_engine::doc::Document; use std::sync::{Arc, Weak}; +#[path = "render_ui/appearance.rs"] +mod selection_appearance; + #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub(super) enum Page { #[default] Scene, Appearance, - Aging, Effects, Lighting, Environment, @@ -19,13 +21,14 @@ pub(super) enum Page { Camera, Output, Diagnostics, + #[cfg(test)] All, } impl Page { - const ALL: [Self; 11] = [ + #[cfg(test)] + const ALL: [Self; 10] = [ Self::Scene, Self::Appearance, - Self::Aging, Self::Lighting, Self::Environment, Self::Background, @@ -39,7 +42,6 @@ impl Page { match self { Self::Scene => "render.page_scene", Self::Appearance => "render.page_appearance", - Self::Aging => "render.page_aging", Self::Effects => "render.page_effects", Self::Lighting => "render.page_lighting", Self::Environment => "render.page_environment", @@ -47,6 +49,7 @@ impl Page { Self::Camera => "render.page_camera", Self::Output => "render.page_output", Self::Diagnostics => "render.page_diagnostics", + #[cfg(test)] Self::All => "render.page_all", } } @@ -54,7 +57,6 @@ impl Page { match self { Self::Scene => "scene", Self::Appearance => "appearance", - Self::Aging => "aging", Self::Effects => "effects", Self::Lighting => "lighting", Self::Environment => "environment", @@ -62,6 +64,7 @@ impl Page { Self::Camera => "camera", Self::Output => "output", Self::Diagnostics => "diagnostics", + #[cfg(test)] Self::All => "all", } } @@ -69,7 +72,6 @@ impl Page { match self { Self::Scene => "render_scene", Self::Appearance => "appearance", - Self::Aging => "appearance", Self::Effects => "camera", Self::Lighting => "settings", Self::Environment => "environment_map", @@ -77,6 +79,7 @@ impl Page { Self::Camera => "camera", Self::Output => "export", Self::Diagnostics => "inspect", + #[cfg(test)] Self::All => "list", } } @@ -84,6 +87,7 @@ impl Page { #[derive(Clone, Debug)] pub(super) struct View { pub effects: super::effects::View, + pub hidden: bool, pub page: Page, reveal: Option<&'static str>, pending: Option, @@ -99,6 +103,7 @@ pub(super) struct View { ground_color: [f64; 3], replace_ground: bool, appearance: Appearance, + selection_appearance: selection_appearance::View, resolution: Resolution, } /// Editor-only coupling. The fixed rational anchor prevents repeated rounded @@ -189,6 +194,7 @@ impl Default for View { fn default() -> Self { Self { effects: Default::default(), + hidden: false, page: Page::Scene, reveal: None, pending: None, @@ -204,6 +210,7 @@ impl Default for View { ground_color: [0.18; 3], replace_ground: false, appearance: Appearance::default(), + selection_appearance: Default::default(), resolution: Resolution::default(), } } @@ -214,6 +221,10 @@ pub(super) fn record_check(app: &mut SolveApp, request: &Value, reply: &Value) { } pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { + if app.render_workspace.view.inspector.hidden { + crate::shell::register_panel(app, "render:inspector", None, None); + return; + } setups::refresh_dirty(app); if app.render_workspace.revision != app.session.revision && !app.render_workspace.view.dirty { setups::load(app); @@ -221,9 +232,25 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { let bounds = crate::shell::panel_bounds(app, ui.available_rect_before_wrap()); let mut side = app.preferences.render_inspector_side.clone(); let mut width = app.preferences.render_inspector_width; - let title = app.tr("render.studio_title").to_string(); - let icon = app.render_workspace.view.inspector.page.icon(); - let content = ui_kit::Panel::workspace( + let appearance_editor = app.render_workspace.view.inspector.page == Page::Appearance; + let selection_appearance = appearance_editor && !app.session.selection.is_empty(); + let title = if selection_appearance { + app.session + .selection + .last() + .and_then(|item| match item { + solidcraft_engine::Sel::Body { name } | solidcraft_engine::Sel::Face { body: name, .. } => Some(name.clone()), + solidcraft_engine::Sel::Occurrence { path } => app.session.occurrence_placement(path).ok().map(|placement| placement.name), + _ => None, + }) + .unwrap_or_else(|| app.tr("render.inspector").to_owned()) + } else { + app.tr("render.studio_title").to_string() + }; + let icon = if selection_appearance { "body" } else { app.render_workspace.view.inspector.page.icon() }; + let scope = selection_appearance::scope_label(app).to_owned(); + let header_action = std::cell::Cell::new(None); + let content = ui_kit::Panel::workspace_with_header( ui, ui_kit::WorkspaceOptions { id: "render:inspector", @@ -232,15 +259,23 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { bounds, fill_height: true, compact: crate::render_ui::compact(app, bounds.width()), + editor: appearance_editor, enabled: true, header_actions: None, }, &mut side, &mut width, + false, + |ui, options| { + if appearance_editor { + header_action.set(ui_kit::inspector_header(ui, options.icon, options.title, &scope)); + } else { + ui_kit::panel::header(ui, options.icon, options.title, || header_action.set(Some(ui_kit::InspectorAction::Close))); + } + }, |ui| { - ui_kit::scope(ui, |ui| { + if !appearance_editor { header(app, ui); - pages(app, ui); ui_kit::Panel::pinned_footer(ui, "render_job_footer", 4, |ui| { ui.separator(); super::job_controls(app, ui, true); @@ -251,38 +286,47 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { } crate::scenario::publish_rect("render:job-footer", ui.min_rect()); }); - let page = app.render_workspace.view.inspector.page; - egui::ScrollArea::vertical().id_salt(("render_inspector", page.handle(), app.docs.active)).auto_shrink([false, false]).show( - ui, - |ui| { - ui_kit::text(ui, app.tr(page.key()), ui_kit::Text::Heading(page.key())); - match page { - Page::Scene => scene_controls(app, ui), - Page::Appearance => appearance_controls(app, ui), - Page::Aging => super::effects::aging_controls(app, ui), - Page::Effects => super::effects::presentation_controls(app, ui), - Page::Lighting => lighting_controls(app, ui), - Page::Environment => environment_controls(app, ui), - Page::Background => background_controls(app, ui), - Page::Camera => camera_controls(app, ui), - Page::Output => output_controls(app, ui), - Page::Diagnostics => diagnostics(app, ui), - Page::All => { - ui_kit::text(ui, app.tr("render.all_controls_help"), ui_kit::Text::Note("render.all_controls_help")); - camera_actions(app, ui); - let title = app.tr("render.page_camera").to_string(); - ui_kit::section(ui, "render_all_camera", &title, false, |ui| camera_controls(app, ui)); - let title = app.tr("render.page_aging").to_string(); - ui_kit::section(ui, "render_all_aging", &title, false, |ui| super::effects::aging_controls(app, ui)); - super::image_edit_controls(app, ui); - } - } - setups::refresh_dirty(app); - }, - ); + } + if appearance_editor { + ui_kit::Panel::editor_footer(ui, "render_appearance_footer", |ui| selection_appearance::footer(app, ui)); + } + let page = app.render_workspace.view.inspector.page; + egui::ScrollArea::vertical().id_salt(("render_inspector", page.handle(), app.docs.active)).auto_shrink([false, false]).show(ui, |ui| { + if !appearance_editor { + ui_kit::text(ui, app.tr(page.key()), ui_kit::Text::Heading(page.key())); + } + match page { + Page::Scene => scene_controls(app, ui), + Page::Appearance => appearance_controls(app, ui), + Page::Effects => super::effects::presentation_controls(app, ui), + Page::Lighting => lighting_controls(app, ui), + Page::Environment => environment_controls(app, ui), + Page::Background => background_controls(app, ui), + Page::Camera => camera_controls(app, ui), + Page::Output => output_controls(app, ui), + Page::Diagnostics => diagnostics(app, ui), + #[cfg(test)] + Page::All => { + ui_kit::text(ui, app.tr("render.all_controls_help"), ui_kit::Text::Note("render.all_controls_help")); + camera_actions(app, ui); + let title = app.tr("render.page_camera").to_string(); + ui_kit::section(ui, "render_all_camera", &title, false, |ui| camera_controls(app, ui)); + let title = app.tr("render.page_aging").to_string(); + ui_kit::section(ui, "render_all_aging", &title, false, |ui| super::effects::aging_controls(app, ui)); + super::image_edit_controls(app, ui); + } + } + setups::refresh_dirty(app); }); }, ); + match header_action.get() { + Some(ui_kit::InspectorAction::Close) => { + let _ = app.run("view.render_inspector", json!({"visible":false})); + } + Some(ui_kit::InspectorAction::Remove) => selection_appearance::remove(app), + None => {} + } app.preferences.render_inspector_width = width; let requested = content .as_ref() @@ -299,30 +343,6 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { } confirmation(app, ui.ctx()); } -fn pages(app: &mut SolveApp, ui: &mut egui::Ui) { - let page = app.render_workspace.view.inspector.page; - let mut index = Page::ALL.iter().position(|p| *p == page).unwrap_or(0); - let options: Vec<_> = - Page::ALL.iter().map(|page| ui_kit::IconSegment { key: page.handle(), icon: page.icon(), tip: app.tr(page.key()).to_string() }).collect(); - let top = ui.cursor().min; - let width = ui.available_width(); - let height = ui_kit::row_height(); - if ui_kit::segmented_icons(ui, &mut index, &options, &[]) - && let Some(page) = Page::ALL.get(index) - { - app.render_workspace.view.inspector.page = *page; - } - for (i, page) in Page::ALL.iter().enumerate() { - crate::scenario::publish_target( - &format!("render:page:{}", page.handle()), - egui::Rect::from_min_size( - top + egui::vec2(width * i as f32 / Page::ALL.len() as f32, 0.0), - egui::vec2(width / Page::ALL.len() as f32, height), - ), - ); - } - ui.add_space(Tokens::get().space_4); -} fn header(app: &mut SolveApp, ui: &mut egui::Ui) { let current = app.render_workspace.view.name.clone(); let names: Vec<_> = app.session.doc.render.setups.keys().cloned().collect(); @@ -358,7 +378,7 @@ fn header(app: &mut SolveApp, ui: &mut egui::Ui) { }); let status = if app.render_workspace.view.dirty { app.tr("render.unsaved") } else { app.tr("render.studio_saved") }; ui.add_sized([ui.available_width(), ui.text_style_height(&egui::TextStyle::Body)], egui::Label::new(status).truncate()); - if app.render_workspace.view.inspector.page != Page::All { + { let labels = [app.tr("render.result_preview").to_string(), app.tr("render.result_title").to_string()]; let mut value = usize::from(app.render_workspace.view.result); if ui_kit::segmented(ui, &mut value, &labels.iter().map(String::as_str).collect::>(), Default::default()) { @@ -416,6 +436,7 @@ fn perform_action(app: &mut SolveApp, action: PendingAction) -> Result<(), Strin } fn confirmation(app: &mut SolveApp, ctx: &egui::Context) { super::shots::confirmation(app, ctx); + materials::confirmation(app, ctx); let Some(pending) = app.render_workspace.view.inspector.pending.clone() else { return }; if pending.revision != app.session.revision || !Weak::ptr_eq(&pending.document, &Arc::downgrade(&app.session.doc)) { app.render_workspace.view.inspector.pending = None; @@ -602,16 +623,21 @@ fn shot_controls(app: &mut SolveApp, ui: &mut egui::Ui) { }); } fn appearance_controls(app: &mut SolveApp, ui: &mut egui::Ui) { + if selection_appearance::controls(app, ui) { + return; + } 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); + let title = app.tr("render.inspector_advanced").to_owned(); + reveal_section(app, ui, "render:appearance:advanced"); + ui_kit::section(ui, "render:appearance:advanced", &title, false, |ui| advanced_appearance_controls(app, ui)); +} +fn advanced_appearance_controls(app: &mut SolveApp, ui: &mut egui::Ui) { browse_button(app, ui, "surfaces", "render.browse_surfaces"); browse_button(app, ui, "physical_profiles", "render.browse_physical"); library::inspect_kinds(app, ui, &["surfaces", "materials", "selene_appearances", "physical_profiles"]); - library::saved_surface_controls(app, ui); - materials::controls(app, ui); - if app.render_workspace.view.method == ImageMethod::CpuRaytrace { - cpu::reflection_controls(app, ui); - } + super::effects::aging_controls(app, ui); } fn lighting_controls(app: &mut SolveApp, ui: &mut egui::Ui) { browse_button(app, ui, "rigs", "render.browse_rigs"); @@ -1155,7 +1181,7 @@ 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() + app.render_workspace.view.inspector.pending.is_some() || app.render_workspace.view.save_shot_name.is_some() || materials::confirmation_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 898b3560a..b5bb60466 100644 --- a/crates/ui-egui/src/render_workspace_inspector_tests.rs +++ b/crates/ui-egui/src/render_workspace_inspector_tests.rs @@ -1,5 +1,5 @@ use super::*; -use crate::scenario::Harness; +use crate::{scenario::Harness, theme::Tokens}; fn fixture() -> Harness { let mut h = Harness::new(); h.call("ui.resize", json!({"width":1440,"height":1000})); @@ -25,6 +25,9 @@ fn native_inspector_defaults_to_output_and_keeps_job_actions_on_screen_in_both_s h.app.render_workspace.view.inspector.page = page; h.frames(3); let inspector = crate::scenario::rect_of("render:inspector").unwrap(); + if page == Page::Appearance { + continue; + } let footer = crate::scenario::rect_of("render:job-footer").unwrap(); assert!(inspector.contains_rect(footer), "footer outside inspector at {page:?}: {inspector:?} {footer:?}"); for name in ["render:check", "render:start", "render:cancel", "render:export"] { @@ -41,20 +44,21 @@ fn native_inspector_defaults_to_output_and_keeps_job_actions_on_screen_in_both_s } } #[test] -fn icon_page_navigation_is_local_and_never_switches_executor_or_overwrites_drafts() { +fn stage_navigation_is_local_and_never_switches_executor_or_overwrites_drafts() { let mut h = fixture(); let before = h.app.session.doc.to_json(); h.app.render_workspace.view.samples = 37; h.app.render_workspace.view.draft.width = 777; - for page in Page::ALL { - h.step(&json!({"click":{"handle":format!("render:page:{}",page.handle())}})).unwrap(); - assert_eq!(h.app.render_workspace.view.inspector.page, page); + for stage in super::super::Stage::ALL { + h.step(&json!({"click":{"handle":format!("render:stage:{}",stage.key())}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, stage.page()); assert_eq!(h.app.render_workspace.view.method, ImageMethod::Raster); assert_eq!(h.app.render_workspace.view.samples, 37); assert_eq!(h.app.render_workspace.view.draft.width, 777); assert_eq!(h.app.session.doc.to_json(), before); } } + #[test] fn dirty_shot_switch_keep_discard_and_save_are_explicit_and_lossless() { let mut h = fixture(); @@ -305,7 +309,7 @@ fn ribbon_navigation_reuses_inspector_and_preserves_exact_unsaved_intent() { ("render.stage.clear", Page::Background), ("render.hdr.inspect", Page::Environment), ("render.settings.capture_hdr", Page::Environment), - ("render.aging.describe", Page::Aging), + ("render.aging.describe", Page::Appearance), ("render.effects.describe", Page::Effects), ("render.backends", Page::Diagnostics), ] { @@ -516,7 +520,7 @@ fn aging_tab_adds_reorders_disables_and_persists_layers_without_engineering_edit let before = h.app.session.doc.to_json(); h.app.start("render.aging.describe"); h.frames(3); - assert_eq!(h.app.render_workspace.view.inspector.page, Page::Aging); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); assert!(!crate::icon_svg::resolve(solidcraft_engine::find_command("render.aging.describe").unwrap().icon).placeholder); for code in [1, 3] { h.step(&json!({"click":{"handle":"render:aging-add"}})).unwrap(); @@ -757,3 +761,601 @@ fn browser_shot_menus_keep_target_and_draft_through_confirmation() { assert_eq!(h.app.render_workspace.view.name, "B"); assert_eq!(h.app.render_workspace.view.draft.width, 456, "removing another shot preserves this draft"); } + +#[test] +fn appearance_inspector_targets_and_chain_follow_body_face_and_component() { + use super::selection_appearance::{chains, inspected_look, targets}; + use solidcraft_engine::{Sel, geom::Vec3}; + let mut h = Harness::new(); + h.app.run("component.create", json!({"name":"Part"})).unwrap(); + h.app.run("solid.box", json!({"body_name":"Subject","length":20,"width":15,"height":10})).unwrap(); + h.app.run("material.assign", json!({"bodies":["Subject"],"material":"Steel"})).unwrap(); + h.app.run("appearance.assign", json!({"components":["Part"],"appearance":"ABS - Blue"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap(); + h.app.run("appearance.assign", json!({"body":"Subject","faces":[[10,7,10]],"appearance":"Copper"})).unwrap(); + let face = h.app.run("model.faces", json!({"body":"Subject"})).unwrap()["faces"] + .as_array() + .unwrap() + .iter() + .find(|f| f["point"][2] == 10.0) + .unwrap()["index"] + .as_u64() + .unwrap() as usize; + h.app.session.selection = vec![Sel::Face { body: "Subject".into(), index: face, point: Vec3::new(10.0, 7.0, 10.0) }]; + let before = h.app.session.doc.to_json(); + for (step, present) in [ + (ui_kit::LookStep::Face, [true, true, true, true]), + (ui_kit::LookStep::Body, [false, true, true, true]), + (ui_kit::LookStep::Component, [false, false, true, true]), + ] { + let target = targets(&h.app, step); + let chain = chains(&mut h.app, &target).unwrap(); + assert_eq!(chain[0].each_ref().map(Option::is_some), present); + assert_eq!(inspected_look(&chain[0], Some(ui_kit::LookStep::Component)).unwrap().name, "ABS - Blue"); + assert_eq!(inspected_look(&chain[0], Some(ui_kit::LookStep::Material)).unwrap().name, "Steel"); + let mut inherited = chain[0].clone(); + inherited[1] = None; + inherited[2] = None; + assert_eq!(inspected_look(&inherited, Some(ui_kit::LookStep::Body)).unwrap().name, "Steel"); + } + assert_eq!(h.app.session.doc.to_json(), before); +} + +#[test] +fn appearance_inspector_all_users_replaces_exact_look_once_without_changing_mass() { + use super::selection_appearance::{assign, chains, targets, users}; + use solidcraft_engine::Sel; + let mut h = fixture(); + h.app.run("solid.box", json!({"body_name":"Other","length":5,"width":5,"height":5,"corner":[30,0,0]})).unwrap(); + h.app.run("material.assign", json!({"bodies":["Subject","Other"],"material":"Steel"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Subject","Other"],"appearance":"ABS - Red"})).unwrap(); + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + let target = targets(&h.app, ui_kit::LookStep::Body); + let from = chains(&mut h.app, &target).unwrap()[0][1].clone().unwrap(); + assert_eq!(users(&h.app, &from), 2); + let mut to = from.clone(); + to.color = [12, 34, 56]; + let mass = h.app.run("component.properties", json!({})).unwrap(); + let undo = h.app.session.undo.len(); + assign(&mut h.app, &target, &from, &to, true).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + for name in ["Subject", "Other"] { + assert_eq!(h.app.session.doc.appearances.bodies.get(name), Some(&to)); + } + assert_eq!(h.app.run("component.properties", json!({})).unwrap(), mass); + h.app.run("edit.undo", json!({})).unwrap(); + assert_eq!(users(&h.app, &from), 2); + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + h.frames(2); + h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":format!("dialog:{}:{}", h.app.tr("render.inspector_applies_to"), crate::i18n::format("render.inspector_all_users", &[("count", "2")]))}})) + .unwrap(); + h.step(&json!({"click":{"handle":"render:appearance:preview:replace"}})).unwrap(); + h.step(&json!({"click":{"handle":"dialog: search"}})).unwrap(); + h.step(&json!({"text":"ABS - Blue"})).unwrap(); + let blue = crate::dialogs_appearance::replacement_library(&mut h.app).iter().position(|look| look.name == "ABS - Blue").unwrap(); + h.step(&json!({"click":{"handle":format!("render:appearance:replace:{blue}")}})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + for name in ["Subject", "Other"] { + assert_eq!(h.app.session.doc.appearances.bodies[name].name, "ABS - Blue"); + } + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":format!("dialog:{}:{}",h.app.tr("render.inspector_finish"),h.app.tr("render.inspector_matte"))}})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1, "an all-users field edit is one replacement command"); + for name in ["Subject", "Other"] { + assert_eq!(h.app.session.doc.appearances.bodies[name].pbr.unwrap().roughness(), 0.85); + } + assert_eq!(h.app.run("component.properties", json!({})).unwrap(), mass); +} + +#[test] +fn appearance_inspector_finish_presets_mixed_set_all_and_clear_use_existing_assignments() { + use super::selection_appearance::{assign, chains, clear, finish, mixed, targets}; + use solidcraft_engine::{Sel, doc::appearance::Look}; + let mut h = fixture(); + h.app.run("solid.box", json!({"body_name":"Other","length":5,"width":5,"height":5,"corner":[30,0,0]})).unwrap(); + h.app.run("material.assign", json!({"bodies":["Subject","Other"],"material":"Steel"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Other"],"appearance":"ABS - Blue"})).unwrap(); + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }, Sel::Body { name: "Other".into() }]; + let target = targets(&h.app, ui_kit::LookStep::Body); + let looks: Vec<_> = chains(&mut h.app, &target).unwrap().into_iter().map(|c| c[1].clone().unwrap()).collect(); + assert!(mixed(&looks, |l| l.color)); + assert!(!mixed(&looks, |l| l.opacity)); + h.frames(2); + h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); + assert!(h.widget(h.app.tr("render.tree_mixed")).is_some()); + appearance_inspector_capture(&mut h, "mixed"); + let mass = h.app.run("component.properties", json!({})).unwrap(); + let mut to = Look::custom([40, 50, 60], 0.5); + for (index, metallic, roughness) in [(0, 0.0, 0.85), (1, 0.0, 0.5), (2, 0.0, 0.12), (3, 1.0, 0.32)] { + finish(&mut to, index).unwrap(); + let pbr = to.pbr.unwrap(); + assert_eq!((pbr.metallic(), pbr.roughness(), to.opacity), (metallic, roughness, 1.0)); + } + let undo = h.app.session.undo.len(); + assign(&mut h.app, &target, &looks[0], &to, false).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + assert_eq!(h.app.session.doc.appearances.bodies.get("Subject"), h.app.session.doc.appearances.bodies.get("Other")); + clear(&mut h.app, &target, &to).unwrap(); + assert!(h.app.session.doc.appearances.bodies.is_empty()); + assert!(chains(&mut h.app, &target).unwrap().iter().all(|c| c[3].as_ref().is_some_and(|l| l.name == "Steel"))); + assert_eq!(h.app.run("component.properties", json!({})).unwrap(), mass); +} + +#[test] +fn appearance_inspector_real_controls_switch_targets_inspect_chain_and_edit_finish() { + use solidcraft_engine::{Sel, geom::Vec3}; + let mut h = fixture(); + h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap(); + let face = h.app.run("model.faces", json!({"body":"Subject"})).unwrap()["faces"] + .as_array() + .unwrap() + .iter() + .find(|f| f["point"][2] == 10.0) + .unwrap()["index"] + .as_u64() + .unwrap() as usize; + h.app.session.selection = vec![Sel::Face { body: "Subject".into(), index: face, point: Vec3::new(10.0, 7.0, 10.0) }]; + h.frames(2); + h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); + let before = h.app.session.doc.to_json(); + h.step(&json!({"click":{"handle":"render:appearance:chain-menu"}})).unwrap(); + h.step(&json!({"click":{"handle":"render:appearance:chain:body"}})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); + appearance_inspector_capture(&mut h, "face"); + h.frames(3); + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":format!("dialog:{}:{}",h.app.tr("render.inspector_finish"),h.app.tr("render.inspector_metal"))}})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + assert_eq!(h.app.session.doc.appearances.bodies["Subject"].pbr.unwrap().metallic(), 1.0); + let roughness = crate::scenario::rect_of(&format!("dialog:scalar:{}", h.app.tr("appearance.roughness"))).unwrap().center(); + let drag_undo = h.app.session.undo.len(); + h.step(&json!({"drag":[[roughness.x,roughness.y],[roughness.x+20.0,roughness.y]],"steps":12})).unwrap(); + assert_eq!(h.app.session.undo.len(), drag_undo + 1, "a multi-frame field edit is one undo step"); + assert_ne!(h.app.session.doc.appearances.bodies["Subject"].pbr.unwrap().roughness(), 0.32); + let edited_undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":format!("dialog::{}",h.app.tr("render.pick_body"))}})).unwrap(); + assert!(h.app.ui.pick_bodies); + assert_eq!(h.app.session.undo.len(), edited_undo); + h.step(&json!({"click":{"handle":format!("dialog::{}",h.app.tr("render.pick_component"))}})).unwrap(); + assert!(h.app.ui.pick_components); + assert!(h.widget(h.app.tr("render.inspector_pick_target")).is_some(), "root bodies have no component override target"); + h.step(&json!({"click":{"handle":format!("dialog::{}",h.app.tr("render.pick_face"))}})).unwrap(); + assert!(!h.app.ui.pick_components && !h.app.ui.pick_bodies); + h.step(&json!({"click":{"handle":format!("dialog::{}",h.app.tr("render.pick_body"))}})).unwrap(); + assert_eq!(h.app.session.undo.len(), edited_undo); + appearance_inspector_capture(&mut h, "body"); + h.app.session.selection.clear(); + h.frames(3); + assert!(h.widget(h.app.tr("render.base_appearance")).is_some()); + appearance_inspector_capture(&mut h, "explicit-target"); +} + +#[test] +fn appearance_inspector_mixed_fields_are_inert_until_edited_and_accept_the_first_value() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.app.run("solid.box", json!({"body_name":"Other","length":5,"width":5,"height":5,"corner":[30,0,0]})).unwrap(); + for (name, opacity) in [("Subject", 0.25), ("Other", 0.75)] { + h.app.run("appearance.assign", json!({"bodies":[name],"color":"#123456","opacity":opacity})).unwrap(); + } + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }, Sel::Body { name: "Other".into() }]; + h.frames(2); + h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + let field = format!("dialog:scalar:{}", h.app.tr("render.inspector_opacity")); + h.step(&json!({"click":{"handle":field}})).unwrap(); + h.step(&json!({"key":"Tab"})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before, "leaving Mixed without editing must be inert"); + assert_eq!(h.app.session.undo.len(), undo); + h.step(&json!({"click":{"handle":field}})).unwrap(); + h.step(&json!({"text":"NaN"})).unwrap(); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before, "invalid input must not set mixed targets"); + assert_eq!(h.app.session.undo.len(), undo); + h.step(&json!({"click":{"handle":field}})).unwrap(); + h.step(&json!({"text":"0.25"})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo, "typing keeps a local draft until commit"); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + for name in ["Subject", "Other"] { + assert_eq!(h.app.session.doc.appearances.bodies[name].opacity, 0.25); + } + h.app.run("edit.undo", json!({})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); +} + +#[test] +fn appearance_inspector_optical_colour_and_opacity_edits_commit_once_with_shared_bounds() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.app + .run( + "appearance.assign", + json!({"bodies":["Subject"],"color":"#123456", + "pbr":{"metallic":0.2,"roughness":0.4,"dielectric_ior":1.5}}), + ) + .unwrap(); + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + h.frames(2); + h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); + let mass = h.app.run("component.properties", json!({})).unwrap(); + for (key, text) in [("appearance.metallic", "2"), ("appearance.roughness", "0"), ("render.inspector_opacity", "0.25")] { + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":format!("dialog:scalar:{}",h.app.tr(key))}})).unwrap(); + h.step(&json!({"text":text})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1, "{key}"); + let look = &h.app.session.doc.appearances.bodies["Subject"]; + match key { + "appearance.metallic" => assert_eq!(look.pbr.unwrap().metallic(), 1.0), + "appearance.roughness" => assert_eq!(look.pbr.unwrap().roughness(), 0.045), + _ => assert_eq!((look.opacity, look.pbr), (0.25, None)), + } + } + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":format!("dialog:scalar:{}",h.app.tr("render.appearance_editor.ior"))}})).unwrap(); + h.step(&json!({"text":"3.5"})).unwrap(); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + let look = &h.app.session.doc.appearances.bodies["Subject"]; + assert_eq!((look.pbr.unwrap().dielectric_ior(), look.opacity), (3.0, 1.0)); + h.step(&json!({"click":{"handle":format!("dialog:color:{}",h.app.tr("render.inspector_colour"))}})).unwrap(); + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":"color:channel:R"}})).unwrap(); + h.step(&json!({"text":"200"})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + assert_eq!(h.app.session.doc.appearances.bodies["Subject"].color[0], 200); + assert_eq!(h.app.run("component.properties", json!({})).unwrap(), mass); +} + +#[test] +fn appearance_inspector_hex_edits_validate_and_commit_once() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap(); + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + h.frames(3); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + let hex = format!("dialog:color_hex:{}", h.app.tr("render.inspector_colour")); + h.step(&json!({"click":{"handle":hex}})).unwrap(); + h.step(&json!({"key":"A","cmd":true,"ctrl":true})).unwrap(); + h.step(&json!({"text":"#GG0000"})).unwrap(); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), before); + h.step(&json!({"click":{"handle":hex}})).unwrap(); + h.step(&json!({"key":"A","cmd":true,"ctrl":true})).unwrap(); + h.step(&json!({"text":"#123456"})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.doc.appearances.bodies["Subject"].color, [0x12, 0x34, 0x56]); + assert_eq!(h.app.session.undo.len(), undo + 1); + h.app.run("solid.box", json!({"body_name":"Other","length":5,"width":5,"height":5,"corner":[30,0,0]})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Other"],"color":"#ABCDEF"})).unwrap(); + h.app.session.selection.push(Sel::Body { name: "Other".into() }); + h.frames(3); + let mixed_before = h.app.session.doc.to_json(); + h.step(&json!({"click":{"handle":hex}})).unwrap(); + h.step(&json!({"key":"Tab"})).unwrap(); + assert_eq!(h.app.session.doc.to_json(), mixed_before); + h.step(&json!({"click":{"handle":hex}})).unwrap(); + h.step(&json!({"key":"A","cmd":true,"ctrl":true})).unwrap(); + h.step(&json!({"text":"#123456"})).unwrap(); + h.step(&json!({"key":"Enter"})).unwrap(); + assert_eq!(h.app.session.doc.appearances.bodies["Other"].color, [0x12, 0x34, 0x56]); +} + +#[test] +fn appearance_inspector_component_and_face_overrides_remove_to_material_from_real_controls() { + use solidcraft_engine::{Sel, geom::Vec3}; + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1000})); + h.app.run("component.create", json!({"name":"Part"})).unwrap(); + h.app.run("solid.box", json!({"body_name":"Subject","length":20,"width":15,"height":10})).unwrap(); + h.app.run("material.assign", json!({"bodies":["Subject"],"material":"Steel"})).unwrap(); + h.app.run("appearance.assign", json!({"components":["Part"],"appearance":"ABS - Blue"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap(); + h.app.run("appearance.assign", json!({"body":"Subject","faces":[[10,7,10]],"appearance":"Copper"})).unwrap(); + let face = h.app.run("model.faces", json!({"body":"Subject"})).unwrap()["faces"] + .as_array() + .unwrap() + .iter() + .find(|f| f["point"][2] == 10.0) + .unwrap()["index"] + .as_u64() + .unwrap() as usize; + h.app.session.selection = vec![Sel::Face { body: "Subject".into(), index: face, point: Vec3::new(10.0, 7.0, 10.0) }]; + super::super::enter(&mut h.app, true).unwrap(); + h.frames(2); + h.step(&json!({"click":{"handle":"render:stage:look"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Appearance); + let mass = h.app.run("component.properties", json!({})).unwrap(); + for (step, name) in [("face", "Copper"), ("body", "ABS - Red"), ("component", "ABS - Blue"), ("material", "Steel")] { + let before = h.app.session.doc.to_json(); + h.step(&json!({"click":{"handle":"render:appearance:chain-menu"}})).unwrap(); + h.step(&json!({"click":{"handle":format!("render:appearance:chain:{step}")}})).unwrap(); + assert!(h.widget(name).is_some(), "inspecting {step} must show {name}"); + assert_eq!(h.app.session.doc.to_json(), before); + } + h.step(&json!({"click":{"handle":format!("dialog::{}",h.app.tr("render.pick_component"))}})).unwrap(); + appearance_inspector_capture(&mut h, "component"); + h.frames(3); + for step in ["component", "body", "face"] { + h.step(&json!({"click":{"handle":format!("dialog::{}",h.app.tr(match step { + "component" => "render.pick_component", "body" => "render.pick_body", _ => "render.pick_face", + }))}})) + .unwrap(); + let undo = h.app.session.undo.len(); + h.step(&json!({"widget":"…"})).unwrap(); + h.step(&json!({"widget":h.app.tr("render.inspector_remove")})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1, "clearing {step}: {:?}", h.app.render_workspace.view.inspector.selection_appearance); + } + assert!(h.app.session.doc.appearances.is_empty()); + assert!(h.widget("Steel").is_some()); + assert_eq!(h.app.run("component.properties", json!({})).unwrap(), mass); +} + +// Opt-in evidence from the actual application UI, without requiring a window server. +fn appearance_inspector_capture(h: &mut Harness, name: &str) { + let Some(dir) = std::env::var_os("SOLIDCRAFT_INSPECTOR_EVIDENCE") else { return }; + std::fs::create_dir_all(&dir).unwrap(); + for dark in [false, true] { + h.app.preferences.theme = if dark { "dark" } else { "light" }.into(); + h.app.ui.dark = dark; + h.app.preferences.render_inspector_width = 305.0; + let ctx = egui::Context::default(); + crate::fonts::setup_bundled_fonts(&ctx); + let mut textures = std::collections::HashMap::new(); + let mut last = None; + for frame in 0..10 { + let mut output = ctx.run_ui( + egui::RawInput { + screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0))), + time: Some(frame as f64 / 10.0), + focused: true, + ..Default::default() + }, + |ui| { + h.app.logic(ui.ctx()); + h.app.ui(ui); + }, + ); + ui_kit::update_test_textures(&mut textures, &output.textures_delta); + output.textures_delta.clear(); + last = Some(output); + } + let output = last.unwrap(); + let card = crate::scenario::rect_of("render:inspector").unwrap(); + let crop = ui_kit::raster_ui(&ctx, output.shapes.clone(), output.pixels_per_point, card, &textures); + crop.save(std::path::Path::new(&dir).join(format!("{name}-{}-305.png", if dark { "dark" } else { "light" }))).unwrap(); + let image = ui_kit::raster_ui(&ctx, output.shapes, output.pixels_per_point, ctx.content_rect(), &textures); + image.save(std::path::Path::new(&dir).join(format!("{name}-{}.png", if dark { "dark" } else { "light" }))).unwrap(); + } +} + +#[test] +fn appearance_inspector_approved_layout_is_305_wide_and_preserves_stage_bounds() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.app.run("solid.box", json!({"body_name":"Boss","length":10,"width":10,"height":10,"corner":[30,0,0]})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Boss","Subject"],"appearance":"Aluminum - Anodized Blue"})).unwrap(); + h.app.run("material.assign", json!({"bodies":["Boss","Subject"],"material":"Steel"})).unwrap(); + h.app.run("select.filter", json!({"mode":"body"})).unwrap(); + h.app.session.selection = vec![Sel::Body { name: "Boss".into() }]; + h.app.preferences.render_inspector_width = 305.0; + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + h.frames(3); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + appearance_inspector_capture(&mut h, "approved"); + h.frames(3); + let inspector = crate::scenario::rect_of("render:inspector").unwrap(); + let browser = crate::scenario::rect_of("browser:card").unwrap(); + let shots = crate::scenario::rect_of("render:shots_strip").unwrap(); + assert!((inspector.width() - 305.0).abs() <= 1.0, "{inspector:?}"); + assert!((inspector.top() - browser.top()).abs() <= 1.0); + assert!(inspector.bottom() < shots.top()); + assert!(h.widget(&crate::i18n::format("render.inspector_all_users", &[("count", "2")])).is_some()); + assert!(h.widget(h.app.tr("render.inspector_save_library")).is_some()); + assert_eq!(h.app.session.doc.to_json(), before); + assert_eq!(h.app.session.undo.len(), undo); + h.step(&json!({"click":{"handle":"render:appearance:close"}})).unwrap(); + assert!(h.app.render_workspace.view.inspector.hidden); + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + h.frames(3); + assert!(!h.app.render_workspace.view.inspector.hidden); + h.step(&json!({"click":{"handle":format!("dialog:{}:{}",h.app.tr("render.inspector_finish"),h.app.tr("render.inspector_matte"))}})).unwrap(); + h.step(&json!({"click":{"handle":format!("dialog:action:{}", h.app.tr("render.inspector_reset"))}})).unwrap(); + assert_eq!(h.app.session.doc.appearances.bodies.get("Boss"), h.app.session.doc.appearances.bodies.get("Subject")); + assert!(h.app.session.doc.appearances.bodies.contains_key("Subject")); + assert_eq!(h.app.session.undo.len(), undo + 2); +} + +#[test] +fn appearance_editor_e2_sections_are_ordered_collapsed_and_expand_for_each_method() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.call("ui.resize", json!({"width":1440,"height":4000})); + h.app.preferences.render_inspector_width = 308.0; + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + let titles = [ + "render.inspector_edit", + "render.appearance_editor.glass", + "render.appearance_editor.coat", + "render.appearance_editor.maps", + "render.appearance_editor.saved", + "render.appearance_editor.reflections", + ]; + h.frames(3); + let before = h.app.session.doc.to_json(); + let mut last = 0.0; + for title in titles { + let rect = crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr(title))).unwrap(); + assert!(rect.top() > last, "{title} follows the preceding design section"); + last = rect.bottom(); + } + assert!(h.widget(h.app.tr("render.appearance_editor.glass_enable")).is_none(), "optics default to collapsed"); + assert!(h.widget(h.app.tr("render.appearance_editor.gpu_reason")).is_some()); + for title in titles.into_iter().skip(1) { + h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr(title))}})).unwrap(); + } + for method in [ImageMethod::Raster, ImageMethod::GpuRaytrace, ImageMethod::CpuRaytrace] { + h.app.render_workspace.view.method = method; + h.frames(3); + for key in [ + "render.appearance_editor.glass_enable", + "render.appearance_editor.recipe", + "render.appearance_editor.boundary", + "render.appearance_editor.thickness", + "render.appearance_editor.absorption", + "render.material_shadow", + "render.subsurface_enable", + "render.material_coat_enable", + "render.appearance_editor.weight", + "render.material_maps_enable", + "render.appearance_editor.base_colour", + "render.appearance_editor.normal", + "appearance.metallic", + "appearance.roughness", + "render.appearance_editor.origin", + "render.appearance_editor.u_repeat", + "render.appearance_editor.v_repeat", + "render.appearance_editor.normal_strength", + "render.appearance_editor.v_up", + "render.material_color_replace", + "render.appearance_editor.save", + "render.appearance_editor.remove", + "render.appearance_editor.replace", + "render.appearance_editor.revalidate", + "render.cpu_reflection_off", + "render.cpu_reflection_mirror", + "render.cpu_reflection_rough", + ] { + assert!(h.widget(h.app.tr(key)).is_some(), "expanded E2 is missing {key} for {method:?}"); + } + let tree = h.output.accesskit_update.as_ref().unwrap(); + let glass = tree.nodes.iter().find(|(_, n)| n.label() == Some(h.app.tr("render.appearance_editor.glass_enable"))).unwrap(); + assert_eq!(glass.1.is_disabled(), method != ImageMethod::GpuRaytrace); + assert_eq!(h.app.session.doc.to_json(), before); + assert!(h.app.render_workspace.view.materials.bindings.is_empty(), "opening never installs temporary bindings"); + } + for selection in + [Sel::Face { body: "Subject".into(), index: 0, point: solidcraft_engine::geom::Vec3::ZERO }, Sel::Body { name: "Subject".into() }] + { + h.app.session.selection = vec![selection]; + if matches!(h.app.session.selection.first(), Some(Sel::Body { .. })) { + h.app.ui.pick_components = true; + } + h.frames(3); + assert!(h.widget(h.app.tr("render.appearance_editor.body_reason")).is_some()); + for title in titles.into_iter().skip(1) { + assert!(crate::scenario::rect_of(&format!("dialog:section:{}", h.app.tr(title))).is_some()); + } + } +} + +#[test] +fn appearance_editor_reset_restores_each_picked_saved_look() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap(); + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + h.frames(3); + let saved = h.app.session.doc.appearances.bodies["Subject"].clone(); + let target = selection_appearance::targets(&h.app, ui_kit::LookStep::Body); + let changed = solidcraft_engine::doc::appearance::Look::custom([10, 20, 30], 0.3); + selection_appearance::assign(&mut h.app, &target, &saved, &changed, false).unwrap(); + h.frames(3); + selection_appearance::reset(&mut h.app); + assert_eq!(h.app.session.doc.appearances.bodies["Subject"], saved); +} + +#[test] +fn appearance_editor_saved_optics_removal_confirms_and_preserves_other_drafts() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.call("ui.resize", json!({"width":1440,"height":2200})); + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; + let set = setups::snapshot(&h.app).unwrap(); + let name = h.app.render_workspace.view.name.clone(); + h.app + .run( + "render.optics.bind", + json!({"name":name,"set":set,"body_index":0,"body_name":"Subject", + "optics":{"ior":1.5,"absorption_per_mm":[0.0,0.0,0.0],"boundary":"closed_mesh","thickness_mm":0.0,"shadow_transmission":false}, + "expected_revision":h.app.session.revision}), + ) + .unwrap(); + setups::load(&mut h.app); + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + h.frames(3); + h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.appearance_editor.saved"))}})).unwrap(); + let before = h.app.session.doc.to_json(); + h.step(&json!({"click":{"handle":"render:optics-remove"}})).unwrap(); + assert!(materials::confirmation_open(&h.app)); + assert!(h.widget(h.app.tr("render.appearance_editor.remove_title")).is_some()); + assert_eq!(h.app.session.doc.to_json(), before); + h.step(&json!({"click":{"handle":"dialog:cancel"}})).unwrap(); + assert!(!materials::confirmation_open(&h.app)); + assert_eq!(h.app.session.doc.to_json(), before); + h.step(&json!({"click":{"handle":"render:optics-remove"}})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Red"})).unwrap(); + h.frames(3); + assert!(!materials::confirmation_open(&h.app), "a changed document expires the pending confirmation"); + assert_eq!(h.app.session.doc.render.setups[&name].optics.len(), 1); + h.app.render_workspace.view.draft.width = 777; + h.frames(3); + h.step(&json!({"click":{"handle":"render:optics-remove"}})).unwrap(); + h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap(); + assert!(h.app.session.doc.render.setups[&name].optics.is_empty()); + assert!(h.app.render_workspace.view.draft.optics.is_empty()); + assert_eq!(h.app.render_workspace.view.draft.width, 777); + assert_eq!(h.app.session.doc.appearances.bodies["Subject"].name, "ABS - Red"); +} + +#[test] +fn appearance_editor_save_optics_keeps_other_temporary_bindings() { + use solidcraft_engine::Sel; + let mut h = fixture(); + h.call("ui.resize", json!({"width":1440,"height":2600})); + h.app.run("solid.box", json!({"body_name":"Other","length":5,"width":5,"height":5,"corner":[30,0,0]})).unwrap(); + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; + let other = materials::read_targets(&mut h.app).unwrap().into_iter().find(|t| t.name == "Other").unwrap(); + let mut binding = materials::Binding::new(other, &h.app); + binding.coat_enabled = true; + h.app.render_workspace.view.materials.bindings.push(binding); + h.app.render_workspace.view.materials.enabled = true; + h.app.session.selection = vec![Sel::Body { name: "Subject".into() }]; + h.app.run("view.render_stage", json!({"stage":"look"})).unwrap(); + h.frames(3); + h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.appearance_editor.glass"))}})).unwrap(); + h.step(&json!({"widget":h.app.tr("render.material_custom")})).unwrap(); + h.step(&json!({"click":{"handle":"render:glass:starter.glass.amber-tint"}})).unwrap(); + h.step(&json!({"click":{"handle":format!("dialog:section:{}",h.app.tr("render.appearance_editor.saved"))}})).unwrap(); + let geometry = h.app.run("component.properties", json!({})).unwrap(); + let undo = h.app.session.undo.len(); + h.step(&json!({"click":{"handle":"render:optics-save"}})).unwrap(); + let view = &h.app.render_workspace.view; + assert_eq!(h.app.session.doc.render.setups[&view.name].optics.len(), 1); + assert_eq!(view.materials.bindings.len(), 1); + assert_eq!(view.materials.bindings[0].target.name, "Other"); + assert!(view.materials.bindings[0].coat_enabled); + assert_eq!(h.app.session.undo.len(), undo + 1); + assert_eq!(h.app.run("component.properties", json!({})).unwrap(), geometry); +} diff --git a/crates/ui-egui/src/render_workspace_library.rs b/crates/ui-egui/src/render_workspace_library.rs index cc4c5bd4e..2af3a4183 100644 --- a/crates/ui-egui/src/render_workspace_library.rs +++ b/crates/ui-egui/src/render_workspace_library.rs @@ -373,7 +373,7 @@ fn preview_parameters(entry: &Value) -> Value { } source.clone() } -fn tile_sphere(entry: &Value) -> ui_kit::Sphere { +pub(super) fn tile_sphere(entry: &Value) -> ui_kit::Sphere { let p = preview_parameters(entry); let color = crate::dialogs_appearance::parse_color(&p["color"]).map(|[r, g, b]| egui::Color32::from_rgb(r, g, b)).unwrap_or(Tokens::get().body); let scalar = |key: &str, default: f64| p["pbr"][key].as_f64().filter(|v| v.is_finite()).unwrap_or(default).clamp(0.0, 1.0); @@ -461,6 +461,7 @@ pub(super) fn card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: egui::Rect) { bounds, fill_height: true, compact: crate::render_ui::compact(app, bounds.width()), + editor: false, enabled: matches!(stage, super::Stage::Look | super::Stage::Light), header_actions: (stage == super::Stage::Look).then_some(&mut actions as &mut dyn FnMut(&mut egui::Ui)), }, @@ -1037,6 +1038,7 @@ fn source_preview(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, id: &s ui.small(error); } } +#[cfg(test)] pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { stage_controls(app, ui); saved_surface_controls(app, ui); @@ -1252,19 +1254,40 @@ fn resource_controls(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut View, id: } } +#[cfg(test)] pub(super) fn saved_surface_controls(app: &mut SolveApp, ui: &mut egui::Ui) { let title = app.tr("render.saved_surfaces").to_string(); + ui_kit::section(ui, "render_saved_surfaces", &title, false, |ui| saved_surface_content(app, ui, None)); +} + +pub(super) fn saved_surface_target_controls( + app: &mut SolveApp, + ui: &mut egui::Ui, + target: Option<&solidcraft_engine::doc::render_surface::RenderBodyTarget>, +) { + if let Some(target) = target { + saved_surface_content(app, ui, Some(target)); + } +} + +fn saved_surface_content(app: &mut SolveApp, ui: &mut egui::Ui, target: Option<&solidcraft_engine::doc::render_surface::RenderBodyTarget>) { let bindings = app.render_workspace.view.draft.surfaces.clone(); - if bindings.is_empty() { + if !bindings.iter().any(|b| target.is_none_or(|t| t == &b.target)) { return; } - ui_kit::section(ui, "render_saved_surfaces", &title, false, |ui| { + { ui_kit::text(ui, app.tr("render.saved_surfaces_help"), ui_kit::Text::Note("render.saved_surfaces_help")); - for (index, binding) in bindings.iter().enumerate() { + if !app.render_workspace.view.materials.bindings.is_empty() { + ui_kit::text(ui, app.tr("render.saved_maps_runtime_conflict"), ui_kit::Text::Note("render.saved_maps_runtime_conflict")); + } + for (index, binding) in bindings.iter().enumerate().filter(|(_, b)| target.is_none_or(|t| t == &b.target)) { ui.label(format!( "{} - {} ({}): {:?}", binding.source.id, binding.target.definition, binding.target.feature, binding.target.occurrence_path )); + if ui_kit::button(ui, app.tr("render.inspector_replace"), ui_kit::Button::Normal).clicked() { + open_category(app, "surfaces"); + } let response = ui_kit::button(ui, app.tr("render.saved_surface_remove"), ui_kit::Button::Normal); crate::scenario::publish_handle(&format!("render:saved-surface-remove:{index}"), response.rect.center()); if response.clicked() { @@ -1277,9 +1300,10 @@ pub(super) fn saved_surface_controls(app: &mut SolveApp, ui: &mut egui::Ui) { } } } - }); + } } +#[cfg(test)] pub(super) fn stage_controls(app: &mut SolveApp, ui: &mut egui::Ui) { let title = app.tr("render.passive_stage").to_string(); ui_kit::section(ui, "render_passive_stage", &title, false, |ui| stage_content(app, ui)); @@ -1415,6 +1439,12 @@ mod studio_browser_tests { assert_eq!(h.app.render_workspace.view.library.selected.as_deref(), Some(id.as_str())); assert_eq!(h.app.render_workspace.view.inspector.page, super::super::inspector::Page::Appearance); assert_eq!(h.app.session.doc.to_json(), before, "browsing and selection must not apply appearances"); + // The selection-following editor takes precedence; library inspection is + // available under Advanced when no model target is selected. + h.app.run("select.clear", json!({})).unwrap(); + h.frames(3); + h.step(&json!({"click":{"handle":format!("dialog:section:{}", h.app.tr("render.inspector_advanced"))}})).unwrap(); + h.frames(3); h.step(&json!({"widget":h.app.tr("render.library_favorite")})).unwrap(); assert!(h.app.preferences.render_library_favorites.contains(&("appearances".into(), id.clone()))); h.step(&json!({"click":{"handle":"render:library-list"}})).unwrap(); diff --git a/crates/ui-egui/src/render_workspace_materials.rs b/crates/ui-egui/src/render_workspace_materials.rs index 11cf15de2..7f2fcd084 100644 --- a/crates/ui-egui/src/render_workspace_materials.rs +++ b/crates/ui-egui/src/render_workspace_materials.rs @@ -45,13 +45,6 @@ impl Boundary { Self::Closed => "closed_mesh", } } - fn label(self) -> &'static str { - match self { - Self::Thin => "render.material_thin", - Self::Box => "render.material_box", - Self::Closed => "render.material_closed", - } - } } #[derive(Clone, Debug)] @@ -176,6 +169,15 @@ pub(super) struct View { selected: Option, target_revision: Option, target_document: Option>, + pending_remove: Option, +} + +#[derive(Clone, Debug)] +struct PendingRemoval { + name: String, + target: solidcraft_engine::doc::render_surface::RenderBodyTarget, + revision: u64, + document: Weak, } pub(super) fn read_targets(app: &mut SolveApp) -> Result, String> { @@ -310,18 +312,10 @@ pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> { } fn vector(app: &SolveApp, ui: &mut egui::Ui, key: &str, values: &mut [f64; 3], range: std::ops::RangeInclusive, suffix: &str) -> bool { - ui.label(app.tr(key)); - let mut changed = false; - ui.horizontal(|ui| { - for value in values { - changed |= ui_kit::number_field(ui, value, range.clone(), 0.01, suffix).changed(); - } - }); - changed + ui_kit::row(ui, app.tr(key), |ui| ui_kit::vector3_field(ui, values, range, suffix)) } pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { - saved_optics_controls(app, ui); let title = app.tr("render.material_title").to_string(); ui_kit::section(ui, "render_materials", &title, false, |ui| { let mut view = std::mem::take(&mut app.render_workspace.view.materials); @@ -412,25 +406,7 @@ pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { app.set_status(e, true); } } - glass_controls(app, ui, binding); - coat_controls(app, ui, binding); - map_controls(app, ui, binding); - ui_kit::checkbox(ui, app.tr("render.optics_replace"), &mut binding.replace_saved_optics); - let save = ui_kit::button( - ui, - app.tr("render.optics_save"), - ui_kit::Button::Enabled(binding.glass_enabled && binding.current(app) && !binding.maps_enabled && !binding.coat_enabled), - ); - crate::scenario::publish_target("render:optics-save", save.rect); - if save.clicked() { - // The transient editor is taken out of app above. snapshot saves - // only the numerical draft; other local bindings remain visible - // and stale for explicit revalidation after this one mutation. - match save_optics(app, binding) { - Ok(()) => remove = true, - Err(error) => app.set_status(error, true), - } - } + remove |= editor_sections(app, ui, Some(binding)); remove |= ui_kit::button(ui, app.tr("render.material_remove"), ui_kit::Button::Normal).clicked(); } if remove && let Some(index) = view.selected.filter(|i| *i < view.bindings.len()) { @@ -438,110 +414,115 @@ pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { view.selected = None; } ui.small(app.tr("render.material_limits")); + view.pending_remove = app.render_workspace.view.materials.pending_remove.take().or(view.pending_remove.take()); app.render_workspace.view.materials = view; }); } fn glass_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) { - let title = app.tr("render.material_glass").to_string(); - ui_kit::section(ui, ("render_glass", binding.target.ordinal), &title, false, |ui| { - if ui_kit::checkbox(ui, app.tr("render.material_glass_enable"), &mut binding.glass_enabled).changed() && binding.glass_enabled { - binding.coat_enabled = false; - binding.maps_enabled = false; - } - ui.small(app.tr("render.material_glass_help")); - let recipes: Vec<_> = appearance_pack::STARTER_PACK.iter().filter(|p| matches!(p.recipe, Recipe::Glass(_))).collect(); - ui_kit::swatch_grid(ui, &recipes, |ui, preset| { - let [r, g, b] = preset.preview_color(); - let response = ui_kit::color_swatch( - ui, - egui::Id::new(("render_glass_recipe", binding.target.ordinal, preset.id)), - egui::Color32::from_rgb(r, g, b), - binding.glass.recipe == Some(preset.id), - preset.name, - preset.id, - ); - crate::scenario::publish_handle(&format!("render:glass:{}", preset.id), response.rect.center()); - if response.clicked() { - match Glass::recipe(preset.id) { - Ok(glass) => { - binding.glass = glass; - binding.glass_enabled = true; - binding.coat_enabled = false; - binding.maps_enabled = false; + if ui_kit::checkbox(ui, app.tr("render.appearance_editor.glass_enable"), &mut binding.glass_enabled).changed() && binding.glass_enabled { + binding.coat_enabled = false; + binding.maps_enabled = false; + } + let recipes: Vec<_> = appearance_pack::STARTER_PACK.iter().filter(|p| matches!(p.recipe, Recipe::Glass(_))).collect(); + let name = + binding.glass.recipe.and_then(appearance_pack::find).map_or_else(|| app.tr("render.material_custom").to_owned(), |p| p.name.to_owned()); + let recipe_label = app.tr("render.appearance_editor.recipe").to_owned(); + ui_kit::row(ui, &recipe_label, |ui| { + ui_kit::dropdown_menu(ui, "render_glass_recipe", &name, |ui| { + for preset in recipes { + let response = ui_kit::list_picker(ui, preset.id, preset.name, binding.glass.recipe == Some(preset.id)); + crate::scenario::publish_target(&format!("render:glass:{}", preset.id), response.rect); + if response.clicked() { + match Glass::recipe(preset.id) { + Ok(glass) => { + binding.glass = glass; + binding.glass_enabled = true; + binding.coat_enabled = false; + binding.maps_enabled = false; + } + Err(error) => app.set_status(error, true), } - Err(e) => app.set_status(e, true), - } - } - }); - let name = - binding.glass.recipe.and_then(appearance_pack::find).map_or_else(|| app.tr("render.material_custom").to_string(), |p| p.name.to_string()); - ui.label(name); - if !binding.glass_enabled { - return; - } - let glass = &mut binding.glass; - let label = app.tr(glass.boundary.label()).to_string(); - let mut changed = false; - ui_kit::dropdown_menu(ui, "render_glass_boundary", &label, |ui| { - for value in [Boundary::Closed, Boundary::Thin, Boundary::Box] { - if ui_kit::list_picker(ui, value.wire(), app.tr(value.label()), glass.boundary == value).clicked() { - glass.boundary = value; - glass.shadows = value == Boundary::Thin; - changed = true; ui.close(); } } }); - ui.label(app.tr("render.material_ior")); - changed |= ui_kit::number_field(ui, &mut glass.ior, 1.0..=3.0, 0.01, "").changed(); - changed |= vector(app, ui, "render.material_absorption", &mut glass.absorption, 0.0..=100.0, " /mm"); - if glass.boundary == Boundary::Thin { - ui.label(app.tr("render.material_thickness")); - changed |= ui_kit::number_field(ui, &mut glass.thickness, 0.0..=10000.0, 0.1, " mm").changed(); - } - changed |= ui_kit::checkbox(ui, app.tr("render.material_shadow"), &mut glass.shadows).changed(); - let mut scatter = glass.subsurface.is_some(); - if ui_kit::checkbox(ui, app.tr("render.subsurface_enable"), &mut scatter).changed() { - glass.subsurface = - scatter.then_some(solidcraft_engine::render::transmission::subsurface::Subsurface { scattering_per_mm: 0.1, anisotropy: 0.0 }); - changed = true; - } - if let Some(subsurface) = &mut glass.subsurface { - changed |= ui_kit::row(ui, app.tr("render.subsurface_rate"), |ui| { - ui_kit::number_field(ui, &mut subsurface.scattering_per_mm, 0.0..=100.0, 0.001, " /mm") - }) - .changed(); - changed |= ui_kit::row(ui, app.tr("render.volume_anisotropy"), |ui| { - ui_kit::number_field(ui, &mut subsurface.anisotropy, -0.95..=0.95, 0.01, "") - }) - .changed(); - ui_kit::text(ui, app.tr("render.subsurface_help"), ui_kit::Text::Note("render.subsurface_help")); - } - if changed { - glass.recipe = None; - } - ui.small(app.tr("render.material_certification")); }); + let glass = &mut binding.glass; + let mut changed = false; + ui.add_enabled_ui(binding.glass_enabled, |ui| { + let mut boundary = match glass.boundary { + Boundary::Closed => 0, + Boundary::Thin => 1, + Boundary::Box => 2, + }; + ui_kit::row(ui, app.tr("render.appearance_editor.boundary"), |ui| { + let labels = ["render.appearance_editor.closed", "render.appearance_editor.thin", "render.appearance_editor.box"].map(|key| app.tr(key)); + if ui_kit::segmented(ui, &mut boundary, &labels, ui_kit::Segments { compact: true, small: true, ..Default::default() }) { + glass.boundary = match boundary { + 1 => Boundary::Thin, + 2 => Boundary::Box, + _ => Boundary::Closed, + }; + glass.shadows = glass.boundary == Boundary::Thin; + if glass.boundary == Boundary::Thin { + glass.subsurface = None; + } + changed = true; + } + }); + changed |= + ui_kit::row(ui, app.tr("render.appearance_editor.ior"), |ui| ui_kit::number_field(ui, &mut glass.ior, 1.0..=3.0, 0.01, "")).changed(); + ui.add_enabled_ui(glass.boundary == Boundary::Thin, |ui| { + changed |= ui_kit::row(ui, app.tr("render.appearance_editor.thickness"), |ui| { + ui_kit::number_field(ui, &mut glass.thickness, 0.001..=10000.0, 0.1, " mm") + }) + .changed(); + }); + changed |= vector(app, ui, "render.appearance_editor.absorption", &mut glass.absorption, 0.0..=100.0, " /mm"); + changed |= ui_kit::checkbox(ui, app.tr("render.material_shadow"), &mut glass.shadows).changed(); + ui.add_enabled_ui(glass.boundary != Boundary::Thin, |ui| { + let mut scatter = glass.subsurface.is_some(); + if ui_kit::checkbox(ui, app.tr("render.subsurface_enable"), &mut scatter).changed() { + glass.subsurface = + scatter.then_some(solidcraft_engine::render::transmission::subsurface::Subsurface { scattering_per_mm: 0.1, anisotropy: 0.0 }); + changed = true; + } + if let Some(subsurface) = &mut glass.subsurface { + changed |= ui_kit::row(ui, app.tr("render.subsurface_rate"), |ui| { + ui_kit::number_field(ui, &mut subsurface.scattering_per_mm, 0.0..=100.0, 0.001, " /mm") + }) + .changed(); + changed |= ui_kit::row(ui, app.tr("render.volume_anisotropy"), |ui| { + ui_kit::number_field(ui, &mut subsurface.anisotropy, -0.95..=0.95, 0.01, "") + }) + .changed(); + } + }); + if glass.boundary != Boundary::Thin { + note(app, ui, "render.appearance_editor.thickness_reason"); + } + if glass.boundary == Boundary::Thin { + note(app, ui, "render.appearance_editor.scatter_reason"); + } + }); + if changed { + glass.recipe = None; + } + note(app, ui, "render.appearance_editor.glass_note"); + note(app, ui, "render.material_certification"); } fn coat_controls(app: &SolveApp, ui: &mut egui::Ui, binding: &mut Binding) { - let title = app.tr("render.material_coat").to_string(); - ui_kit::section(ui, ("render_coat", binding.target.ordinal), &title, false, |ui| { - ui.add_enabled_ui(!binding.glass_enabled, |ui| { - ui_kit::checkbox(ui, app.tr("render.material_coat_enable"), &mut binding.coat_enabled); - if binding.coat_enabled { - for (key, value, range) in [ - ("render.material_weight", &mut binding.coat.weight, 0.0..=1.0), - ("render.material_roughness", &mut binding.coat.roughness, 0.045..=1.0), - ("render.material_ior", &mut binding.coat.ior, 1.0..=3.0), - ] { - ui.label(app.tr(key)); - ui_kit::number_field(ui, value, range, 0.01, ""); - } - } - }); - ui.small(app.tr("render.material_coat_help")); + ui_kit::checkbox(ui, app.tr("render.material_coat_enable"), &mut binding.coat_enabled); + ui.add_enabled_ui(binding.coat_enabled, |ui| { + for (key, value, range) in [ + ("render.appearance_editor.weight", &mut binding.coat.weight, 0.0..=1.0), + ("appearance.roughness", &mut binding.coat.roughness, 0.045..=1.0), + ] { + ui_kit::row(ui, app.tr(key), |ui| ui_kit::mixed_slider(ui, value, range, None)); + } + ui_kit::row(ui, app.tr("render.appearance_editor.ior"), |ui| ui_kit::number_field(ui, &mut binding.coat.ior, 1.0..=3.0, 0.01, "")); }); } @@ -555,10 +536,10 @@ enum MapSlot { impl MapSlot { fn key(self) -> &'static str { match self { - Self::Color => "render.material_color_map", - Self::Normal => "render.material_normal_map", - Self::Roughness => "render.material_roughness_map", - Self::Metallic => "render.material_metallic_map", + Self::Color => "render.appearance_editor.base_colour", + Self::Normal => "render.appearance_editor.normal", + Self::Roughness => "appearance.roughness", + Self::Metallic => "appearance.metallic", } } fn field(self, maps: &mut Maps) -> &mut String { @@ -655,37 +636,32 @@ pub(super) fn install_library_surface(app: &mut SolveApp, id: &str, target: Targ } fn map_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) { - let title = app.tr("render.material_maps").to_string(); - ui_kit::section(ui, ("render_maps", binding.target.ordinal), &title, false, |ui| { - ui.add_enabled_ui(!binding.glass_enabled, |ui| { - ui_kit::checkbox(ui, app.tr("render.material_maps_enable"), &mut binding.maps_enabled); - if !binding.maps_enabled { - return; - } - for slot in [MapSlot::Color, MapSlot::Normal, MapSlot::Roughness, MapSlot::Metallic] { - let key = slot.key(); - ui.label(app.tr(key)); + ui_kit::checkbox(ui, app.tr("render.material_maps_enable"), &mut binding.maps_enabled); + ui.add_enabled_ui(binding.maps_enabled, |ui| { + for slot in [MapSlot::Color, MapSlot::Normal, MapSlot::Metallic, MapSlot::Roughness] { + let label = app.tr(slot.key()).to_owned(); + ui_kit::row(ui, &label, |ui| { let path = slot.field(&mut binding.maps); - ui_kit::bounded_cell_editor(ui, ui.id().with(key), path, "", false, 4096); - let label = app.tr("render.material_browse").to_string(); - if ui_kit::button(ui, label, ui_kit::Button::Enabled(binding.current(app))).clicked() { + let label = if path.is_empty() { + app.tr("render.appearance_editor.choose_image").to_owned() + } else { + std::path::Path::new(path).file_name().map(|s| s.to_string_lossy().into_owned()).unwrap_or_default() + }; + if ui_kit::button(ui, &label, ui_kit::Button::Enabled(binding.current(app))).clicked() { choose_map(app, binding, slot); } - } - let mut absolute = binding.maps.base_color_mode == BaseColorMode::Replace; - if ui_kit::checkbox(ui, app.tr("render.material_color_replace"), &mut absolute).changed() { - binding.maps.base_color_mode = if absolute { BaseColorMode::Replace } else { BaseColorMode::Modulate }; - } - ui_kit::checkbox(ui, app.tr("render.material_v_up"), &mut binding.maps.flip_v); - ui.label(app.tr("render.material_normal_strength")); - ui_kit::number_field(ui, &mut binding.maps.strength, 0.0..=1.0, 0.01, ""); - vector(app, ui, "render.material_origin", &mut binding.maps.frame.origin, -1e6..=1e6, " mm"); - vector(app, ui, "render.material_repeat_u", &mut binding.maps.frame.u, -1e6..=1e6, " mm"); - vector(app, ui, "render.material_repeat_v", &mut binding.maps.frame.v, -1e6..=1e6, " mm"); + }); + } + vector(app, ui, "render.appearance_editor.origin", &mut binding.maps.frame.origin, -1e6..=1e6, " mm"); + vector(app, ui, "render.appearance_editor.u_repeat", &mut binding.maps.frame.u, -1e6..=1e6, " mm"); + vector(app, ui, "render.appearance_editor.v_repeat", &mut binding.maps.frame.v, -1e6..=1e6, " mm"); + ui_kit::row(ui, app.tr("render.appearance_editor.normal_strength"), |ui| { + ui_kit::mixed_slider(ui, &mut binding.maps.strength, 0.0..=1.0, None) }); - ui.small(app.tr("render.material_maps_help")); - if binding.glass_enabled { - ui.small(app.tr("render.material_glass_exclusive")); + ui_kit::checkbox(ui, app.tr("render.appearance_editor.v_up"), &mut binding.maps.flip_v); + let mut absolute = binding.maps.base_color_mode == BaseColorMode::Replace; + if ui_kit::checkbox(ui, app.tr("render.material_color_replace"), &mut absolute).changed() { + binding.maps.base_color_mode = if absolute { BaseColorMode::Replace } else { BaseColorMode::Modulate }; } }); } @@ -694,7 +670,12 @@ fn save_optics(app: &mut SolveApp, binding: &Binding) -> Result<(), String> { if !binding.current(app) { return Err(app.tr("render.material_revalidate_needed").into()); } - let setup = super::setups::snapshot(app)?; + // A saved shot owns numerical intent, not the tab's local map/coat bindings. + // Keep those bindings intact while taking the portable shot snapshot. + let local = std::mem::take(&mut app.render_workspace.view.materials); + let setup = super::setups::snapshot(app); + app.render_workspace.view.materials = local; + let setup = setup?; let value = &binding.glass; let name = app.render_workspace.view.name.clone(); let optics = json!({"ior":value.ior,"absorption_per_mm":value.absorption,"boundary":value.boundary.wire(), @@ -704,30 +685,245 @@ fn save_optics(app: &mut SolveApp, binding: &Binding) -> Result<(), String> { json!({"name":name,"set":setup,"body_index":binding.target.ordinal,"body_name":binding.target.name, "optics":optics,"replace":binding.replace_saved_optics,"expected_revision":app.session.revision}), )?; + let local = std::mem::take(&mut app.render_workspace.view.materials); super::setups::load(app); + app.render_workspace.view.materials = local; Ok(()) } -fn saved_optics_controls(app: &mut SolveApp, ui: &mut egui::Ui) { - let bindings = app.render_workspace.view.draft.optics.clone(); - if bindings.is_empty() { - return; +fn note(app: &SolveApp, ui: &mut egui::Ui, key: &'static str) { + ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key)); +} + +/// The same body editor is used by the selection inspector and explicit-target page. +/// An unsupported selection gets an inert draft so every design control is inspectable. +fn editor_sections(app: &mut SolveApp, ui: &mut egui::Ui, binding: Option<&mut Binding>) -> bool { + let supported = binding.is_some(); + let mut placeholder = Binding::new(Target { stable_target: None, ordinal: 0, name: String::new() }, app); + let binding = binding.unwrap_or(&mut placeholder); + let reason = if !supported { + Some(app.tr("render.appearance_editor.body_reason").to_owned()) + } else if app.render_workspace.view.method != super::ImageMethod::GpuRaytrace { + Some(app.tr("render.appearance_editor.gpu_reason").to_owned()) + } else { + None + }; + let title = app.tr("render.appearance_editor.glass").to_owned(); + ui_kit::method_section(ui, "render:appearance:glass", &title, "GPU", reason.as_deref(), |ui| glass_controls(app, ui, binding)); + let opaque_reason = reason.clone().or_else(|| binding.glass_enabled.then(|| app.tr("render.material_glass_exclusive").to_owned())); + let title = app.tr("render.appearance_editor.coat").to_owned(); + ui_kit::method_section(ui, "render:appearance:coat", &title, "GPU", opaque_reason.as_deref(), |ui| coat_controls(app, ui, binding)); + let title = app.tr("render.appearance_editor.maps").to_owned(); + ui_kit::method_section(ui, "render:appearance:maps", &title, "GPU", opaque_reason.as_deref(), |ui| map_controls(app, ui, binding)); + let title = app.tr("render.appearance_editor.saved").to_owned(); + let removed = ui_kit::editor_section(ui, "render:appearance:saved", &title, false, |ui| { + ui.add_enabled_ui(supported, |ui| saved_controls(app, ui, binding)).inner + }) + .unwrap_or(false); + reflection_section(app, ui, supported.then_some(binding.target.name.as_str())); + removed +} + +/// Resolve one selected whole body against the authoritative captured scene. Never +/// broaden a face/component selection into a whole-body optics assignment. +pub(super) fn selection_controls(app: &mut SolveApp, ui: &mut egui::Ui, body: Option<&str>) { + let mut binding = body.and_then(|name| app.render_workspace.view.materials.bindings.iter().find(|b| b.target.name == name).cloned()); + if binding.is_none() + && let Some(name) = body + { + let current = app.render_workspace.view.materials.target_revision == Some(app.session.revision) + && app.render_workspace.view.materials.target_document.as_ref().is_some_and(|d| Weak::ptr_eq(d, &Arc::downgrade(&app.session.doc))); + if !current { + match read_targets(app) { + Ok(targets) => { + let view = &mut app.render_workspace.view.materials; + view.targets = targets; + view.target_revision = Some(app.session.revision); + view.target_document = Some(Arc::downgrade(&app.session.doc)); + } + Err(error) => app.set_status(error, true), + } + } + let mut targets = app.render_workspace.view.materials.targets.iter().filter(|t| t.name == name); + if let Some(target) = targets.next() + && targets.next().is_none() + { + binding = Some(Binding::new(target.clone(), app)); + } } - let title = app.tr("render.optics_saved").to_string(); - ui_kit::section(ui, "render_saved_optics", &title, false, |ui| { - ui_kit::text(ui, app.tr("render.optics_saved_help"), ui_kit::Text::Note("render.optics_saved_help")); - for (index, binding) in bindings.iter().enumerate() { - ui.label(format!("{} #{} · n={:.4}", binding.target.definition, binding.target.feature, binding.optics.ior)); - let remove = ui_kit::button(ui, app.tr("render.optics_remove"), ui_kit::Button::Enabled(!app.render_workspace.view.dirty)); - crate::scenario::publish_target(&format!("render:optics-remove:{index}"), remove.rect); - if remove.clicked() { - match app.run( - "render.optics.unbind", - json!({"name":app.render_workspace.view.name,"target":binding.target,"expected_revision":app.session.revision}), - ) { - Ok(_) => super::setups::load(app), - Err(error) => app.set_status(error, true), + let before = app.session.revision; + let removed = editor_sections(app, ui, binding.as_mut()); + if let Some(binding) = binding { + let view = &mut app.render_workspace.view.materials; + let existing = view.bindings.iter().position(|b| b.target == binding.target); + if removed { + if let Some(index) = existing { + view.bindings.remove(index); + } + } else if app.session.revision == before { + // Opening the editor alone never allocates an inactive assignment. + if binding.glass_enabled || binding.coat_enabled || binding.maps_enabled || existing.is_some() { + if existing.is_none() { + view.enabled = true; + } + if let Some(index) = existing { + if let Some(slot) = view.bindings.get_mut(index) { + *slot = binding; + } + } else if view.bindings.len() < MAX_BINDINGS { + view.bindings.push(binding); + } else { + app.set_status(app.tr("render.material_limits").to_owned(), true); } } } + } +} + +fn saved_controls(app: &mut SolveApp, ui: &mut egui::Ui, binding: &mut Binding) -> bool { + let saved = app + .render_workspace + .view + .draft + .optics + .iter() + .enumerate() + .find(|(_, saved)| binding.target.stable_target.as_ref() == Some(&saved.target)) + .map(|(index, saved)| (index, saved.target.clone())); + ui_kit::banner(ui, ui_kit::AssistantTone::Working, |ui| { + note( + app, + ui, + if saved.is_some() && !binding.active() { "render.appearance_editor.saved_state" } else { "render.appearance_editor.temporary" }, + ); + }); + let can_save = binding.glass_enabled + && binding.current(app) + && !binding.maps_enabled + && !binding.coat_enabled + && app.render_workspace.view.method == super::ImageMethod::GpuRaytrace; + let mut removed = false; + ui.horizontal(|ui| { + let save = ui_kit::button(ui, app.tr("render.appearance_editor.save"), ui_kit::Button::Enabled(can_save)); + crate::scenario::publish_target("render:optics-save", save.rect); + if save.clicked() { + match save_optics(app, binding) { + Ok(()) => removed = true, + Err(error) => app.set_status(error, true), + } + } + let remove = ui_kit::button(ui, app.tr("render.appearance_editor.remove"), ui_kit::Button::Enabled(saved.is_some())); + crate::scenario::publish_target("render:optics-remove", remove.rect); + if remove.clicked() + && let Some((index, target)) = saved + { + crate::scenario::publish_target(&format!("render:optics-remove:{index}"), remove.rect); + app.render_workspace.view.materials.pending_remove = Some(PendingRemoval { + name: app.render_workspace.view.name.clone(), + target, + revision: app.session.revision, + document: Arc::downgrade(&app.session.doc), + }); + } + }); + ui_kit::checkbox(ui, app.tr("render.appearance_editor.replace"), &mut binding.replace_saved_optics); + if !can_save { + note(app, ui, "render.appearance_editor.save_reason"); + } + if !binding.current(app) { + note(app, ui, "render.material_revalidate_needed"); + } + if ui_kit::button(ui, app.tr("render.appearance_editor.revalidate"), ui_kit::Button::Normal).clicked() + && let Err(error) = revalidate(app, binding) + { + app.set_status(error, true); + } + super::library::saved_surface_target_controls(app, ui, binding.target.stable_target.as_ref()); + removed +} + +fn reflection_section(app: &mut SolveApp, ui: &mut egui::Ui, body: Option<&str>) { + let reason = if body.is_none() { + Some(app.tr("render.appearance_editor.body_reason").to_owned()) + } else if app.render_workspace.view.method != super::ImageMethod::CpuRaytrace { + Some(app.tr("render.appearance_editor.cpu_reason").to_owned()) + } else { + None + }; + let title = app.tr("render.appearance_editor.reflections").to_owned(); + ui_kit::method_section(ui, "render:appearance:reflections", &title, "CPU", reason.as_deref(), |ui| { + use solidcraft_engine::render::job::ReflectionMode; + let name = body.unwrap_or_default(); + let mut mode = app + .render_workspace + .view + .raytrace + .reflections + .as_ref() + .and_then(|r| r.bodies.iter().find(|b| b.body == name)) + .map_or(0, |b| if b.mode == ReflectionMode::Mirror { 1 } else { 2 }); + let labels = ["render.cpu_reflection_off", "render.cpu_reflection_mirror", "render.cpu_reflection_rough"].map(|key| app.tr(key).to_owned()); + let body_label = app.tr("render.inspector_this_body").to_owned(); + ui_kit::row(ui, &body_label, |ui| { + if ui_kit::segmented( + ui, + &mut mode, + &labels.each_ref().map(String::as_str), + ui_kit::Segments { compact: true, small: true, ..Default::default() }, + ) { + let value = match mode { + 1 => Some(ReflectionMode::Mirror), + 2 => Some(ReflectionMode::RoughSpecular), + _ => None, + }; + if let Err(error) = super::cpu::set_reflection(app, name, value) { + app.set_status(error, true); + } + } + }); + if ui_kit::button(ui, app.tr("render.cpu_binding_confirm"), ui_kit::Button::Enabled(mode != 0)).clicked() + && let Err(error) = super::cpu::revalidate(app, name) + { + app.set_status(error, true); + } + let title = app.tr("render.appearance_editor.reflection_sampling").to_owned(); + ui_kit::editor_section(ui, "render:appearance:reflection-sampling", &title, false, |ui| super::cpu::reflection_sampling_controls(app, ui)); }); } + +pub(super) fn confirmation_open(app: &SolveApp) -> bool { + app.render_workspace.view.materials.pending_remove.is_some() +} + +pub(super) fn confirmation(app: &mut SolveApp, ctx: &egui::Context) { + let Some(pending) = app.render_workspace.view.materials.pending_remove.clone() else { return }; + if pending.revision != app.session.revision + || pending.name != app.render_workspace.view.name + || !Weak::ptr_eq(&pending.document, &Arc::downgrade(&app.session.doc)) + { + app.render_workspace.view.materials.pending_remove = None; + app.set_status(app.tr("render.review_stale").to_owned(), true); + return; + } + let title = app.tr("render.appearance_editor.remove_title").to_owned(); + let (closed, action) = ui_kit::Confirm::new(egui::Id::new("render_remove_optics"), "delete", &title) + .tone(ui_kit::Tone::Danger) + .actions(app.tr("render.appearance_editor.remove"), app.tr("render.keep_editing"), None) + .selected(ui_kit::Action::Cancel) + .show(ctx, true, |ui| { + note(app, ui, "render.appearance_editor.remove_note"); + }); + if closed || action == ui_kit::Action::Cancel { + app.render_workspace.view.materials.pending_remove = None; + } + if action == ui_kit::Action::Ok { + app.render_workspace.view.materials.pending_remove = None; + match app.run("render.optics.unbind", json!({"name":pending.name,"target":&pending.target,"expected_revision":pending.revision})) { + Ok(_) => { + // Removing one saved binding must preserve unsaved shot settings + // and unrelated temporary overrides on this tab. + app.render_workspace.view.draft.optics.remove(&pending.target); + } + Err(error) => app.set_status(error, true), + } + } +} diff --git a/crates/ui-egui/src/render_workspace_ribbon.rs b/crates/ui-egui/src/render_workspace_ribbon.rs index 2dcc8c327..c4401b414 100644 --- a/crates/ui-egui/src/render_workspace_ribbon.rs +++ b/crates/ui-egui/src/render_workspace_ribbon.rs @@ -173,6 +173,7 @@ pub(super) fn presentation(app: &SolveApp) -> solidcraft_engine::render::job::pr } fn focus(app: &mut SolveApp, page: inspector::Page, category: Option<&str>) { + app.render_workspace.view.inspector.hidden = false; app.render_workspace.view.inspector.page = page; if let Some(category) = category { library::open_category(app, category); @@ -207,7 +208,10 @@ fn navigate(app: &mut SolveApp, id: &str) -> Result<(), String> { action_ready(app, id)?; use inspector::Page; match id { - "render.aging.describe" => focus(app, Page::Aging, None), + "render.aging.describe" => { + focus(app, Page::Appearance, None); + inspector::reveal(app, "render:appearance:advanced"); + } "render.effects.describe" => focus(app, Page::Effects, None), "render.preset.resolve" | "render.preset.apply" => focus(app, Page::Scene, Some("native_scenes")), "render.settings.get" | "render.shot.duplicate" | "render.shot.rename" | "render.shot.remove" => { diff --git a/crates/ui-egui/src/render_workspace_studio.rs b/crates/ui-egui/src/render_workspace_studio.rs index 3b602f742..266e888cc 100644 --- a/crates/ui-egui/src/render_workspace_studio.rs +++ b/crates/ui-egui/src/render_workspace_studio.rs @@ -169,6 +169,7 @@ pub(super) fn lens_controls(app: &mut SolveApp, ui: &mut egui::Ui) { } } +#[cfg(test)] pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { finishing_controls(app, ui); lens_controls(app, ui); diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs index e450bd6f3..8a7fbd01c 100644 --- a/crates/ui-egui/src/render_workspace_tests.rs +++ b/crates/ui-egui/src/render_workspace_tests.rs @@ -595,8 +595,8 @@ fn clicked_render_workspace_saves_one_setup_and_restores_design_view() { let perspective = h.app.tr("render.perspective").to_string(); let save = h.app.tr("render.save_setup").to_string(); let back = h.app.tr("render.return_design").to_string(); + h.step(&json!({"click":{"handle":"render:stage:frame"}})).unwrap(); assert!(h.widget(&heading).is_some(), "{language}"); - h.step(&json!({"click":{"handle":"render:page:camera"}})).unwrap(); h.step(&json!({"widget":perspective})).unwrap(); assert!(!h.app.session.is_dirty(), "preview edits are staged"); h.step(&json!({"widget":save})).unwrap(); @@ -1751,6 +1751,7 @@ fn clicked_gpu_glass_recipe_stays_temporary_and_blocks_cpu_rendering() { h.app.session.mark_saved(); enter(&mut h.app, true).unwrap(); h.app.render_workspace.view.inspector.page = inspector::Page::All; + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; h.frames(3); let doc = h.app.session.doc.clone(); let title = h.app.tr("render.material_title").to_string(); @@ -1762,13 +1763,15 @@ fn clicked_gpu_glass_recipe_stays_temporary_and_blocks_cpu_rendering() { h.step(&json!({"click":{"handle":"dialog:list:render:material-body-0"}})).unwrap(); let add = h.app.tr("render.material_add").to_string(); h.step(&json!({"widget":add})).unwrap(); - let glass = h.app.tr("render.material_glass").to_string(); + let glass = h.app.tr("render.appearance_editor.glass").to_string(); h.step(&json!({"click":{"handle":format!("dialog:section:{glass}")}})).unwrap(); + h.step(&json!({"widget":h.app.tr("render.material_custom")})).unwrap(); h.step(&json!({"click":{"handle":"render:glass:starter.glass.amber-tint"}})).unwrap(); let binding = &h.app.render_workspace.view.materials.bindings[0]; assert!(binding.glass_enabled && !binding.coat_enabled && !binding.maps_enabled); assert_eq!(binding.glass.recipe, Some("starter.glass.amber-tint")); assert_eq!(binding.target.name, "Optics"); + h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; assert!(image_params(&h.app).is_err(), "CPU must not silently ignore active GPU material assignments"); assert!(Arc::ptr_eq(&doc, &h.app.session.doc)); assert!(!h.app.session.is_dirty()); @@ -2064,7 +2067,7 @@ fn clicked_setup_save_reload_and_switch_keep_gpu_numeric_intent_without_a_host() let open_section = |h: &mut Harness, handle: String| { for _ in 0..4 { let at = crate::scenario::handle_at(&handle).unwrap(); - let top = crate::scenario::rect_of("render:page:all").unwrap().bottom() + Tokens::get().space_8; + let top = crate::scenario::rect_of("render:inspector:header").unwrap().bottom() + Tokens::get().space_8; let bottom = crate::scenario::rect_of("render:job-footer").unwrap().top() - Tokens::get().space_8; if (top..=bottom).contains(&at.y) { break; @@ -2857,8 +2860,8 @@ fn render_workspace_stage_chips_dispatch_without_mutations_and_remember_each_doc assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history); assert!(h.app.render_workspace.view.job.is_none()); assert!(h.app.render_workspace.view.completed.is_none()); - // Stage selection focuses pages; it does not remove the other editors. - h.step(&json!({"click":{"handle":"render:page:diagnostics"}})).unwrap(); + // Stage selection preserves access to the other command-driven editors. + h.app.start("render.status"); h.frames(2); assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Diagnostics); } @@ -3033,7 +3036,7 @@ fn render_workspace_focus_tab_only_toggles_render_without_text_focus() { h.step(&json!({"key":"Tab"})).unwrap(); assert!(!h.app.shell.render_focus); h.frames(3); - h.step(&json!({"click":{"handle":"render:setup-name"}})).unwrap(); + h.step(&json!({"click":{"handle":"render:library-search"}})).unwrap(); assert!(h.ctx.egui_wants_keyboard_input()); h.step(&json!({"key":"Tab"})).unwrap(); assert!(!h.app.shell.render_focus); @@ -3433,13 +3436,13 @@ fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() { } else if key == "render:appearances" { "render:library-search" } else { - "render:page:output" + "dialog:editor_footer" }) .unwrap(); if key == "render:browser" { assert!(header.contains_rect(control), "Scene lens belongs in the title band"); } else { - assert!(control.top() >= header.bottom(), "navigation must be below the standard header: {control:?} {header:?}"); + assert!(control.top() >= header.bottom(), "editor controls must be below the standard header: {control:?} {header:?}"); } } @@ -4554,3 +4557,25 @@ fn render_workspace_shots_strip_geometry_and_theme_evidence() { } crate::theme::set_dark(previous); } + +#[test] +fn appearance_editor_hostile_optics_stay_finite_and_never_panic() { + let mut h = Harness::new(); + h.app.run("solid.box", json!({"length":10,"width":10,"height":3,"body_name":"Optics"})).unwrap(); + let target = materials::read_targets(&mut h.app).unwrap().remove(0); + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; + h.app.render_workspace.view.materials.enabled = true; + for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -1.0, 1e300] { + let mut binding = materials::Binding::new(target.clone(), &h.app); + binding.glass_enabled = true; + binding.glass.ior = value; + h.app.render_workspace.view.materials.bindings = vec![binding]; + assert!(materials::params(&h.app, &mut json!({})).is_err(), "hostile IOR {value}"); + } + let mut binding = materials::Binding::new(target, &h.app); + binding.glass_enabled = true; + binding.glass.boundary = materials::Boundary::Box; + binding.glass.subsurface = Some(solidcraft_engine::render::transmission::subsurface::Subsurface { scattering_per_mm: 0.1, anisotropy: 0.0 }); + h.app.render_workspace.view.materials.bindings = vec![binding]; + assert!(materials::params(&h.app, &mut json!({})).is_ok(), "box boundaries are closed dielectrics too"); +} diff --git a/crates/ui-egui/src/ui_kit/actions.rs b/crates/ui-egui/src/ui_kit/actions.rs index 299bc2e0c..ea26ac6ae 100644 --- a/crates/ui-egui/src/ui_kit/actions.rs +++ b/crates/ui-egui/src/ui_kit/actions.rs @@ -78,6 +78,17 @@ fn icon_button_presentation( response.on_hover_text(crate::i18n::tr_label(label)) } +/// Plain secondary text action, sharing the kit's normal hit height and typography. +pub(crate) fn text_button(ui: &mut Ui, label: &str, enabled: bool) -> Response { + let t = Tokens::get(); + let response = ui.add_enabled( + enabled, + egui::Button::new(RichText::new(label).size(t.font_label).color(t.form_ink)).frame(false).min_size(vec2(0.0, t.control_height)), + ); + scenario::publish_target(&format!("dialog:action:{label}"), response.rect); + response +} + /// Esc cancels; unowned Enter submits only when valid. Tokens: `none`. pub(crate) fn keyboard(ctx: &egui::Context, ok_enabled: bool) -> Action { if ctx.input(|i| i.key_pressed(egui::Key::Escape)) { diff --git a/crates/ui-egui/src/ui_kit/assistant.rs b/crates/ui-egui/src/ui_kit/assistant.rs index 40e522e99..4e14456a7 100644 --- a/crates/ui-egui/src/ui_kit/assistant.rs +++ b/crates/ui-egui/src/ui_kit/assistant.rs @@ -27,6 +27,17 @@ impl AssistantTone { pub(crate) fn assistant_badge(ui: &mut Ui, label: &str, tone: AssistantTone) -> Response { let t = Tokens::get(); let (ink, fill) = tone.colors(&t); + badge(ui, label, ink, fill) +} + +/// A compact informational chip in the active workspace colours. +pub(crate) fn workspace_chip(ui: &mut Ui, label: &str) -> Response { + let accent = crate::theme::TabAccent::current(ui.ctx()); + badge(ui, label, accent.ink, accent.soft) +} + +fn badge(ui: &mut Ui, label: &str, ink: egui::Color32, fill: egui::Color32) -> Response { + let t = Tokens::get(); let font = egui::FontId::proportional(t.font_caption); let width = ui.painter().layout_no_wrap(label.to_owned(), font.clone(), ink).size().x + t.space_12; let (rect, response) = ui.allocate_exact_size(vec2(width, t.form_close_size - t.space_4), egui::Sense::hover()); diff --git a/crates/ui-egui/src/ui_kit/color.rs b/crates/ui-egui/src/ui_kit/color.rs index 051027551..02d28bdd9 100644 --- a/crates/ui-egui/src/ui_kit/color.rs +++ b/crates/ui-egui/src/ui_kit/color.rs @@ -46,6 +46,39 @@ pub(crate) fn color_field(ui: &mut Ui, rgb: &mut [u8; 3]) -> Response { if ui.style().explanation_tooltips { response.on_hover_text(i18n::tr("color.edit")) } else { response } } +/// A colour swatch and editable hexadecimal field; incomplete text remains local until valid. +pub(crate) fn color_hex_field(ui: &mut Ui, rgb: &mut [u8; 3], mixed: Option<&str>) -> Response { + let id = ui.id().with(("color_hex", label(ui))); + let current = format!("#{:02X}{:02X}{:02X}", rgb[0], rgb[1], rgb[2]); + let is_mixed = mixed.is_some(); + let initial = || if is_mixed { String::new() } else { current.clone() }; + let (observed, was_mixed, mut hex) = ui.ctx().data(|d| d.get_temp::<([u8; 3], bool, String)>(id)).unwrap_or_else(|| (*rgb, is_mixed, initial())); + if observed != *rgb || was_mixed != is_mixed { + hex = initial(); + } + let mut response = color_field(ui, rgb); + if response.changed() { + hex = format!("#{:02X}{:02X}{:02X}", rgb[0], rgb[1], rgb[2]); + } + let mut field = super::bounded_cell_editor(ui, id.with("field"), &mut hex, mixed.unwrap_or("#RRGGBB"), false, 32); + scenario::publish_target(&format!("dialog:color_hex:{}", label(ui)), field.rect); + let mut valid = false; + if field.changed() { + let text = hex.trim(); + let digits = text.strip_prefix('#').unwrap_or(text); + if digits.len() == 6 + && let Ok(value) = u32::from_str_radix(digits, 16) + { + *rgb = [(value >> 16) as u8, (value >> 8) as u8, value as u8]; + valid = true; + response.mark_changed(); + } + } + field.flags.set(egui::response::Flags::CHANGED, valid); + ui.ctx().data_mut(|d| d.insert_temp(id, (*rgb, is_mixed, hex))); + response.union(field) +} + /// Popover body, also rendered independently by the gallery. Format is global, alpha is opaque. /// Tokens: form_card_width, control_*, form_*, on_accent, border, radius_xl, font_small, space_*. pub(crate) fn color_popover(ui: &mut Ui, rgb: &mut [u8; 3]) -> bool { diff --git a/crates/ui-egui/src/ui_kit/fields.rs b/crates/ui-egui/src/ui_kit/fields.rs index 353098e4c..44028acfe 100644 --- a/crates/ui-egui/src/ui_kit/fields.rs +++ b/crates/ui-egui/src/ui_kit/fields.rs @@ -168,15 +168,38 @@ pub(crate) fn searchable_dropdown( custom: Option<&str>, pending: Option<&str>, ) -> Option { + searchable_dropdown_with(ui, id, current, filter, options, SearchMenu { custom, pending, icon: None }) +} + +struct SearchMenu<'a> { + custom: Option<&'a str>, + pending: Option<&'a str>, + icon: Option<&'static str>, +} + +fn searchable_dropdown_with( + ui: &mut Ui, + id: &str, + current: &str, + filter: &mut String, + options: &[SearchOption<'_>], + menu: SearchMenu<'_>, +) -> Option { + let SearchMenu { custom, pending, icon } = menu; crate::prefs_search::note_current(ui, current); let mut chosen = None; let row = label(ui).to_owned(); - let response = egui::ComboBox::from_id_salt(id) - .width(dimension(ui.available_width())) + let combo = egui::ComboBox::from_id_salt(id) + .width(if icon.is_some() { Tokens::get().control_height } else { dimension(ui.available_width()) }) .height(Tokens::get().space_24 * 14.0) - .selected_text(current) - .icon(dropdown_arrow) - .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside) + .selected_text(if icon.is_some() { "" } else { current }) + .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside); + let combo = if let Some(icon) = icon { + combo.icon(move |ui, rect, _, _| crate::icons::paint_ink(ui.painter(), rect.shrink(Tokens::get().space_2), icon, Tokens::get().form_dim)) + } else { + combo.icon(dropdown_arrow) + }; + let response = combo .show_ui(ui, |ui| { let search = ui.add( text_input(egui::TextEdit::singleline(filter)) @@ -496,6 +519,17 @@ pub(crate) fn search_field(ui: &mut Ui, id: egui::Id, value: &mut String, hint: response } +/// Compact icon action opening the shared searchable menu. +pub(crate) fn searchable_icon_dropdown( + ui: &mut Ui, + icon: &'static str, + label: &str, + filter: &mut String, + options: &[SearchOption<'_>], +) -> Option { + searchable_dropdown_with(ui, "icon_search_menu", label, filter, options, SearchMenu { custom: None, pending: None, icon: Some(icon) }) +} + /// Behaviour of the one kit slider. Appearance is always owned by `slider`. /// Values/ranges stay in caller units; formatting never rounds saved values during drawing. pub(crate) struct Slider { @@ -503,11 +537,12 @@ pub(crate) struct Slider { pub format: fn(f64) -> String, pub show_value: bool, pub integer: bool, + pub workspace_accent: bool, } impl Default for Slider { fn default() -> Self { - Self { step: None, format: |v| format!("{v:.2}"), show_value: true, integer: false } + Self { step: None, format: |v| format!("{v:.2}"), show_value: true, integer: false, workspace_accent: false } } } @@ -522,6 +557,7 @@ pub(crate) fn slider(ui: &mut Ui, value: &mut T, range: super::scope(ui, |ui| { let t = Tokens::get(); ui.style_mut().drag_value_text_style = egui::TextStyle::Monospace; + let primary = if options.workspace_accent { crate::theme::TabAccent::current(ui.ctx()).ink } else { t.form_primary }; let limits = (range.start().to_f64(), range.end().to_f64()); let reserved = if options.show_value { // Reserve the actual formatted editor, including suffixes and localized Instant. @@ -568,8 +604,8 @@ pub(crate) fn slider(ui: &mut Ui, value: &mut T, range: let fraction = if limits.1 != limits.0 { ((value.to_f64() - limits.0) / (limits.1 - limits.0)).clamp(0.0, 1.0) as f32 } else { 0.0 }; let center = egui::pos2(egui::lerp(track.x_range(), fraction), track.center().y); ui.painter().rect_filled(track, t.control_radius, t.dialog_rule); - ui.painter().rect_filled(egui::Rect::from_min_max(track.min, egui::pos2(center.x, track.bottom())), t.control_radius, t.form_primary); - ui.painter().circle(center, t.space_8, t.control_fill, egui::Stroke::new(t.space_2, t.form_primary)); + ui.painter().rect_filled(egui::Rect::from_min_max(track.min, egui::pos2(center.x, track.bottom())), t.control_radius, primary); + ui.painter().circle(center, t.space_8, t.control_fill, egui::Stroke::new(t.space_2, primary)); publish(ui, &response, egui::WidgetType::Slider); response.widget_info(|| egui::WidgetInfo::slider(ui.is_enabled(), value.to_f64(), crate::i18n::tr_label(label(ui)))); scenario::publish_rect(&format!("dialog:slider_track:{}", label(ui)), slider); @@ -578,14 +614,68 @@ pub(crate) fn slider(ui: &mut Ui, value: &mut T, range: }) } +/// Shared slider with a compact mixed-aware value editor at the right. +/// The caller owns commit timing, just as for `mixed_scalar_field`. +pub(crate) fn mixed_slider(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive, mixed: Option<&str>) -> Response { + let t = Tokens::get(); + ui.horizontal(|ui| { + let width = if mixed.is_some() { t.space_24 * 2.0 } else { t.space_24 + t.space_12 }; + let track = ui + .allocate_ui(vec2((ui.available_width() - width - t.space_8).max(0.0), row_height()), |ui| { + slider(ui, value, range.clone(), Slider { show_value: false, workspace_accent: true, ..Default::default() }) + }) + .inner; + let field = ui + .allocate_ui(vec2(width, row_height()), |ui| { + ui.visuals_mut().widgets.inactive.bg_fill = egui::Color32::TRANSPARENT; + ui.visuals_mut().widgets.inactive.bg_stroke = egui::Stroke::NONE; + ui.visuals_mut().widgets.inactive.weak_bg_fill = egui::Color32::TRANSPARENT; + ui.style_mut().text_styles.insert(egui::TextStyle::Monospace, egui::FontId::monospace(t.font_label)); + scalar_field_impl(ui, value, range, mixed, true) + }) + .inner; + field.union(track) + }) + .inner +} + /// Locale-aware bounded scalar field, used for dimensionless material properties. pub(crate) fn scalar_field(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive) -> Response { + mixed_scalar_field(ui, value, range, None) +} + +/// A bounded scalar with a translated mixed-value placeholder. Typing or dragging +/// replaces the placeholder; commit ownership remains with the caller. +pub(crate) fn mixed_scalar_field(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive, mixed: Option<&str>) -> Response { + scalar_field_impl(ui, value, range, mixed, false) +} + +fn scalar_field_impl(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive, mixed: Option<&str>, plain: bool) -> Response { ui.style_mut().drag_value_text_style = egui::TextStyle::Monospace; - let response = ui.add_sized( - vec2(dimension(ui.available_width()), row_height()), - egui::DragValue::new(value).range(range).speed(0.01).custom_parser(crate::prefs::parse_number), - ); - Tokens::get().input_bevel(ui, &response); + let before = *value; + let parsed = std::cell::Cell::new(false); + let field = egui::DragValue::new(value).range(range).speed(0.01).custom_parser(|text| { + let value = crate::prefs::parse_number(text); + parsed.set(value.is_some()); + value + }); + let field = if plain { field.fixed_decimals(2) } else { field }; + let mut response = ui.add_sized(vec2(dimension(ui.available_width()), row_height()), |ui: &mut Ui| { + let field = if let Some(mixed) = mixed.filter(|_| !ui.ctx().is_being_dragged(ui.next_auto_id())) { + field.custom_formatter(move |_, _| mixed.to_owned()) + } else { + field + }; + ui.add(field) + }); + // Entering the first target's existing number still sets every mixed target. + // Merely focusing and leaving the translated placeholder is inert. + if mixed.is_some() { + response.flags.set(egui::response::Flags::CHANGED, *value != before || parsed.get()); + } + if !plain { + Tokens::get().input_bevel(ui, &response); + } scenario::publish_target(&format!("dialog:scalar:{}", label(ui)), response.rect); response } @@ -680,6 +770,26 @@ pub(crate) fn number_field( response } +/// Three bounded numeric components sharing the available control-column width. +/// Each field retains the standard parser, bevel and focus behaviour. Tokens: +/// number_field typography/chrome and the enclosing row's spacing. +pub(crate) fn vector3_field(ui: &mut Ui, values: &mut [f64; 3], range: std::ops::RangeInclusive, suffix: &str) -> bool { + let mut changed = false; + let label = super::layout::label(ui).to_owned(); + ui.columns(3, |columns| { + for (axis, (ui, value)) in columns.iter_mut().zip(values).enumerate() { + let width = ui.available_width().max(0.0); + ui.spacing_mut().text_edit_width = width; + ui.spacing_mut().interact_size.x = width; + ui.set_clip_rect(ui.clip_rect().intersect(ui.max_rect())); + let response = number_field(ui, value, range.clone(), 0.01, suffix); + scenario::publish_target(&format!("dialog:vector:{label}:{axis}"), response.rect); + changed |= response.changed(); + } + }); + changed +} + /// Growing plain-text message editor; its parent owns scrolling and Enter routing. /// Tokens: control_fill, form_inset, font_label. Use text_area for bounded data input. #[cfg(any(not(target_arch = "wasm32"), test))] diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs index 789f3f879..fead21e91 100644 --- a/crates/ui-egui/src/ui_kit/gallery.rs +++ b/crates/ui-egui/src/ui_kit/gallery.rs @@ -131,6 +131,43 @@ const ELEMENTS: &[Element] = &[ assert_eq!(tree_row(ui, ui.id().with(("tree_geometry", index)), row).rect, Some(rect)); } }), + element!("editor_section", |ui, _| { + editor_section(ui, "edit", "Edit", true, |ui| { + text(ui, "Colour", Text::Inline); + }); + }), + element!("method_section", |ui, _| { + method_section(ui, "gpu_section", "Glass and absorption", "GPU", Some("Needs GPU path tracing"), |ui| { + checkbox(ui, "Use physical glass", &mut false); + }); + }), + element!("vector3_field", |ui, _| { + row(ui, "Origin", |ui| vector3_field(ui, &mut [0.0; 3], -1e6..=1e6, " mm")); + }), + element!("pending_section", |ui, _| { + pending_section(ui, "upcoming", "Textures", "Soon"); + }), + element!("inspector_header", |ui, _| { + inspector_header(ui, "body", "Boss", "Body"); + }), + element!("workspace_chip", |ui, _| { + workspace_chip(ui, "Body"); + }), + element!("section_heading", |ui, _| { + section_heading(ui, "Edit"); + }), + element!("text_button", |ui, _| { + text_button(ui, "Reset", true); + }), + element!("color_hex_field", |ui, _| { + color_hex_field(ui, &mut [52, 92, 160], None); + }), + element!("mixed_slider", |ui, _| { + mixed_slider(ui, &mut 0.5, 0.0..=1.0, None); + }), + element!("searchable_icon_dropdown", |ui, _| { + searchable_icon_dropdown(ui, "spin", "Replace…", &mut String::new(), &[]); + }), element!("icon_label_action", |ui, _| { icon_label_action(ui, "Render Image", Some("play"), true, true); }), @@ -189,6 +226,35 @@ const ELEMENTS: &[Element] = &[ element!("catalog_footer", |ui, _| { catalog_footer(ui, "Click to apply · drag onto the model"); }), + element!("sphere_preview", |ui, _| { + sphere_preview( + ui, + "gallery:preview", + Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None }, + "Satin", + ["Library", "Used by 2"], + |ui| searchable_icon_dropdown(ui, "spin", "Replace…", &mut String::new(), &[]), + ); + }), + element!("sphere_preview_with_source", |ui, _| { + sphere_preview_with_source( + ui, + "gallery:preview-source", + Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None }, + "Satin", + "Used by 2", + |ui| { + compact_dropdown_menu(ui, "gallery:source", "In Design", |ui| { + text(ui, "Body look", Text::Inline); + }) + }, + |ui| text_button(ui, "Replace…", true), + ); + }), + element!("mixed_scalar_field", |ui, _| { + let mut value = 0.5; + mixed_scalar_field(ui, &mut value, 0.0..=1.0, Some("Mixed")); + }), element!("sphere_grid", |ui, _| { let sphere = Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None }; let tiles = ["gallery:grid:a", "gallery:grid:b", "gallery:grid:c"].map(|id| SphereTile { diff --git a/crates/ui-egui/src/ui_kit/layout.rs b/crates/ui-egui/src/ui_kit/layout.rs index 676f3e67d..ece263b3b 100644 --- a/crates/ui-egui/src/ui_kit/layout.rs +++ b/crates/ui-egui/src/ui_kit/layout.rs @@ -261,6 +261,15 @@ pub(crate) fn figure_rows( /// Memory belongs to the enclosing dialog ID; animation is avoided so each row keeps its fixed height. /// Persisted disclosure with a rule and uppercase title. Tokens: `control_height, space_2, radius_sm, hover, dialog_rule, form_section_icon_size, form_gap_y, font_caption, font_section_tracking, text_dim`. +/// Static section caption for an Inspector group that stays expanded. +#[cfg(test)] +pub(crate) fn section_heading(ui: &mut Ui, title: &str) { + let t = Tokens::get(); + let (rect, _) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), t.space_16), egui::Sense::hover()); + paint_text(ui, rect, &crate::i18n::tr_label(title).to_uppercase(), crate::fonts::semibold(t.font_caption), t.form_dim, true); + scenario::publish_rect(&format!("dialog:heading:{title}"), rect); +} + pub(crate) fn section(ui: &mut Ui, id: impl egui::AsIdSalt, title: &str, default_open: bool, add: impl FnOnce(&mut Ui) -> R) -> Option { section_count(ui, id, title, default_open, None::, add) } @@ -274,6 +283,48 @@ pub(crate) fn section_count( count: Option, add: impl FnOnce(&mut Ui) -> R, ) -> Option { + section_with_badge(ui, id, title, default_open, (count.map(|count| count.to_string()), false, false), add) +} + +/// Dense editor disclosure: 24 pt heading and 6 pt field gaps, with the same saved state and commands. +pub(crate) fn editor_section(ui: &mut Ui, id: impl egui::AsIdSalt, title: &str, default_open: bool, add: impl FnOnce(&mut Ui) -> R) -> Option { + section_with_badge(ui, id, title, default_open, (None, false, true), add) +} + +/// Compact editor disclosure with a method badge. Unsupported content stays +/// inspectable and disabled; its translated reason remains visible when folded. +/// Uses the editor section's spacing, typography and semantic theme tokens. +pub(crate) fn method_section( + ui: &mut Ui, + id: impl egui::AsIdSalt, + title: &str, + method: &str, + reason: Option<&str>, + add: impl FnOnce(&mut Ui) -> R, +) -> Option { + let result = + section_with_badge(ui, id, title, false, (Some(method.to_owned()), false, true), |ui| ui.add_enabled_ui(reason.is_none(), add).inner); + if let Some(reason) = reason { + super::text(ui, reason, super::Text::Note("method_section_reason")); + } + result +} + +/// A collapsed upcoming group with an inert disclosure and a trailing status chip. +#[cfg(test)] +pub(crate) fn pending_section(ui: &mut Ui, id: impl egui::AsIdSalt, title: &str, badge: &str) { + section_with_badge(ui, id, title, false, (Some(badge.to_owned()), true, true), |_| {}); +} + +fn section_with_badge( + ui: &mut Ui, + id: impl egui::AsIdSalt, + title: &str, + default_open: bool, + badge: (Option, bool, bool), + add: impl FnOnce(&mut Ui) -> R, +) -> Option { + let (count, pending, compact) = badge; // A search still walks the body, so a setting inside a folded section can match, without // leaving the folded heading on screen for every query. if crate::prefs_search::querying(ui) && crate::prefs_search::suppress_chrome(ui) && !crate::prefs_search::texts_hit(ui, &[title]) { @@ -283,8 +334,11 @@ pub(crate) fn section_count( let t = Tokens::get(); ui.add_space(t.space_2); let id = ui.make_persistent_id(id); - let mut open = searching || ui.ctx().data_mut(|data| data.get_persisted::(id)).unwrap_or(default_open); - let (rect, response) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), row_height()), egui::Sense::click()); + let mut open = !pending && (searching || ui.ctx().data_mut(|data| data.get_persisted::(id)).unwrap_or(default_open)); + let (rect, response) = ui.allocate_exact_size( + vec2(dimension(ui.available_width()), if compact { t.control_height - t.space_4 } else { row_height() }), + egui::Sense::click(), + ); crate::prefs_search::follow(ui, title, rect); if response.hovered() || response.has_focus() { ui.painter().rect_filled(rect.shrink2(vec2(0.0, 1.0)), t.radius_sm, t.hover); @@ -296,7 +350,7 @@ pub(crate) fn section_count( super::disclosure(ui.painter(), icon_rect.center(), open, t.form_dim); let text_rect = egui::Rect::from_min_max(egui::pos2((icon_rect.right() + t.form_gap_y).min(rect.right()), rect.top()), rect.max); let caption = crate::i18n::tr_label(title).to_uppercase(); - let badge_value = count.map(|count| count.to_string()); + let badge_value = count; let badge_width = badge_value.as_ref().map_or(0.0, |value| label_width(ui, value) + t.space_12); let reserved = if badge_value.is_some() { badge_width + t.space_12 } else { 0.0 }; let mut format = egui::TextFormat::simple(crate::fonts::semibold(t.font_caption), t.form_dim); @@ -310,9 +364,11 @@ pub(crate) fn section_count( let title_rect = egui::Rect::from_min_max(text_rect.min, egui::pos2(text_rect.left() + title_width, text_rect.bottom())); paint_text(ui, title_rect, &caption, crate::fonts::semibold(t.font_caption), t.form_dim, true); let mut rule_left = title_rect.right() + t.space_12; + let mut rule_right = rect.right(); if let Some(value) = badge_value { let width = badge_width.min((rect.right() - rule_left).max(0.0)); - let badge = egui::Rect::from_min_size(egui::pos2(rule_left.min(rect.right()), rect.center().y - t.space_10), vec2(width, t.space_10 * 2.0)); + let left = if pending { rect.right() - width } else { rule_left.min(rect.right()) }; + let badge = egui::Rect::from_min_size(egui::pos2(left, rect.center().y - t.space_10), vec2(width, t.space_10 * 2.0)); ui.painter().rect_filled(badge, t.radius_xl, t.dialog_footer); ui.painter().with_clip_rect(ui.clip_rect().intersect(badge)).text( badge.center(), @@ -322,21 +378,33 @@ pub(crate) fn section_count( t.form_dim, ); scenario::publish_rect(&format!("dialog:section:{title}:count"), badge); - rule_left = badge.right() + t.space_12; + if pending { + rule_right = badge.left() - t.space_12; + } else { + rule_left = badge.right() + t.space_12; + } } - if rule_left < rect.right() { - t.secondary_hline(ui.painter(), rule_left..=rect.right(), rect.center().y, t.dialog_rule); + if rule_left < rule_right { + t.secondary_hline(ui.painter(), rule_left..=rule_right, rect.center().y, t.dialog_rule); } response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::CollapsingHeader, ui.is_enabled(), open, crate::i18n::tr_label(title))); scenario::publish_handle(&format!("dialog:section:{title}"), response.rect.center()); scenario::publish_rect(&format!("dialog:section:{title}"), rect); - if response.clicked() && !searching { + if response.clicked() && !pending && !searching { open = !open; } if !searching { ui.ctx().data_mut(|data| data.insert_persisted(id, open)); } - open.then(|| ui.push_id(id, add).inner) + open.then(|| { + ui.push_id(id, |ui| { + if compact { + ui.spacing_mut().item_spacing.y = t.space_6; + } + add(ui) + }) + .inner + }) } /// Shortcut matches during Preferences search. Closed until opened, and closed again when the diff --git a/crates/ui-egui/src/ui_kit/look_chain.rs b/crates/ui-egui/src/ui_kit/look_chain.rs index b21f1c348..f22d67944 100644 --- a/crates/ui-egui/src/ui_kit/look_chain.rs +++ b/crates/ui-egui/src/ui_kit/look_chain.rs @@ -30,9 +30,9 @@ impl LookStep { pub fn look_chain(ui: &mut Ui, id: &str, labels: [&str; 4], looks: [Option; 4], active: LookStep) -> Option { let t = Tokens::get(); let width = ui.available_width().clamp(1.0, t.form_card_width * 2.0); - let side = t.space_24.min(width / 4.0); + let side = (t.control_height + t.space_6).min(width / 4.0); let ring_width = t.space_2.min(side / 8.0); - let height = side + t.space_8 + t.font_small + t.space_4; + let height = side + t.space_2 + t.font_small + t.space_2; let (rect, _) = ui.allocate_exact_size(vec2(width, height), Sense::hover()); let mut clicked = None; for (index, ((step, label), look)) in LookStep::ALL.into_iter().zip(labels).zip(looks).enumerate() { @@ -40,10 +40,12 @@ pub fn look_chain(ui: &mut Ui, id: &str, labels: [&str; 4], looks: [Option(ui: &mut Ui, label: &str, add: impl FnOnce(&mut Ui) -> R) -> egui::InnerResponse> { + Self::button_with(ui, |ui, _| super::text_button(ui, label, true), add) + } + pub(crate) fn item_button(ui: &mut Ui, item: &MenuItem<'_>, add: impl FnOnce(&mut Ui) -> R) -> egui::InnerResponse> { Self::button_with(ui, |ui, _| item.show(ui), add) } diff --git a/crates/ui-egui/src/ui_kit/mod.rs b/crates/ui-egui/src/ui_kit/mod.rs index e6e68a280..f93005899 100644 --- a/crates/ui-egui/src/ui_kit/mod.rs +++ b/crates/ui-egui/src/ui_kit/mod.rs @@ -79,8 +79,10 @@ pub(crate) use radial::{RADIAL_RADIUS, radial_menu}; pub(crate) use reports::*; pub(crate) use search::{CommandSearch, SearchBadge, SearchFieldGeometry}; pub(crate) use shortcuts::*; +#[cfg(test)] +pub(crate) use sphere::sphere_preview; pub use sphere::{FinishKind, Sphere, sphere_thumbnail}; -pub(crate) use sphere::{SphereTile, sphere_grid}; +pub(crate) use sphere::{SphereTile, sphere_grid, sphere_preview_with_source}; pub(crate) use stages::{StageAction, StageBar}; pub(crate) use status::*; pub(crate) use table::*; @@ -110,3 +112,5 @@ pub(crate) fn fits_steadily(ui: &egui::Ui, key: impl std::hash::Hash + std::fmt: ui.data_mut(|data| data.insert_temp(id, fits)); fits } + +pub(crate) use panel::{InspectorAction, inspector_header}; diff --git a/crates/ui-egui/src/ui_kit/panel.rs b/crates/ui-egui/src/ui_kit/panel.rs index 98d078f45..f5bb2f580 100644 --- a/crates/ui-egui/src/ui_kit/panel.rs +++ b/crates/ui-egui/src/ui_kit/panel.rs @@ -216,6 +216,57 @@ impl<'a> TopHeader<'a> { } } +/// Selection editor chrome, shared by floating Inspectors. Returns an action for registry dispatch. +#[derive(Clone, Copy)] +pub(crate) enum InspectorAction { + Close, + Remove, +} + +pub(crate) fn inspector_header(ui: &mut Ui, icon: &str, title: &str, kind: &str) -> Option { + let t = Tokens::get(); + let mut action = None; + let (rect, _) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), header_height()), egui::Sense::hover()); + let icon_rect = egui::Rect::from_center_size(egui::pos2(rect.left() + (t.space_16 + t.space_4), rect.center().y), vec2(t.space_14, t.space_14)); + crate::icons::paint_ink(ui.painter(), icon_rect, icon, crate::theme::TabAccent::current(ui.ctx()).ink); + let close_rect = egui::Rect::from_center_size( + egui::pos2(rect.right() - (t.space_16 + t.space_4), rect.center().y), + vec2(t.form_close_size, t.form_close_size), + ); + let close = super::icon_button_at(ui, close_rect, "close", crate::i18n::tr_label("Close")); + scenario::publish_target("render:appearance:close", close.rect); + if close.clicked() { + action = Some(InspectorAction::Close); + } + let more_rect = close_rect.translate(vec2(-t.control_height - t.space_4, 0.0)); + { + let mut more_ui = ui.new_child(egui::UiBuilder::new().id_salt("inspector_more").max_rect(more_rect)); + let ui = &mut more_ui; + super::Menu::text(ui, "…", |ui| { + if super::MenuItem::new("render:appearance:remove", crate::i18n::tr("render.inspector_remove"), "").show(ui).clicked() { + action = Some(InspectorAction::Remove); + ui.close(); + } + }); + } + let badge_width = ui.painter().layout_no_wrap(kind.to_owned(), crate::fonts::semibold(t.font_small), t.form_ink).size().x + t.space_16; + let badge = egui::Rect::from_center_size( + egui::pos2(more_rect.left() - t.space_8 - badge_width / 2.0, rect.center().y), + vec2(badge_width, t.space_16 + t.space_4), + ); + { + let mut badge_ui = ui.new_child(egui::UiBuilder::new().id_salt("inspector_kind").max_rect(badge)); + super::workspace_chip(&mut badge_ui, kind); + } + let name = egui::Rect::from_min_max(egui::pos2(icon_rect.right() + t.space_8, rect.top()), egui::pos2(badge.left() - t.space_8, rect.bottom())); + paint_text(ui, name, title, crate::fonts::semibold(t.font_label), t.form_ink, false); + ui.interact(name, ui.make_persistent_id("inspector_title"), egui::Sense::hover()) + .widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Label, ui.is_enabled(), title)); + t.secondary_hline(ui.painter(), rect.x_range(), rect.bottom(), t.dialog_rule); + scenario::publish_rect("dialog:header", rect); + action +} + /// A bounded docked or floating card. Uses form_card_width and the caller's tokenised frame. /// Window IDs and content scopes are retained so moving a card does not reset field focus. pub(crate) struct Panel<'a> { @@ -241,6 +292,7 @@ pub(crate) struct WorkspaceOptions<'a> { pub fill_height: bool, /// Use the minimum dock width without overwriting its remembered width. pub compact: bool, + pub editor: bool, pub enabled: bool, pub header_actions: Option<&'a mut dyn FnMut(&mut Ui)>, } @@ -298,6 +350,27 @@ impl<'a> Panel<'a> { .show(ui, add) } + /// One-row editor footer, pinned inside the shared workspace card. + pub(crate) fn editor_footer(ui: &mut Ui, key: &'static str, add: impl FnOnce(&mut Ui) -> R) -> egui::InnerResponse { + let t = Tokens::get(); + let host = super::Container::new(ui.ctx(), super::Surface::Viewport); + host.edge(key, super::Edge::Bottom) + .exact_size(t.form_footer_height) + .resizable(false) + .frame( + host.edge_frame(t.dialog_footer) + .outer_margin(egui::Margin::symmetric(-(t.space_12 as i8), 0)) + .inner_margin(egui::Margin::symmetric(t.space_12 as i8, t.space_8 as i8)), + ) + .show(ui, |ui| { + let band = ui.max_rect().expand2(vec2(t.space_12, t.space_8)); + ui.painter().rect_filled(band, egui::CornerRadius { nw: 0, ne: 0, sw: t.radius_xl, se: t.radius_xl }, t.dialog_footer); + t.secondary_hline(ui.painter(), band.x_range(), band.top(), t.dialog_rule); + scenario::publish_rect("dialog:editor_footer", band); + add(ui) + }) + } + /// Shared strip composition reserves actions at the right and scrolls choices at the left. pub(crate) fn strip_contents(ui: &mut egui::Ui, right: impl FnOnce(&mut egui::Ui), choices: impl FnOnce(&mut egui::Ui)) { ui.spacing_mut().item_spacing.x = Tokens::get().space_8; @@ -401,7 +474,13 @@ impl<'a> Panel<'a> { let ctx = ui.ctx().clone(); let mut move_side = None; let response = container.area(egui::Id::new(options.id)).fixed_pos(rect.min).movable(false).show(&ctx, |ui| { - let frame = container.frame(&ctx, t.panel, if left { crate::frame::Side::Left } else { crate::frame::Side::Right }).inner_margin(0.0); + let frame = container + .frame( + &ctx, + if options.editor { t.dialog_body } else { t.panel }, + if left { crate::frame::Side::Left } else { crate::frame::Side::Right }, + ) + .inner_margin(0.0); let content = container.show_frame(ui, frame, bounds, |ui| { let size = (rect.size() - frame.total_margin().sum()).max(egui::Vec2::ZERO); // Allocate the bounded host once; overflowing controls scroll/clip inside a child, @@ -451,6 +530,8 @@ impl<'a> Panel<'a> { egui::Frame::NONE .inner_margin(if tree { egui::Margin::symmetric(0, t.space_4 as i8) + } else if options.editor { + egui::Margin { left: t.space_12 as i8, right: t.space_12 as i8, top: t.space_10 as i8, bottom: 0 } } else { egui::Margin::same(if options.icon.is_empty() { t.space_10 } else { t.space_12 } as i8) }) @@ -459,7 +540,12 @@ impl<'a> Panel<'a> { if tree { ui.spacing_mut().item_spacing.y = 0.0; } - super::scope(ui, add) + super::scope(ui, |ui| { + if options.editor { + ui.spacing_mut().item_spacing.y = t.space_8; + } + add(ui) + }) }) .inner }); diff --git a/crates/ui-egui/src/ui_kit/reports.rs b/crates/ui-egui/src/ui_kit/reports.rs index 7d6cf4f59..a2410b727 100644 --- a/crates/ui-egui/src/ui_kit/reports.rs +++ b/crates/ui-egui/src/ui_kit/reports.rs @@ -30,11 +30,16 @@ pub(crate) fn report_divider(ui: &mut Ui, key: &str) { /// List border around a caller-owned virtualised viewport. Tokens: dialog_rule, control_radius, space_10. pub(crate) fn list_frame(ui: &mut Ui, key: &str, add: impl FnOnce(&mut Ui) -> R) -> R { + list_frame_filled(ui, key, egui::Color32::TRANSPARENT, 0.0, add) +} + +pub(super) fn list_frame_filled(ui: &mut Ui, key: &str, fill: egui::Color32, vertical: f32, add: impl FnOnce(&mut Ui) -> R) -> R { let t = Tokens::get(); let response = egui::Frame::NONE + .fill(fill) .stroke(t.container_border(t.dialog_rule)) .corner_radius(t.control_radius) - .inner_margin(egui::Margin::symmetric(t.space_10 as i8, 0)) + .inner_margin(egui::Margin::symmetric(t.space_10 as i8, vertical as i8)) .show(ui, |ui| { // Frame already subtracts its border and padding from the content width. ui.set_min_width(ui.available_width().max(0.0)); diff --git a/crates/ui-egui/src/ui_kit/slider_tests.rs b/crates/ui-egui/src/ui_kit/slider_tests.rs index b1ad106ab..d2d8c8480 100644 --- a/crates/ui-egui/src/ui_kit/slider_tests.rs +++ b/crates/ui-egui/src/ui_kit/slider_tests.rs @@ -26,6 +26,7 @@ fn every_slider_option_uses_the_same_token_thumb_in_both_themes() { format: if formatted { |v| format!("{:.0} %", v * 100.0) } else { |v| format!("{v:.2}") }, show_value, integer, + workspace_accent: false, }, ); }); diff --git a/crates/ui-egui/src/ui_kit/sphere.rs b/crates/ui-egui/src/ui_kit/sphere.rs index fbfe9444d..29cfbd37a 100644 --- a/crates/ui-egui/src/ui_kit/sphere.rs +++ b/crates/ui-egui/src/ui_kit/sphere.rs @@ -175,6 +175,67 @@ pub fn sphere_thumbnail(ui: &mut Ui, id: &str, sphere: Sphere, size: f32) -> Res response } +/// Inspector sample card. Content, chips and action reuse the kit's existing +/// controls; dimensions and the bordered card belong here rather than callers. +#[cfg(test)] +pub(crate) fn sphere_preview(ui: &mut Ui, id: &str, sphere: Sphere, name: &str, chips: [&str; 2], action: impl FnOnce(&mut Ui) -> R) -> R { + sphere_preview_with_source(ui, id, sphere, name, chips[1], |ui| super::text(ui, chips[0], super::Text::Inline), action) +} + +/// Sample card with an interactive source tag (for example an inheritance menu). +/// Keeps the standard sphere, two-line caption, usage chip and trailing action. +/// Tokens and dimensions are identical to the plain sample card. +pub(crate) fn sphere_preview_with_source( + ui: &mut Ui, + id: &str, + sphere: Sphere, + name: &str, + usage: &str, + source: impl FnOnce(&mut Ui) -> Response, + action: impl FnOnce(&mut Ui) -> R, +) -> R { + let t = Tokens::get(); + super::reports::list_frame_filled(ui, id, t.dialog_footer, t.space_10, |ui| { + let row = ui.horizontal(|ui| { + let side = t.control_height * 2.0 - t.space_8; + sphere_thumbnail(ui, id, sphere, side); + let text_width = (ui.available_width() - t.control_height - t.space_16).max(0.0); + ui.allocate_ui_with_layout(vec2(text_width, side), egui::Layout::top_down(egui::Align::Min), |ui| { + ui.spacing_mut().item_spacing.y = t.space_4; + ui.add_sized( + vec2(text_width, t.space_16), + egui::Label::new(egui::RichText::new(name).font(crate::fonts::semibold(t.font_label)).color(t.form_ink)) + .truncate() + .halign(egui::Align::Min), + ) + .on_hover_text(name); + let (line, _) = ui.allocate_exact_size(vec2(text_width, t.control_height), Sense::hover()); + let usage_width = (ui.painter().layout_no_wrap(usage.to_owned(), egui::FontId::proportional(t.font_caption), t.form_ink).size().x + + t.space_12) + .min((text_width - t.space_24 - t.space_8).max(0.0)); + let usage_rect = Rect::from_min_max(pos2(line.right() - usage_width, line.top()), line.max); + let source_rect = Rect::from_min_max(line.min, pos2((usage_rect.left() - t.space_4).max(line.left()), line.bottom())); + let mut source_ui = ui.new_child( + egui::UiBuilder::new().id_salt("sample_source").max_rect(source_rect).layout(egui::Layout::left_to_right(egui::Align::Center)), + ); + source_ui.set_clip_rect(ui.clip_rect().intersect(source_rect)); + let source = source(&mut source_ui); + scenario::publish_rect(&format!("{id}:chip:0"), source.rect.intersect(source_rect)); + let mut usage_ui = ui.new_child( + egui::UiBuilder::new().id_salt("sample_usage").max_rect(usage_rect).layout(egui::Layout::left_to_right(egui::Align::Center)), + ); + usage_ui.set_clip_rect(ui.clip_rect().intersect(usage_rect)); + let response = super::workspace_chip(&mut usage_ui, usage); + scenario::publish_rect(&format!("{id}:chip:1"), response.rect.intersect(usage_rect)); + }); + let response = ui.vertical(action); + scenario::publish_target(&format!("{id}:replace"), response.response.rect); + response.inner + }); + row.inner + }) +} + /// A catalog sample: 48 pt sphere in a 56 pt cell, two-line caption and optional /// usage badge. The surrounding chrome follows the active workspace accent. pub(crate) struct SphereTile<'a> { diff --git a/crates/ui-egui/src/ui_kit/sphere_tests.rs b/crates/ui-egui/src/ui_kit/sphere_tests.rs index 65a403305..b1e673867 100644 --- a/crates/ui-egui/src/ui_kit/sphere_tests.rs +++ b/crates/ui-egui/src/ui_kit/sphere_tests.rs @@ -1,5 +1,66 @@ use super::*; +#[test] +fn interactive_preview_keeps_source_usage_and_replace_inside_the_card() { + for dark in [false, true] { + crate::theme::set_dark(dark); + for width in [280.0, 305.0, 308.0, 356.0] { + let ctx = crate::fonts::test_context(); + crate::test_support::frame(&ctx, egui::RawInput::default(), |ui| { + ui.set_width(width); + super::super::scope(ui, |ui| { + sphere_preview_with_source( + ui, + "preview", + Sphere { color: Tokens::get().render_accent, kind: FinishKind::Metal, opacity: None }, + "Brushed aluminium", + "Used by 4", + |ui| super::super::compact_dropdown_menu(ui, "source", "In Design", |_| {}), + |ui| super::super::searchable_icon_dropdown(ui, "spin", "Replace…", &mut String::new(), &[]), + ); + }); + }); + let card = crate::scenario::rect_of("dialog:list:preview").unwrap(); + assert!(card.width() <= width + 1.0, "{card:?}"); + for child in ["preview", "preview:replace", "preview:chip:0", "preview:chip:1"] { + assert!(card.contains_rect(crate::scenario::rect_of(child).unwrap()), "{child}"); + } + } + } +} + +#[test] +fn preview_keeps_sample_chips_and_replace_inside_the_shared_card() { + for dark in [false, true] { + crate::theme::set_dark(dark); + for width in [280.0, 356.0] { + let ctx = crate::fonts::test_context(); + crate::test_support::frame(&ctx, egui::RawInput::default(), |ui| { + ui.set_width(width); + super::super::scope(ui, |ui| { + sphere_preview( + ui, + "preview", + Sphere { color: Tokens::get().render_accent, kind: FinishKind::Metal, opacity: None }, + "A long appearance label that must fit the card", + ["Library", "Used by 1000"], + |ui| super::super::searchable_icon_dropdown(ui, "spin", "Replace…", &mut String::new(), &[]), + ); + }); + }); + let card = crate::scenario::rect_of("dialog:list:preview").unwrap(); + let sample = crate::scenario::rect_of("preview").unwrap(); + let replace = crate::scenario::rect_of("preview:replace").unwrap(); + assert!(card.width() <= width + 1.0, "{card:?}"); + assert!(card.contains_rect(sample) && card.contains_rect(replace)); + assert!(replace.left() > sample.right()); + for chip in ["preview:chip:0", "preview:chip:1"] { + assert!(card.contains_rect(crate::scenario::rect_of(chip).unwrap())); + } + } + } +} + #[test] fn tiles_keep_three_columns_cell_sphere_badge_and_selection_in_both_themes() { for dark in [false, true] { diff --git a/crates/ui-egui/tests/scenarios/render_workspace_shell.json b/crates/ui-egui/tests/scenarios/render_workspace_shell.json index ac749d745..e8097f9b5 100644 --- a/crates/ui-egui/tests/scenarios/render_workspace_shell.json +++ b/crates/ui-egui/tests/scenarios/render_workspace_shell.json @@ -8,9 +8,10 @@ {"click":{"handle":"render:stage:light"}}, {"click":{"handle":"render:stage:frame"}}, {"click":{"handle":"render:stage:output"}}, + {"click":{"handle":"render:tree:output"}}, {"expect":{"disjoint":["render:browser:header","render:tree:environment"]}}, {"expect":{"disjoint":["render:browser:header","render:appearances:header"]}}, - {"expect":{"disjoint":["render:inspector:header","render:page:output"]}}, + {"expect":{"disjoint":["render:inspector:header","render:output-width"]}}, {"click":{"handle":"render:shots:hide"}}, {"expect":{"shown_handles":["render:shots:show"],"hidden_handles":["render:shots:hide"]}}, {"call":"ui.workspace","params":{"workspace":"design"}}, @@ -18,5 +19,6 @@ {"call":"ui.workspace","params":{"workspace":"render"}}, {"click":{"handle":"render:shots:show"}}, {"call":"ui.set","params":{"layout":"docked"}}, - {"expect":{"shown_handles":["render:shots:hide","render:stage:output","render:page:output"],"hidden_handles":["tab:RENDER"],"errors":0}} + {"click":{"handle":"render:tree:output"}}, + {"expect":{"shown_handles":["render:shots:hide","render:stage:output","render:output-width"],"hidden_handles":["tab:RENDER"],"errors":0}} ] diff --git a/docs/render-workspace.md b/docs/render-workspace.md index d665e4b41..8085eef4a 100644 --- a/docs/render-workspace.md +++ b/docs/render-workspace.md @@ -130,38 +130,52 @@ half-edge vectors specify their geometry in millimetres; radiance is linear RGB. An environment map replaces the constant environment term. The path integrator uses the published emitter/BSDF MIS contract. -### GPU image materials +### Appearance editor and body optics -The GPU image materials section assigns runtime optics to whole visible scene bodies. -Refresh the authoritative body list, explicitly choose a body, and add its assignment. -The captured ordinal and exact name must match; a document identity or revision change -requires explicit revalidation. A removed, renamed or reordered body cannot silently -receive another body's settings. The editor uses weak document identity references, so -stale assignments do not retain historical documents. The normal Appearance and material -library dialogs keep their existing behavior. +Picking a face, body or component opens Appearance. Its kind chips, look card and +Applies to scope lead to Edit: colour, finish, metallic, roughness, opacity and IOR. +The look card's source tag opens the inheritance chain. Reset restores the picked +target's values from when it was opened; Save to library uses the existing design +library export flow. -Glass, clear coat and planar maps have separate collapsible controls. Six original glass -recipes come directly from the starter pack: linear transmittance over the recipe's -reference distance becomes absorption per millimetre via `-ln(T) / distance`. Selecting -one never changes saved opacity or assigns a scalar appearance. The swatch shows the -recipe's transmittance, not a rendered preview. Manual IOR, RGB absorption, thin-sheet -thickness and straight-shadow transmission are available. Closed solids derive optical -distance from geometry; full topology, orientation, overlap and optical-boundary checks -run during GPU preparation. Successful Check does not certify those geometric properties. +Glass and absorption (GPU), Clear coat (GPU), Maps (GPU), Saved with this shot, +and Reflections (CPU) follow in that order and start collapsed. Unsupported +methods remain visible with an explanation; opening a section never changes the +renderer. Optical bindings currently target one whole visible body, so face, +component and multiple-body picks show the same controls disabled with a reason. +The Browser command has no Wear selection kind yet, so no Open Wear link is shown. -Clear coat exposes weight, roughness and IOR over the existing opaque base. Runtime maps -accept bounded local PNG/JPEG base-color sRGB and OpenGL +Y normal images, normal strength, -and orthogonal world-space origin/U/V vectors in millimetres. Each vector spans one full -repeat. The backend's 1024×1024 per-map, 16 MiB encoded-total and 128-repeat bounds remain. -Glass cannot share one body with coat or maps. Limits are eight glass bodies, 64 coat -bodies and 16 mapped bodies, within a maximum of 64 editor assignments. +The old Appearance page retains explicit target selection and the library/reference +and wear controls awaiting their own editors. Its body optics use the same sections +as the picked-body editor. Scene ordinal, exact name, stable target and document +identity are checked; a document revision change requires Revalidate this body. -All these controls are temporary per-document-tab state, explicitly labelled in the UI. -They are not saved in the design, render setup or portable material library. Disable the -overrides before choosing a CPU method; active GPU assignments cause Check/Start to -refuse a CPU request. Both buttons submit the same freshly validated runtime parameters, -and file contents are captured by the engine at that boundary. File-picker completion -checks the original document, revision and body identity before accepting the path. +Six original glass recipes use linear transmittance over a reference distance to +compute absorption per millimetre via -ln(T) / distance. Glass exposes boundary, +IOR, thickness, RGB absorption, straight shadow transmission and closed-solid +interior scattering. Thickness is disabled for closed glass, which uses geometric +distance. Glass cannot share a body with coat or maps. Full topology, orientation, +overlap and optical-boundary checks run during GPU preparation; Check does not +certify those properties. + +Clear coat retains weight, roughness and IOR. Maps retain the bounded PNG/JPEG +picker flow for base colour, normal, metallic and roughness images, world-space +origin and U/V repeat vectors, normal strength, V orientation and base replacement. +The backend's map-size, encoded-byte, repeat and assignment limits still apply. +File-picker completion checks the original document, revision and body identity. + +These local overrides are temporary on the document tab. Save these optics uses +render.optics.bind to save physical glass with the shot; replacement requires the +explicit Replace this body's saved optics checkbox. Coat and local image maps +remain temporary, and the save action explains that limit. Remove saved opens the +shared Remove saved optics? confirmation before render.optics.unbind; stale +confirmations cannot affect a changed document. Saved authored surface bindings +remain manageable in Saved with this shot. Reflections retains this body's +Off/Mirror/Rough CPU binding and explicit target confirmation. + +Active GPU overrides still cause Check/Start to refuse a CPU request. Both buttons +submit the same freshly validated runtime parameters and the engine captures file +contents at that boundary. Check and Start build the same request from the current product camera, size and selected method, including when Render Result is open. Every click revalidates host @@ -398,3 +412,16 @@ as before; the focus state is available to a later Inspector change. Look expands Objects, Light expands Lights and Environment, and Frame expands Shots. Output leaves expansion unchanged. Stages preserve selection and never lock rows or prevent manual expansion. + +## Appearance editor + +Look shows one Appearance editor with scope, current look, the four-step look +chain and Edit controls. There is no Inspector page strip. Applies to chooses the +selected target or every exact user of the look; mixed values remain inert until +edited. Edit contains colour/hex, finish and metallic/roughness/opacity sliders. +Advanced reuses the existing surface library, optical bindings, glass, clear coat, +texture-map, reflection and aging controls. The separate Textures disclosure is +marked Soon. The shared footer exports the design library through `library.export` +and resets the current target's override through `appearance.assign`. +`view.render_inspector {visible}` controls transient per-document visibility; +selecting a stage reopens the editor. Selection focus routing is deferred. diff --git a/docs/ui-kit.md b/docs/ui-kit.md index e63987193..5de5f3ce7 100644 --- a/docs/ui-kit.md +++ b/docs/ui-kit.md @@ -146,7 +146,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera | `searchable_dropdown`, `SearchOption` | Filtered choices, custom-value action and pending message | dropdown tokens | | `selection_field`, `Selection` | Selection chip with explicit `active` and `filled` state, in three looks: the active input (where the next pick goes) has a `form_primary` border and `selected_bg` tint; a filled inactive one a quiet neutral tint, a stronger neutral border and its count in `form_ink`; an empty inactive one the plain control with a dim prompt | `selected_bg/ink`, `form_primary/ink/dim`, `control_*`, `form_inset`, `space_2/8/24` | | `value_pair` | Paired captions/expressions; optional independent field names | row/field tokens, `space_8` | -| `fraction_field`, `scalar_field` | Locale-aware bounded dimensionless values; scalar fields fill their control column | form control/font tokens | +| `fraction_field`, `scalar_field`, `mixed_scalar_field` | Locale-aware bounded dimensionless values; scalar fields fill their control column; the mixed variant accepts a translated placeholder | form control/font tokens | | `number_field` | Integer/decimal field with caller range, drag speed and suffix | form control/font tokens | | `length_field`, `angle_field` | Length in design units, angle in degrees | form control/font tokens | | `slider` + `Slider` options | One token-painted track/thumb over native slider/value interaction; optional step, caller formatting, whole-step manipulation and hidden value editor | `control_height`, `space_24/8/4/2`, form control/font tokens | @@ -160,7 +160,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` | 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. | `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` | 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` | | `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 | @@ -724,3 +724,18 @@ icon segments and category chips. `catalog_footer` draws the quiet information h 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. + +The Appearance Inspector uses the shared `inspector_header` (selection icon/name, +workspace chip, Menu and close action) and `Panel::editor_footer` (48 pt pinned +band). `color_hex_field` pairs the colour popover with a bounded hex editor; +`mixed_slider` pairs the standard slider with the mixed-aware scalar editor. +`editor_section` uses a 24 pt heading and 6 pt field gaps. +`workspace_chip`, `text_button`, `section_heading`, `pending_section`, +`searchable_icon_dropdown` and `Menu::text` retain +shared token paint and hit targets. All are exercised in the kit gallery. + +| Shared editor component | Behaviour | +| --- | --- | +| method_section | Compact, initially collapsed editor section with a method tag; unsupported contents remain inspectable and disabled, with a translated reason visible even when collapsed. Uses editor_section typography and spacing. | +| vector3_field | Three bounded number fields divide the row's control column evenly, retaining the shared parser, focus and bevels. Used for RGB absorption and world-space origin/repeat vectors. | +| sphere_preview_with_source | Sample card with an interactive source tag, retaining the sphere, name, usage badge and trailing action. Appearance uses the tag to inspect its inheritance chain. |