diff --git a/assets/locales/pending/render-browser-tree.json b/assets/locales/pending/render-browser-tree.json new file mode 100644 index 000000000..154a17cbc --- /dev/null +++ b/assets/locales/pending/render-browser-tree.json @@ -0,0 +1,298 @@ +{ + "en": { + "Select Same Look": "Select Same Look", + "render.tree_add_light": "Add light", + "render.tree_add_shot": "Add shot", + "render.tree_browser": "Render Browser", + "render.tree_by_look": "By look", + "render.tree_by_object": "By object", + "render.tree_constant": "Constant environment", + "render.tree_default": "Default", + "render.tree_directional": "Directional", + "render.tree_environment": "Environment", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "{count} faces", + "render.tree_face_one": "{count} face", + "render.tree_fixed_studio": "Fixed studio", + "render.tree_hdr": "HDR", + "render.tree_lights": "Lights", + "render.tree_lights_pending": "Named light commands are not available yet.", + "render.tree_mixed": "Mixed", + "render.tree_more": "{count} more", + "render.tree_mute": "Mute light", + "render.tree_no_environment": "No environment", + "render.tree_objects": "Objects", + "render.tree_output": "Output", + "render.tree_point": "Point", + "render.tree_rectangle": "Rectangle", + "render.tree_search": "Search objects", + "render.tree_selection": "Render selection", + "render.tree_shots": "Shots", + "render.tree_sky": "Sky", + "render.tree_solo": "Solo light", + "render.tree_spot": "Spot", + "render.tree_sun": "Sun", + "render.tree_switch": "Switch", + "render.tree_user_one": "{count} object", + "render.tree_users": "{count} objects" + }, + "de": { + "Select Same Look": "Gleiches Aussehen auswählen", + "render.tree_add_light": "Licht hinzufügen", + "render.tree_add_shot": "Aufnahme hinzufügen", + "render.tree_browser": "Render-Browser", + "render.tree_by_look": "Nach Aussehen", + "render.tree_by_object": "Nach Objekt", + "render.tree_constant": "Konstante Umgebung", + "render.tree_default": "Standard", + "render.tree_directional": "Gerichtet", + "render.tree_environment": "Umgebung", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "{count} Flächen", + "render.tree_face_one": "{count} Fläche", + "render.tree_fixed_studio": "Festes Studio", + "render.tree_hdr": "HDR", + "render.tree_lights": "Lichter", + "render.tree_lights_pending": "Befehle für benannte Lichter sind noch nicht verfügbar.", + "render.tree_mixed": "Gemischt", + "render.tree_more": "{count} weitere", + "render.tree_mute": "Licht stummschalten", + "render.tree_no_environment": "Keine Umgebung", + "render.tree_objects": "Objekte", + "render.tree_output": "Ausgabe", + "render.tree_point": "Punkt", + "render.tree_rectangle": "Rechteck", + "render.tree_search": "Objekte suchen", + "render.tree_selection": "Render-Auswahl", + "render.tree_shots": "Aufnahmen", + "render.tree_sky": "Himmel", + "render.tree_solo": "Licht solo schalten", + "render.tree_spot": "Spot", + "render.tree_sun": "Sonne", + "render.tree_switch": "Wechseln", + "render.tree_user_one": "{count} Objekt", + "render.tree_users": "{count} Objekte" + }, + "ja": { + "Select Same Look": "同じ外観を選択", + "render.tree_add_light": "ライトを追加", + "render.tree_add_shot": "ショットを追加", + "render.tree_browser": "レンダーブラウザー", + "render.tree_by_look": "外観別", + "render.tree_by_object": "オブジェクト別", + "render.tree_constant": "一定の環境光", + "render.tree_default": "既定", + "render.tree_directional": "平行光", + "render.tree_environment": "環境", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "{count} 面", + "render.tree_face_one": "{count} 面", + "render.tree_fixed_studio": "固定スタジオ", + "render.tree_hdr": "HDR", + "render.tree_lights": "ライト", + "render.tree_lights_pending": "名前付きライトのコマンドはまだ利用できません。", + "render.tree_mixed": "混在", + "render.tree_more": "ほか{count}件", + "render.tree_mute": "ライトをミュート", + "render.tree_no_environment": "環境なし", + "render.tree_objects": "オブジェクト", + "render.tree_output": "出力", + "render.tree_point": "点光源", + "render.tree_rectangle": "矩形", + "render.tree_search": "オブジェクトを検索", + "render.tree_selection": "レンダー選択", + "render.tree_shots": "ショット", + "render.tree_sky": "空", + "render.tree_solo": "ライトをソロにする", + "render.tree_spot": "スポット", + "render.tree_sun": "太陽", + "render.tree_switch": "切り替え", + "render.tree_user_one": "{count} オブジェクト", + "render.tree_users": "{count} オブジェクト" + }, + "zh": { + "Select Same Look": "选择相同外观", + "render.tree_add_light": "添加灯光", + "render.tree_add_shot": "添加镜头", + "render.tree_browser": "渲染浏览器", + "render.tree_by_look": "按外观", + "render.tree_by_object": "按对象", + "render.tree_constant": "恒定环境光", + "render.tree_default": "默认", + "render.tree_directional": "平行光", + "render.tree_environment": "环境", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "{count} 个面", + "render.tree_face_one": "{count} 个面", + "render.tree_fixed_studio": "固定工作室", + "render.tree_hdr": "HDR", + "render.tree_lights": "灯光", + "render.tree_lights_pending": "命名灯光命令尚不可用。", + "render.tree_mixed": "混合", + "render.tree_more": "另有 {count} 个", + "render.tree_mute": "静音灯光", + "render.tree_no_environment": "无环境", + "render.tree_objects": "对象", + "render.tree_output": "输出", + "render.tree_point": "点光源", + "render.tree_rectangle": "矩形光", + "render.tree_search": "搜索对象", + "render.tree_selection": "渲染选择", + "render.tree_shots": "镜头", + "render.tree_sky": "天空", + "render.tree_solo": "独显灯光", + "render.tree_spot": "聚光灯", + "render.tree_sun": "太阳", + "render.tree_switch": "切换", + "render.tree_user_one": "{count} 个对象", + "render.tree_users": "{count} 个对象" + }, + "ko": { + "Select Same Look": "같은 외관 선택", + "render.tree_add_light": "조명 추가", + "render.tree_add_shot": "샷 추가", + "render.tree_browser": "렌더 브라우저", + "render.tree_by_look": "외관별", + "render.tree_by_object": "객체별", + "render.tree_constant": "일정한 환경광", + "render.tree_default": "기본", + "render.tree_directional": "방향광", + "render.tree_environment": "환경", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "면 {count}개", + "render.tree_face_one": "면 {count}개", + "render.tree_fixed_studio": "고정 스튜디오", + "render.tree_hdr": "HDR", + "render.tree_lights": "조명", + "render.tree_lights_pending": "이름이 지정된 조명 명령은 아직 사용할 수 없습니다.", + "render.tree_mixed": "혼합", + "render.tree_more": "{count}개 더", + "render.tree_mute": "조명 끄기", + "render.tree_no_environment": "환경 없음", + "render.tree_objects": "객체", + "render.tree_output": "출력", + "render.tree_point": "점광원", + "render.tree_rectangle": "사각형", + "render.tree_search": "객체 검색", + "render.tree_selection": "렌더 선택", + "render.tree_shots": "샷", + "render.tree_sky": "하늘", + "render.tree_solo": "조명 단독 표시", + "render.tree_spot": "스포트", + "render.tree_sun": "태양", + "render.tree_switch": "전환", + "render.tree_user_one": "객체 {count}개", + "render.tree_users": "객체 {count}개" + }, + "ar": { + "Select Same Look": "تحديد المظهر نفسه", + "render.tree_add_light": "إضافة ضوء", + "render.tree_add_shot": "إضافة لقطة", + "render.tree_browser": "متصفح التصيير", + "render.tree_by_look": "حسب المظهر", + "render.tree_by_object": "حسب الكائن", + "render.tree_constant": "بيئة ثابتة", + "render.tree_default": "افتراضي", + "render.tree_directional": "اتجاهي", + "render.tree_environment": "البيئة", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "{count} وجوه", + "render.tree_face_one": "{count} وجه", + "render.tree_fixed_studio": "استوديو ثابت", + "render.tree_hdr": "HDR", + "render.tree_lights": "الأضواء", + "render.tree_lights_pending": "أوامر الأضواء المسمّاة غير متاحة بعد.", + "render.tree_mixed": "مختلط", + "render.tree_more": "{count} أخرى", + "render.tree_mute": "كتم الضوء", + "render.tree_no_environment": "لا توجد بيئة", + "render.tree_objects": "الكائنات", + "render.tree_output": "المخرجات", + "render.tree_point": "نقطي", + "render.tree_rectangle": "مستطيل", + "render.tree_search": "بحث في الكائنات", + "render.tree_selection": "تحديد التصيير", + "render.tree_shots": "اللقطات", + "render.tree_sky": "السماء", + "render.tree_solo": "عزل الضوء", + "render.tree_spot": "كشّاف", + "render.tree_sun": "الشمس", + "render.tree_switch": "تبديل", + "render.tree_user_one": "{count} كائن", + "render.tree_users": "{count} كائنات" + }, + "he": { + "Select Same Look": "בחר אותו מראה", + "render.tree_add_light": "הוסף אור", + "render.tree_add_shot": "הוסף צילום", + "render.tree_browser": "דפדפן רינדור", + "render.tree_by_look": "לפי מראה", + "render.tree_by_object": "לפי אובייקט", + "render.tree_constant": "סביבה קבועה", + "render.tree_default": "ברירת מחדל", + "render.tree_directional": "כיווני", + "render.tree_environment": "סביבה", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "{count} פאות", + "render.tree_face_one": "פאה {count}", + "render.tree_fixed_studio": "סטודיו קבוע", + "render.tree_hdr": "HDR", + "render.tree_lights": "אורות", + "render.tree_lights_pending": "פקודות אורות בעלי שם עדיין אינן זמינות.", + "render.tree_mixed": "מעורב", + "render.tree_more": "{count} נוספים", + "render.tree_mute": "השתק אור", + "render.tree_no_environment": "ללא סביבה", + "render.tree_objects": "אובייקטים", + "render.tree_output": "פלט", + "render.tree_point": "נקודתי", + "render.tree_rectangle": "מלבן", + "render.tree_search": "חיפוש אובייקטים", + "render.tree_selection": "בחירת רינדור", + "render.tree_shots": "צילומים", + "render.tree_sky": "שמיים", + "render.tree_solo": "בידוד אור", + "render.tree_spot": "זרקור", + "render.tree_sun": "שמש", + "render.tree_switch": "החלף", + "render.tree_user_one": "אובייקט {count}", + "render.tree_users": "{count} אובייקטים" + }, + "vi": { + "Select Same Look": "Chọn cùng diện mạo", + "render.tree_add_light": "Thêm đèn", + "render.tree_add_shot": "Thêm cảnh chụp", + "render.tree_browser": "Trình duyệt kết xuất", + "render.tree_by_look": "Theo diện mạo", + "render.tree_by_object": "Theo đối tượng", + "render.tree_constant": "Môi trường hằng định", + "render.tree_default": "Mặc định", + "render.tree_directional": "Định hướng", + "render.tree_environment": "Môi trường", + "render.tree_environment_values": "{rotation}° · {intensity}×", + "render.tree_face_count": "{count} mặt", + "render.tree_face_one": "{count} mặt", + "render.tree_fixed_studio": "Studio cố định", + "render.tree_hdr": "HDR", + "render.tree_lights": "Đèn", + "render.tree_lights_pending": "Chưa có lệnh đèn có tên.", + "render.tree_mixed": "Hỗn hợp", + "render.tree_more": "Thêm {count}", + "render.tree_mute": "Tắt đèn", + "render.tree_no_environment": "Không có môi trường", + "render.tree_objects": "Đối tượng", + "render.tree_output": "Đầu ra", + "render.tree_point": "Điểm", + "render.tree_rectangle": "Hình chữ nhật", + "render.tree_search": "Tìm đối tượng", + "render.tree_selection": "Vùng chọn kết xuất", + "render.tree_shots": "Cảnh chụp", + "render.tree_sky": "Bầu trời", + "render.tree_solo": "Chỉ hiện một đèn", + "render.tree_spot": "Đèn rọi", + "render.tree_sun": "Mặt trời", + "render.tree_switch": "Chuyển", + "render.tree_user_one": "{count} đối tượng", + "render.tree_users": "{count} đối tượng" + } +} diff --git a/crates/doc/src/appearance.rs b/crates/doc/src/appearance.rs index 064a9fa8d..e02ba05cb 100644 --- a/crates/doc/src/appearance.rs +++ b/crates/doc/src/appearance.rs @@ -161,6 +161,36 @@ pub fn material_look(material: &str) -> Option { } impl Document { + /// Resolve a picked face through the same appearance chain used by the viewport. + pub fn model_face_look(&self, body: &crate::ModelBody, face: usize) -> Option { + self.face_colors(body).into_iter().find(|(index, _)| *index == face).map(|(_, look)| look).or_else(|| self.model_display_look(body)) + } + + /// Body appearance including the imported fallback used by `body_color`. + pub fn model_display_look(&self, body: &crate::ModelBody) -> Option { + self.model_body_look(body).or_else(|| { + let color = body.body.color().or_else(|| body.imported.as_ref().and_then(|p| p.color))?; + Some(Look::custom(color.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8), self.model_body_opacity(body))) + }) + } + + /// Distinct appearances used by an object, including its face overrides. `None` is + /// the unassigned/imported body appearance. Repeated faces count as one object user. + pub fn model_used_looks(&self, body: &crate::ModelBody) -> Vec> { + let faces = self.face_colors(body); + let mut looks = Vec::new(); + if faces.len() < body.body.face_count() || faces.is_empty() { + looks.push(self.model_display_look(body)); + } + for (_, look) in faces { + let look = Some(look); + if !looks.contains(&look) { + looks.push(look); + } + } + looks + } + /// Shared definition appearance for a computed occurrence body. pub fn model_body_look(&self, body: &crate::ModelBody) -> Option { let name = body.definition_name(); diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index d25f3c9d9..d3f9259f4 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -83,6 +83,8 @@ pub static COMMANDS: &[CommandSpec] = &[ CommandSpec::new("select.filter", "Selection filter", select_filter).icon("select").noundo().doc_only() .params("mode: body|face|component → validated UI pick granularity; headless echo only, no document edits or undo"), CommandSpec::new("select.clear", "Clear Selection", select_clear).icon("select").noundo(), + CommandSpec::new("select.same_look", "Select Same Look", select_same_look).icon("select").noundo().doc_only() + .params("body?: world body name, face?: face index; defaults to the current body/face selection → selects objects using the resolved appearance"), ]; fn undo(s: &mut Session, _p: &Value) -> Result { @@ -1214,6 +1216,44 @@ fn select_filter(_s: &mut Session, p: &Value) -> Result { Ok(json!({"mode": request.mode})) } +fn select_same_look(s: &mut Session, p: &Value) -> Result { + #[derive(serde::Deserialize)] + #[serde(deny_unknown_fields)] + struct Request { + body: Option, + face: Option, + } + let request: Request = serde_json::from_value(p.clone()).map_err(|e| bad("select.same_look", e.to_string()))?; + let selected = s.selection.last(); + let name = request + .body + .as_deref() + .or(match selected { + Some(Sel::Body { name }) => Some(name.as_str()), + Some(Sel::Face { body, .. }) => Some(body.as_str()), + _ => None, + }) + .ok_or_else(|| bad("select.same_look", "select an object or face"))?; + let state = s.world_state(); + let body = state.body(name).ok_or_else(|| bad("select.same_look", "unknown object"))?; + let face = request.face.or(match selected { + Some(Sel::Face { body, index, .. }) if request.body.is_none() && body == name => Some(*index), + _ => None, + }); + if let Some(face) = face + && face >= body.body.face_count() + { + return Err(bad("select.same_look", "unknown face")); + } + let look = face.map_or_else(|| s.doc.model_display_look(body), |face| s.doc.model_face_look(body, face)); + let items: Vec<_> = + state.bodies.iter().filter(|b| s.doc.model_used_looks(b).contains(&look)).take(10_001).map(|b| Sel::Body { name: b.name.clone() }).collect(); + if items.len() > 10_000 { + return Err(bad("select.same_look", "too many objects")); + } + select_set(s, &json!({"items":items})) +} + fn select_clear(s: &mut Session, _p: &Value) -> Result { s.selection.clear(); s.revision += 1; diff --git a/crates/engine/src/cmd/edit_tests.rs b/crates/engine/src/cmd/edit_tests.rs index c9844edee..9f1cf41b4 100644 --- a/crates/engine/src/cmd/edit_tests.rs +++ b/crates/engine/src/cmd/edit_tests.rs @@ -1244,3 +1244,41 @@ fn a_reorder_keeps_the_model_it_was_checked_on() { fresh.evaluate(&s.doc); assert_eq!(fresh.state().bodies.len(), bodies(&s)); } + +#[test] +fn select_same_look_uses_resolved_looks_without_document_history_edits_and_refuses_hostile_input() { + let mut s = Session::default(); + for (name, x) in [("A", 0), ("B", 20), ("C", 40)] { + run(&mut s, "solid.box", json!({"corner":[x,0,0],"length":10,"width":10,"height":10,"body_name":name})); + } + run(&mut s, "appearance.assign", json!({"bodies":["A","B"],"appearance":"ABS - Red"})); + run(&mut s, "appearance.assign", json!({"bodies":["C"],"appearance":"ABS - Blue"})); + run(&mut s, "appearance.assign", json!({"body":"C","faces":[[40,5,5]],"appearance":"ABS - Red"})); + let doc = s.doc.clone(); + let history = (s.undo.len(), s.redo.len(), s.evaluations); + run(&mut s, "select.same_look", json!({"body":"A"})); + assert_eq!(s.selection.len(), 3); + let point = solidcraft_geom::Vec3::new(40.0, 5.0, 5.0); + let face = solidcraft_doc::appearance::face_index_at(s.world_state().body("C").unwrap(), point).unwrap(); + run(&mut s, "select.set", json!({"items":[Sel::Face {body:"C".into(),index:face,point}]})); + run(&mut s, "select.same_look", json!({})); + assert_eq!(s.selection.len(), 3); + run(&mut s, "select.same_look", json!({"body":"C"})); + assert_eq!(s.selection, [Sel::Body { name: "C".into() }]); + let selected = s.selection.clone(); + // Session treats null parameters as the command's empty/default object. + run(&mut s, "select.same_look", Value::Null); + for params in [ + json!([]), + json!({"body":"missing"}), + json!({"body":"A","face":u64::MAX}), + json!({"body":"A","face":-1}), + json!({"body":1}), + json!({"body":"A","extra":true}), + ] { + assert!(s.execute("select.same_look", ¶ms).is_err(), "{params}"); + assert_eq!(s.selection, selected); + } + assert!(std::sync::Arc::ptr_eq(&doc, &s.doc)); + assert_eq!(history, (s.undo.len(), s.redo.len(), s.evaluations)); +} diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs index 24d7bea2d..46b9e3194 100644 --- a/crates/engine/src/cmd/view_navigation.rs +++ b/crates/engine/src/cmd/view_navigation.rs @@ -9,7 +9,26 @@ use crate::schema::{TypedContract, output_schema_for}; use crate::{Result, Sel, Session}; const FOCUS_CONTRACT: TypedContract = TypedContract::new(); -const BROWSER_CONTRACT: TypedContract = TypedContract::new(); +const BROWSER_CONTRACT: TypedContract = TypedContract::new(); + +// Both existing request forms share the Browser command and its published schema. +#[derive(serde::Deserialize, serde::Serialize, schemars::JsonSchema)] +#[serde(untagged)] +enum RenderBrowserRequest { + Open(RenderBrowser), + Controls(RenderBrowserControls), +} + +#[derive(serde::Deserialize, serde::Serialize, schemars::JsonSchema)] +#[serde(deny_unknown_fields)] +struct RenderBrowserControls { + #[serde(skip_serializing_if = "Option::is_none")] + by_look: Option, + #[serde(skip_serializing_if = "Option::is_none")] + search: Option, + #[serde(skip_serializing_if = "Option::is_none")] + query: Option, +} pub static COMMANDS: &[CommandSpec] = &[ CommandSpec::new("view.fit", "Fit", fit) @@ -34,8 +53,11 @@ CommandSpec::new("view.render_focus", "Render Focus View", crate::checked!("view .params("on: bool → {on}; per-window UI state, never saved in the design; headless validation only"), CommandSpec::new("view.render_browser", "Render Browser", crate::checked!("view.render_browser", render_browser)) .icon("list").noundo().doc_only() - .contract(&BROWSER_CONTRACT).output(output_schema_for::) - .params("open: bool → {open}; narrow-window Browser card; per-window UI state, headless validation 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_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"), CommandSpec::new("view.render_stage", "Render Stage", render_stage) .icon("render_scene").noundo().doc_only() .params("stage: look|light|frame|output → {stage}; per-document UI state, never edits or evaluates the design; headless validation only"), @@ -233,9 +255,46 @@ fn render_focus(_s: &mut Session, p: &Value) -> Result { Ok(json!(request)) } +fn render_select(s: &mut Session, p: &Value) -> Result { + #[derive(serde::Deserialize, serde::Serialize)] + #[serde(deny_unknown_fields)] + struct Request { + kind: String, + #[serde(skip_serializing_if = "Option::is_none")] + id: Option, + } + let request: Request = serde_json::from_value(p.clone()).map_err(|e| bad("view.render_select", e.to_string()))?; + let identified = matches!(request.kind.as_str(), "light" | "shot"); + if !matches!(request.kind.as_str(), "nothing" | "environment" | "light" | "shot" | "output") + || identified != request.id.is_some() + || request.id.as_ref().is_some_and(|id| id.trim().is_empty() || id.len() > 1024) + { + return Err(bad("view.render_select", "expected a Browser kind and an id only for light or shot")); + } + let result = serde_json::to_value(request).map_err(|e| bad("view.render_select", e.to_string()))?; + if !s.selection.is_empty() { + s.selection.clear(); + s.revision += 1; + } + Ok(result) +} + fn render_browser(_s: &mut Session, p: &Value) -> Result { - let request: RenderBrowser = serde_json::from_value(p.clone()).map_err(|e| bad("view.render_browser", e.to_string()))?; - Ok(json!(request)) + if !p.is_object() { + return Err(bad("view.render_browser", "expected an object with Browser controls")); + } + if p.get("open").is_some() { + let request: RenderBrowser = serde_json::from_value(p.clone()).map_err(|e| bad("view.render_browser", e.to_string()))?; + return Ok(json!(request)); + } + let request: RenderBrowserControls = serde_json::from_value(p.clone()).map_err(|e| bad("view.render_browser", e.to_string()))?; + if request.by_look.is_none() && request.search.is_none() && request.query.is_none() { + return Err(bad("view.render_browser", "expected at least one Browser control")); + } + if request.query.as_ref().is_some_and(|q| q.len() > 1024) { + return Err(bad("query", "expected at most 1024 bytes")); + } + serde_json::to_value(request).map_err(|e| bad("view.render_browser", e.to_string())) } fn render_stage(_s: &mut Session, p: &Value) -> Result { @@ -1020,3 +1079,60 @@ fn render_workspace_dock_validates_without_mutation() { 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(), session.camera)); } + +#[cfg(test)] +#[test] +fn render_browser_focus_validates_without_document_changes_or_evaluation() { + let mut session = Session::default(); + let doc = session.doc.clone(); + let before = (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty()); + for request in [ + json!({"kind":"nothing"}), + json!({"kind":"environment"}), + json!({"kind":"light","id":"sun:0"}), + json!({"kind":"shot","id":"Hero"}), + json!({"kind":"output"}), + ] { + assert_eq!(session.execute("view.render_select", &request).unwrap(), request); + } + for request in [ + Value::Null, + json!([]), + json!({}), + json!({"kind":"object"}), + json!({"kind":"shot"}), + json!({"kind":"light","id":1}), + json!({"kind":"light","id":" "}), + json!({"kind":"shot","id":"x".repeat(1025)}), + json!({"kind":"output","id":"extra"}), + json!({"kind":"environment","extra":true}), + ] { + assert!(session.execute("view.render_select", &request).is_err(), "{request}"); + } + assert!(std::sync::Arc::ptr_eq(&doc, &session.doc)); + assert_eq!(before, (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty())); +} + +#[cfg(test)] +#[test] +fn render_browser_controls_validate_without_document_changes_or_evaluation() { + let mut session = Session::default(); + let document = session.doc.clone(); + let before = (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty()); + for request in [json!({"by_look":true}), json!({"search":true,"query":"Copper"}), json!({"query":""})] { + assert_eq!(session.execute("view.render_browser", &request).unwrap(), request); + } + for request in [ + Value::Null, + json!([]), + json!({}), + json!({"by_look":null}), + json!({"by_look":1}), + json!({"search":null,"extra":true}), + json!({"query":"x".repeat(1025)}), + ] { + assert!(session.execute("view.render_browser", &request).is_err()); + } + 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())); +} diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs index f5c9ecb93..8fed00c7d 100644 --- a/crates/ui-egui/src/browser.rs +++ b/crates/ui-egui/src/browser.rs @@ -64,7 +64,6 @@ pub(crate) fn reveal_body(app: &mut SolveApp, body: &str) { #[path = "browser_model_tests.rs"] mod model_tests; -use crate::icons::glyphs::badge; use std::collections::BTreeSet; use egui::{Color32, FontId, Pos2, Rect, Sense, Stroke, pos2, vec2}; @@ -75,7 +74,7 @@ use solidcraft_engine::doc::FeatureKind; use crate::context_menu::{Item, Target}; use crate::theme::Tokens; -use crate::{SolveApp, icons}; +use crate::SolveApp; thread_local! { /// The rows drawn this frame: (label, row, fold arrow area, open). For automation @@ -446,220 +445,31 @@ pub fn group_action(app: &mut SolveApp, action: &str, p: &Value) { // Drawing // --------------------------------------------------------------------------------------------- -const ROW_H: f32 = crate::ui_kit::TREE_ROW_HEIGHT; /// The floating card's inner margin: the header highlight sits this far from the card's top, left /// and right edges, so its corners are concentric with the card's. const CARD_INSET: f32 = 4.0; const HEADER_H: f32 = 26.0; const INDENT: f32 = 14.0; -/// Opacity of a dimmed row's icon (a hidden body, sketch, origin item, …). -const DIM_ICON_OPACITY: f32 = 0.4; +use crate::ui_kit::RowResp; fn row_rect(ui: &egui::Ui) -> Rect { - Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), ROW_H)) + crate::ui_kit::tree_row_rect(ui, &Row { compact: compact_tree(ui), ..Default::default() }) } /// One row's look. -#[derive(Default)] -pub(crate) struct Row<'a> { - pub(crate) depth: usize, - /// Some(open) for rows that fold. - pub(crate) fold: Option, - /// Some(visible) for rows with an eye. - pub(crate) eye: Option, - pub(crate) icon: &'a str, - pub(crate) label: &'a str, - /// The label is a name someone gave (a body, sketch, component, …): it is shown as typed, - /// not translated when it happens to match a UI label. - pub(crate) name: bool, - pub(crate) selected: bool, - pub(crate) dim: bool, - pub(crate) color: Option, - /// Component rows: is it the active one? - pub(crate) radio: Option, - /// Trailing badges: "lock", "pin". - pub(crate) badges: &'a [&'a str], - /// A button at the row's right end: (icon, tooltip label), e.g. a feature's profile sketch. - pub(crate) action: Option<(&'a str, &'a str)>, - /// Lit by the selection or the 3D view's pointer: the item's own row, or a row leading to it. - pub(crate) mark: Mark, +pub(crate) use crate::ui_kit::{Mark, Row}; + +fn compact_tree(ui: &egui::Ui) -> bool { + ui.ctx().data(|d| d.get_temp::(egui::Id::new("sc_compact_tree"))).unwrap_or(false) } -/// How a row relates to what the selection and the 3D view's pointer light. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub(crate) enum Mark { - #[default] - None, - /// A row a lit item is inside (its component, placement, folder or group): a faint bar. - Branch, - /// A lit item's own row: a solid bar, and the hover colour unless it is selected. - Here, -} - -/// What happened on a row. -#[derive(Default)] -pub(crate) struct RowResp { - pub(crate) rect: Option, - pub(crate) clicked: bool, - pub(crate) double: bool, - pub(crate) secondary: Option, - pub(crate) fold: bool, - pub(crate) eye: bool, - pub(crate) radio: bool, - /// The row's [`Row::action`] button was clicked. - pub(crate) action: bool, - pub(crate) hovered: bool, - /// The row's response (drag and drop). - pub(crate) resp: Option, - /// The press began on the fold arrow, eye or radio (not a drag of the row). - pub(crate) on_control: bool, -} - -pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp { - let t = Tokens::get(); - // Rows scrolled out of view only take their space: no widgets, no painting. - let r = row_rect(ui); - if !ui.is_rect_visible(r) { - ui.allocate_space(r.size()); - return RowResp { rect: Some(r), ..Default::default() }; - } - // A stable id per row (not the layout position), so a press and its release stay on the - // same row while rows above open or close. - let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), ROW_H), Sense::hover()); - let resp = ui.interact(r, id, Sense::click_and_drag()); - // While something is dragged (an appearance swatch, drawn under the pointer) `hovered` is - // off; the row under the pointer still counts, so a drop lands on it. - let dragged_over = egui::DragAndDrop::has_any_payload(ui.ctx()) && ui.input(|i| i.pointer.hover_pos()).is_some_and(|p| r.contains(p)); - let mut out = RowResp { rect: Some(r), hovered: resp.hovered() || dragged_over, ..Default::default() }; - if row.selected { - ui.painter().rect_filled(r, t.radius_sm.saturating_sub(1), crate::theme::TabAccent::current(ui.ctx()).soft); - } else if resp.hovered() || row.mark == Mark::Here { - ui.painter().rect_filled(r, t.radius_sm.saturating_sub(1), t.hover); - } - // A lit item (selected, or under the pointer in the 3D view): a bar down the left of its row, - // and a fainter, thinner one on each row leading to it, so the bars trace its branch. - let bar = match row.mark { - Mark::None => None, - Mark::Branch => Some((2.0, t.accent.gamma_multiply(0.4))), - Mark::Here => Some((3.0, t.accent)), - }; - if let Some((w, colour)) = bar { - ui.painter().rect_filled(Rect::from_min_size(r.left_top() + vec2(0.0, 2.0), vec2(w, r.height() - 4.0)), t.radius_sm / 4, colour); - } - let mut x = r.left() + 2.0 + row.depth as f32 * INDENT; - let cy = r.center().y; - // The row is one widget: where a click lands decides what it does (the fold arrow with - // padding, the eye, the radio, or the row itself), so a click on the arrow never also - // selects the row or starts a drag. - let fold_r = Rect::from_min_max(pos2(x - 4.0, r.top()), pos2(x + 15.0, r.bottom())); - let eye_r = Rect::from_center_size(pos2(x + 14.0 + 8.0, cy), vec2(19.0, r.height())); - let radio_r = Rect::from_center_size(pos2(x + 32.0 + 6.0, cy), vec2(15.0, r.height())); - // The label follows the fold arrow, eye, radio and icon (drawn below in that order). It is - // laid out first, so the action button can sit right after the name and read as the row's. - let label_x = x + 14.0 + 18.0 + if row.radio.is_some() { 15.0 } else { 0.0 } + if row.icon.is_empty() { 0.0 } else { 21.0 }; - let col = - if row.selected { crate::theme::TabAccent::current(ui.ctx()).ink } else { row.color.unwrap_or(if row.dim { t.text_dim } else { t.text }) }; - let label_display = if row.name { crate::i18n::tr_name(row.label) } else { crate::i18n::tr_dyn(row.label) }; - let font = if row.selected { crate::fonts::semibold(t.font_label) } else { FontId::proportional(t.font_label) }; - // The label stops before the action, the badges and the card's edge; a longer name ends in - // an ellipsis and its full text is in the tooltip. - let badges_width = row.badges.len() as f32 * 15.0; - let action_width = if row.action.is_some() { 22.0 } else { 0.0 }; - let room = (r.right() - 4.0 - badges_width - action_width - label_x).max(0.0); - let mut job = egui::text::LayoutJob::simple(label_display.to_string(), font, col, room); - job.wrap.max_rows = 1; - job.wrap.break_anywhere = true; - job.wrap.overflow_character = Some('\u{2026}'); - let galley = ui.painter().layout_job(job); - let lw = galley.size().x; - let elided = galley.elided; - let action_r = Rect::from_min_size(pos2(label_x + lw + 2.0, r.top()), vec2(20.0, r.height())); - let at = |p: Pos2| -> u8 { - if row.action.is_some() && action_r.contains(p) { - 4 - } else if row.fold.is_some() && fold_r.contains(p) { - 1 - } else if row.eye.is_some() && eye_r.contains(p) { - 2 - } else if row.radio.is_some() && radio_r.contains(p) { - 3 - } else { - 0 - } - }; - DRAWN.with(|d| d.borrow_mut().push((row.label.to_string(), r, row.fold.map(|_| fold_r), row.fold))); - let press_on = ui.input(|i| i.pointer.press_origin()).map_or(0, at); - let click_on = resp.interact_pointer_pos().map_or(0, at); - let hover_on = resp.hover_pos().map_or(0, at); - // Fold arrow. - if let Some(open) = row.fold { - crate::ui_kit::disclosure(ui.painter(), pos2(x + 6.0, cy), open, if hover_on == 1 { t.text } else { t.text_dim }); - out.fold = resp.clicked() && click_on == 1; - crate::scenario::publish_handle(&format!("fold:{}", row.label), fold_r.center()); - } - x += 14.0; - // Eye. - if let Some(vis) = row.eye { - let er = Rect::from_center_size(pos2(x + 8.0, cy), vec2(15.0, 15.0)); - // Hidden or faded rows keep main's dimming, with the rounded suppression asset. - icons::paint_icon(ui.painter(), er, if vis { "eye" } else { "suppress" }, if vis && !row.dim { 0.85 } else { DIM_ICON_OPACITY }); - out.eye = resp.clicked() && click_on == 2; - crate::scenario::publish_handle(&format!("eye:{}", row.label), er.center()); - } - x += 18.0; - // Activation radio (components). - if let Some(active) = row.radio { - let rc = pos2(x + 6.0, cy); - ui.painter().circle_stroke(rc, 5.0, Stroke::new(1.2, if active { t.accent } else { t.text_dim })); - if active { - ui.painter().circle_filled(rc, 2.8, t.accent); - } - out.radio = resp.clicked() && click_on == 3; - x += 15.0; - } - if !row.icon.is_empty() { - let ir = Rect::from_min_size(pos2(x, cy - 8.0), vec2(16.0, 16.0)); - // Icons are full-colour images (a tint colour only sets their opacity): a hidden or - // faded row draws its icon faint, like its label. - icons::paint_icon(ui.painter(), ir, row.icon, if row.dim { DIM_ICON_OPACITY } else { 1.0 }); - x += 21.0; - } - crate::scenario::publish_rect(&format!("row_label:{}", row.label), Rect::from_min_size(pos2(x, cy - galley.size().y / 2.0), galley.size())); - ui.painter().with_clip_rect(ui.painter().clip_rect().intersect(r)).galley(pos2(x, cy - galley.size().y / 2.0), galley, col); - let mut bx = (x + lw + 6.0 + action_width).min(r.right() - 16.0); - for b in row.badges { - let br = Rect::from_center_size(pos2(bx + 6.0, cy), vec2(12.0, 12.0)); - badge(ui.painter(), br, b, t.text_dim); - bx += 15.0; - } - if let Some((icon, _)) = row.action { - if hover_on == 4 { - ui.painter().rect_filled(action_r.shrink2(vec2(1.0, 3.0)), t.radius_sm.saturating_sub(1), t.hover); - } - let ir = Rect::from_center_size(action_r.center(), vec2(14.0, 14.0)); - icons::paint_icon(ui.painter(), ir, icon, if hover_on == 4 { 1.0 } else { 0.6 }); - out.action = resp.clicked() && click_on == 4; - crate::scenario::publish_handle(&format!("action:{}", row.label), action_r.center()); - } - crate::scenario::publish_handle(&format!("row:{}", row.label), r.center()); - let tip = match hover_on { - 1 => Some(if row.fold == Some(true) { crate::i18n::tr("ui.collapse") } else { crate::i18n::tr("ui.expand") }), - 2 => Some(if row.eye == Some(true) { crate::i18n::tr("ui.hide") } else { crate::i18n::tr("ui.show") }), - 3 => Some(if row.radio == Some(true) { crate::i18n::tr("ui.active_component") } else { crate::i18n::tr("ui.activate") }), - 4 => row.action.map(|(_, tip)| crate::i18n::tr_label(tip)), - _ => None, - }; - let resp = match tip { - Some(t) => resp.on_hover_text(t), - None if elided => resp.on_hover_text(label_display.to_string()), - None => resp, - }; - out.on_control = press_on != 0; - out.clicked = resp.clicked() && click_on == 0; - out.double = resp.double_clicked() && click_on == 0; - out.resp = Some(resp.clone()); - if resp.secondary_clicked() { - out.secondary = resp.interact_pointer_pos().or(Some(r.left_bottom())); +pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row<'_>) -> RowResp { + let compact = compact_tree(ui); + let out = crate::ui_kit::tree_row(ui, id, &Row { compact, ..*row }); + if let Some(r) = out.rect.filter(|r| ui.is_rect_visible(*r)) { + let x = r.left() + if compact { Tokens::get().space_8 } else { 2.0 } + row.depth as f32 * INDENT; + let fold = row.fold.map(|_| Rect::from_min_max(pos2(x - 4.0, r.top()), pos2(x + 15.0, r.bottom()))); + DRAWN.with(|d| d.borrow_mut().push((row.label.to_string(), r, fold, row.fold))); } out } @@ -1077,8 +887,12 @@ fn render_card(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions) { } let mut side = app.preferences.render_browser_side.clone(); let mut width = app.preferences.render_browser_width; - let title = app.tr("ui.browser_title").to_string(); - let content = crate::ui_kit::Panel::workspace( + let title = app.tr("render.page_scene").to_string(); + let labels = [app.tr("render.tree_by_object").to_string(), app.tr("render.tree_by_look").to_string()]; + let search_label = app.tr("render.tree_search").to_string(); + let mut lens = usize::from(app.render_workspace.view.by_look); + let mut search_clicked = false; + let content = crate::ui_kit::Panel::workspace_with_header( ui, crate::ui_kit::WorkspaceOptions { id: "render:browser", @@ -1090,6 +904,11 @@ fn render_card(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions) { }, &mut side, &mut width, + true, + |ui, options| { + search_clicked = + crate::ui_kit::tree_header(ui, options.title, &mut lens, &labels.iter().map(String::as_str).collect::>(), &search_label); + }, |ui| { if narrow { let hide = crate::ui_kit::button(ui, app.tr("render.fold_browser"), crate::ui_kit::Button::Normal); @@ -1098,9 +917,17 @@ fn render_card(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions) { let _ = app.run("view.render_browser", json!({"open":false})); } } + ui.ctx().data_mut(|d| d.insert_temp(egui::Id::new("sc_compact_tree"), true)); browser_contents(app, ui, acts, true); + ui.ctx().data_mut(|d| d.remove::(egui::Id::new("sc_compact_tree"))); }, ); + if (lens == 1) != app.render_workspace.view.by_look { + let _ = app.run("view.render_browser", json!({"by_look":lens == 1})); + } + if search_clicked { + let _ = app.run("view.render_browser", json!({"search":!app.render_workspace.view.search_objects})); + } app.preferences.render_browser_width = width; let requested = content.as_ref().and_then(|c| c.inner.1).map(str::to_string).or_else(|| (app.preferences.render_browser_side != side).then(|| side.clone())); @@ -1176,8 +1003,10 @@ fn browser_contents(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions, c if crate::render_workspace::browser_mode(app, ui) { return; } - t.secondary_hline(ui.painter(), ui.max_rect().x_range(), ui.cursor().top() + 1.0, t.toolbar.lerp_to_gamma(t.border, 0.5)); - ui.add_space(t.space_3); + if !render { + t.secondary_hline(ui.painter(), ui.max_rect().x_range(), ui.cursor().top() + 1.0, t.toolbar.lerp_to_gamma(t.border, 0.5)); + ui.add_space(t.space_3); + } if collapsible && !stacked { browser_rows_hugging(app, ui, acts); } else { @@ -1311,7 +1140,15 @@ fn rows_scrolling(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions, shr .scroll_source(egui::scroll_area::ScrollSource { scroll_bar: true, mouse_wheel: true, ..egui::scroll_area::ScrollSource::NONE }) .show(ui, |ui| { ui.spacing_mut().item_spacing.y = 0.0; - component_rows(app, ui, 0, 0, acts, &mut cache); + if crate::render_workspace::active(app) { + crate::render_workspace::scene::sections(app, ui); + if !crate::render_workspace::scene::objects(app, ui, &mut acts.hover_bodies, &mut acts.hovered) { + component_rows(app, ui, 0, 1, acts, &mut cache); + } + crate::render_workspace::scene::output(app, ui); + } else { + component_rows(app, ui, 0, 0, acts, &mut cache); + } }); // The row was reached and scrolled to, or isn't in the tree (a body a later feature removes): // either way the reveal is done. @@ -1404,6 +1241,15 @@ fn component_rows_inner( cache: &mut cache::Cache, root: &mut cache::Node, ) { + if id == 0 && crate::render_workspace::active(app) { + let Some(slot) = root.folders.first_mut() else { return }; + let data = slot.get_or_insert_with(|| cache.folder(app, id, None, "bodies")); + folder_rows_at(app, ui, id, None, "bodies", depth.saturating_sub(1), acts, data); + for path in &root.children { + occurrence_rows(app, ui, path, depth, acts, cache); + } + return; + } let key = &root.key; let reveal = app.tree.reveal.clone(); if let Some(body) = reveal.as_ref() { @@ -1420,6 +1266,7 @@ fn component_rows_inner( let faded = app.session.active_component != 0 && !app.session.doc.component_within(id, app.session.active_component) && !active; let name = &root.name; let badges: &[&str] = if root.grounded { &["pin"] } else { &[] }; + let appearance = crate::render_workspace::scene::decoration(app, bodies); let row = Row { depth, fold: Some(open), @@ -1431,6 +1278,9 @@ fn component_rows_inner( dim: faded, radio: Some(active), badges, + swatch: appearance.swatch, + secondary: &appearance.name, + count: &appearance.count, // The design holds everything the tree lists. mark: if id == 0 && acts.lit.any() { Mark::Branch } else { Mark::None }, ..Default::default() @@ -1490,19 +1340,25 @@ fn component_rows_inner( return; } let d = depth + 1; - if id == 0 { + if id == 0 && !crate::render_workspace::active(app) { doc_settings(app, ui, d); named_view_rows(app, ui, d, acts); origin_rows(app, ui, d, acts); canvas_rows(app, ui, d, acts); analysis_rows(app, ui, d, acts); } + let render = crate::render_workspace::active(app); for (slot, folder) in root.folders.iter_mut().zip(["bodies", "sketches", "construction"]) { + if render && folder != "bodies" { + continue; + } let data = slot.get_or_insert_with(|| cache.folder(app, id, None, folder)); folder_rows_at(app, ui, id, None, folder, d, acts, data); } - features::rows(app, ui, id, &[], d, acts); - if id == 0 { + if !render { + features::rows(app, ui, id, &[], d, acts); + } + if id == 0 && !render { crate::dialogs_assembly::browser_joints(app, ui, d); } for path in &root.children { @@ -1560,6 +1416,12 @@ fn occurrence_rows_inner( let faded = app.session.active_occurrence_path.as_ref().is_some_and(|p| !path.starts_with(p) && !p.starts_with(path)); let badges: &[&str] = if placement.grounded { &["pin"] } else { &[] }; app.tree.remember(key); + let appearance = if crate::render_workspace::active(app) { + let bodies = placement.hover_bodies.get_or_insert_with(|| app.session.occurrence_bodies(path, true).unwrap_or_default()); + crate::render_workspace::scene::decoration(app, bodies) + } else { + crate::render_workspace::scene::Decoration::default() + }; let r = draw_row( ui, ui.id().with(key), @@ -1569,6 +1431,9 @@ fn occurrence_rows_inner( eye: Some(own_visible), icon: "component", label: &placement.label, + swatch: appearance.swatch, + secondary: &appearance.name, + count: &appearance.count, name: true, selected, // A cut component is faded until Paste moves it. @@ -1632,11 +1497,17 @@ fn occurrence_rows_inner( if !open { return; } + let render = crate::render_workspace::active(app); for (slot, folder) in placement.folders.iter_mut().zip(["bodies", "sketches", "construction"]) { + if render && folder != "bodies" { + continue; + } let data = slot.get_or_insert_with(|| cache.folder(app, placement.component, Some(path), folder)); folder_rows_at(app, ui, placement.component, Some(path), folder, depth + 1, acts, data); } - features::rows(app, ui, placement.component, path, depth + 1, acts); + if !render { + features::rows(app, ui, placement.component, path, depth + 1, acts); + } if path.len() < 64 { for child in &placement.children { occurrence_rows(app, ui, child, depth + 1, acts, cache); @@ -2365,7 +2236,8 @@ fn folder_rows_at( } // A folded folder draws no row: its groups and items move up into its place, and their own // eyes, hover and drops do its jobs. It is always open, as nothing could open it again. - let folded = folder == "bodies" && bodies_folded(app, comp, prefix, data.entries().count()); + let render = crate::render_workspace::active(app); + let folded = !render && folder == "bodies" && bodies_folded(app, comp, prefix, data.entries().count()); let open = folded || is_open(app, key, true); let inner = if folded { depth } else { depth + 1 }; // The folder's eye is its own: hiding it hides its items without changing theirs, and its @@ -2373,75 +2245,89 @@ fn folder_rows_at( // hidden, whatever their own eyes say. let shown = !app.session.folder_hidden(key); let folder_faded = !shown || path.is_some_and(|p| !app.session.occurrence_visible(p)); - let r = if folded { - RowResp::default() - } else { - draw_row( - ui, - ui.id().with(key), - &Row { - depth, - fold: Some(open), - eye: Some(shown), - icon: "folder", - label: folder_label(folder), - dim: folder_faded, - mark: acts.lit.branch(app, data.entries()), - ..Default::default() - }, - ) - }; - if r.fold { - toggle(app, key, true); - } else if r.clicked { - // The Bodies label is the whole set while a command is asking for bodies. The arrow - // still folds it. With no such command, the label folds, as it always has. - let names: Vec = data.entries().flat_map(|e| e.bodies.clone()).collect(); - if !offer_bodies(app, &names, Take::Toggle) { + if !render { + let r = if folded { + RowResp::default() + } else { + draw_row( + ui, + ui.id().with(key), + &Row { + depth, + fold: Some(open), + eye: Some(shown), + icon: "folder", + label: folder_label(folder), + dim: folder_faded, + mark: acts.lit.branch(app, data.entries()), + ..Default::default() + }, + ) + }; + if r.fold { toggle(app, key, true); + } else if r.clicked { + // The Bodies label is the whole set while a command is asking for bodies. The arrow + // still folds it. With no such command, the label folds, as it always has. + let names: Vec = data.entries().flat_map(|e| e.bodies.clone()).collect(); + if !offer_bodies(app, &names, Take::Toggle) { + toggle(app, key, true); + } + } + if r.eye { + toggle_folder(app, key); + } + if r.hovered { + acts.hover(data.entries().flat_map(|e| &e.bodies)); + } + if let Some(p) = r.secondary { + acts.menu = Some((p, Target::Folder { component: comp, folder: fstatic.to_string(), scope: prefix.to_owned() })); + } + // Dropping on the folder row takes items out of their groups, to the end. Bodies or sketches + // from another component's folder move into this component, as a drop on its row does + // (#3270: the Bodies folder looked like the place to drop a body, and took nothing). + if let Some(resp) = &r.resp + && let Some(d) = drop_target(ui, resp, |d: &Drag| d.folder == fstatic && (d.comp == comp || d.folder != "construction"), DropMark::Box) + { + acts.drop = Some(if d.comp == comp { + DropAction::Move { comp, folder: fstatic, keys: d.keys.clone(), group: None, before: None } + } else { + DropAction::Component { to: comp, folder: d.folder, keys: d.keys.clone() } + }); + } + if !open { + return; } } - if r.eye { - toggle_folder(app, key); - } - if r.hovered { - acts.hover(data.entries().flat_map(|e| &e.bodies)); - } - if let Some(p) = r.secondary { - acts.menu = Some((p, Target::Folder { component: comp, folder: fstatic.to_string(), scope: prefix.to_owned() })); - } - // Dropping on the folder row takes items out of their groups, to the end. Bodies or sketches - // from another component's folder move into this component, as a drop on its row does - // (#3270: the Bodies folder looked like the place to drop a body, and took nothing). - if let Some(resp) = &r.resp - && let Some(d) = drop_target(ui, resp, |d: &Drag| d.folder == fstatic && (d.comp == comp || d.folder != "construction"), DropMark::Box) - { - acts.drop = Some(if d.comp == comp { - DropAction::Move { comp, folder: fstatic, keys: d.keys.clone(), group: None, before: None } - } else { - DropAction::Component { to: comp, folder: d.folder, keys: d.keys.clone() } - }); - } - if !open { - return; - } let loose_keys = &data.loose_keys; + if render { + for e in &data.loose { + entry_row(app, ui, comp, path, fstatic, e, depth + 1, None, loose_keys, folder_faded, acts); + } + } for group in &data.groups { let (id, items, gkey) = (group.id, &group.items, &group.key); let gopen = is_open(app, gkey, true); let gshown = !app.session.folder_hidden(gkey); let group_faded = folder_faded || !gshown; + let label = if render { + app.session.doc.browser_groups.iter().find(|g| g.id == id).map_or(group.label.as_str(), |g| g.name.as_str()) + } else { + &group.label + }; + let count = if render && !gopen { crate::i18n::format("render.tree_more", &[("count", &items.len().to_string())]) } else { String::new() }; let r = draw_row( ui, ui.id().with(gkey), &Row { depth: inner, fold: Some(gopen), - eye: Some(gshown), - icon: "folder", - label: &group.label, + eye: (!render || gopen).then_some(gshown), + icon: if render { "" } else { "folder" }, + label, name: true, - dim: group_faded, + dim: group_faded || (render && !gopen), + count: &count, mark: acts.lit.branch(app, items), ..Default::default() }, @@ -2474,8 +2360,10 @@ fn folder_rows_at( } } } - for e in &data.loose { - entry_row(app, ui, comp, path, fstatic, e, inner, None, loose_keys, folder_faded, acts); + if !render { + for e in &data.loose { + entry_row(app, ui, comp, path, fstatic, e, inner, None, loose_keys, folder_faded, acts); + } } } @@ -2531,6 +2419,10 @@ fn entry_row( parent_hidden: bool, acts: &mut Actions, ) { + let appearance = crate::render_workspace::scene::decoration(app, &e.bodies); + if crate::render_workspace::active(app) && !crate::render_workspace::scene::matches_query(app, &e.label, &appearance.name) { + return; + } app.tree.remember(&e.row_key); let pattern_key = e.patterns.as_deref(); let patterns_open = pattern_key.is_some_and(|key| is_open(app, key, true)); @@ -2560,6 +2452,9 @@ fn entry_row( // A cut body is faded until Paste moves it. dim: !e.visible || parent_hidden || (folder == "bodies" && app.cut_bodies.contains(&e.key)), color: e.color, + swatch: appearance.swatch, + secondary: &appearance.name, + count: &appearance.count, badges, mark, ..Default::default() diff --git a/crates/ui-egui/src/browser_model_tests.rs b/crates/ui-egui/src/browser_model_tests.rs index ee598b340..89dfb43f3 100644 --- a/crates/ui-egui/src/browser_model_tests.rs +++ b/crates/ui-egui/src/browser_model_tests.rs @@ -196,6 +196,31 @@ fn construction_rows_include_points_and_axes() { assert!(super::entries(&h.app, 0, "construction").is_empty()); } +#[test] +fn render_browser_swatch_resolves_face_body_component_then_physical_material() { + let (mut h, component, _) = fixture(); + crate::render_workspace::enter(&mut h.app, true).unwrap(); + let swatch = |h: &crate::scenario::Harness| crate::render_workspace::scene::decoration(&h.app, &["Body1".into()]); + h.app.run("material.assign", json!({"bodies":["Body1"],"material":"Brass"})).unwrap(); + assert_eq!(swatch(&h).name, "Brass"); + h.app.run("appearance.assign", json!({"components":[component.to_string()],"appearance":"ABS - Red"})).unwrap(); + assert_eq!(swatch(&h).name, "ABS - Red"); + h.app.run("appearance.assign", json!({"bodies":["Body1"],"appearance":"ABS - Blue"})).unwrap(); + assert_eq!(swatch(&h).name, "ABS - Blue"); + let point = solidcraft_engine::geom::Vec3::new(0.0, 5.0, 5.0); + h.app.run("appearance.assign", json!({"body":"Body1","faces":[point],"appearance":"ABS - Red"})).unwrap(); + let state = h.app.session.world_state(); + let body = state.body("Body1").unwrap(); + let face = solidcraft_engine::doc::appearance::face_index_at(body, point).unwrap(); + h.app.run("select.set", json!({"items":[Sel::Face{body:"Body1".into(),index:face,point}]})).unwrap(); + let resolved = swatch(&h); + assert_eq!(resolved.name, "ABS - Red"); + assert_eq!(resolved.swatch, Some(egui::Color32::from_rgb(196, 40, 40))); + assert_eq!(resolved.count, "1 face"); + h.app.run("select.clear", json!({})).unwrap(); + assert_eq!(swatch(&h).name, "ABS - Blue"); +} + fn body_names(app: &crate::SolveApp) -> Vec { app.dialog .as_ref() diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs index 2bb9734f3..e9a28488c 100644 --- a/crates/ui-egui/src/context_menu.rs +++ b/crates/ui-egui/src/context_menu.rs @@ -359,6 +359,14 @@ pub fn radial_items(app: &SolveApp) -> Vec { pub fn items(app: &SolveApp, target: &Target) -> Vec { let mut v = match target { Target::Viewport => viewport_items(app), + Target::Body { name } if crate::render_workspace::active(app) => vec![ + cmd(app, "select.set", "Select").with(json!({"items":[Sel::Body {name:name.clone()}]})), + cmd(app, "select.same_look", "Select Same Look").with(json!({"body":name})), + Item::sep(), + act("ui.isolate", "Isolate", "body").with(json!({"bodies":[name]})), + act(if app.session.visibility.hidden_bodies.contains(name) { "ui.show" } else { "ui.hide" }, "Show/Hide", "eye") + .with(json!({"bodies":[name]})), + ], Target::Body { name } => body_items(app, std::slice::from_ref(name), true), Target::Sketch { id } => sketch_items(app, *id), Target::Feature { id } => feature_items(app, *id), @@ -398,7 +406,31 @@ pub fn items(app: &SolveApp, target: &Target) -> Vec { .collect(), Target::NamedView { name } => crate::browser::view_items(app, name), }; - v.extend(crate::browser::folded_folder_items(app, target)); + if !crate::render_workspace::active(app) { + v.extend(crate::browser::folded_folder_items(app, target)); + } + if crate::render_workspace::active(app) { + let (bodies, selection) = match target { + Target::Component { id } => { + let bodies = component_bodies(app, *id); + let selection: Vec = bodies.iter().map(|name| Sel::Body { name: name.clone() }).collect(); + (bodies, selection) + } + Target::Occurrence { path } => { + (app.session.occurrence_bodies(path, true).unwrap_or_default(), vec![Sel::Occurrence { path: path.clone() }]) + } + _ => (Vec::new(), Vec::new()), + }; + if let Some(body) = bodies.first() { + v.insert(0, cmd(app, "select.set", "Select").with(json!({"items":selection}))); + v.insert( + 1, + cmd(app, "select.same_look", "Select Same Look") + .with(json!({"body":body})) + .on(crate::render_workspace::scene::same_look(app, &bodies)), + ); + } + } // Several items of the folder selected: they can be grouped. if let Some(p) = crate::browser::selection_group(app, target) { v.push(Item::sep()); diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs index 312eda4cb..3bf9c8ec8 100644 --- a/crates/ui-egui/src/i18n.rs +++ b/crates/ui-egui/src/i18n.rs @@ -695,7 +695,16 @@ 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")); - for id in ["render.pick_label", "render.pick_body", "render.pick_face", "render.pick_component", "render.pick_help"] { + for id in [ + "render.pick_label", + "render.pick_body", + "render.pick_face", + "render.pick_component", + "render.pick_help", + "render.tree_browser", + "render.tree_search", + "render.tree_more", + ] { assert_ne!(locale.text(id), Locale::for_language("en").text(id), "{language}: {id}"); } let session = solidcraft_engine::Session::default(); diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 7cd7adcce..fcc89588a 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -985,9 +985,22 @@ impl SolveApp { solidcraft_engine::slicers::set_chosen_programs(&self.preferences.custom_slicers); } let t0 = now_ms(); + let selected_before = self.session.selection.clone(); let r = self.session.execute(id, ¶ms).map_err(|e| e.to_string()); self.big_operation |= now_ms() - t0 >= recovery_ui::BIG_OPERATION_MS; - self.command_completed(id, r) + let done = self.command_completed(id, r); + // Render focus already applies its semantic selection after clearing object picks. + if done.is_ok() + && id != "view.render_select" + && (self.session.selection != selected_before || matches!(id, "select.set" | "select.clear" | "select.same_look")) + { + self.render_workspace.view.selection = if self.session.selection.is_empty() { + render_workspace::RenderSelection::Nothing + } else { + render_workspace::RenderSelection::Object(self.session.selection.clone()) + }; + } + done } /// Host effects shared by directly executed and already evaluated commands. @@ -1019,6 +1032,20 @@ impl SolveApp { } _ => {} } + if id == "view.render_browser" { + render_workspace::apply_browser_controls(self, v); + } + if id == "view.render_select" { + use render_workspace::RenderSelection; + let selected = match v.get("kind").and_then(Value::as_str) { + Some("environment") => RenderSelection::Environment, + Some("output") => RenderSelection::Output, + Some("light") => RenderSelection::Light(v.get("id").and_then(Value::as_str).unwrap_or_default().into()), + Some("shot") => RenderSelection::Shot(v.get("id").and_then(Value::as_str).unwrap_or_default().into()), + _ => RenderSelection::Nothing, + }; + self.render_workspace.view.selection = selected; + } if id == "view.layout" { let layout = if v.get("mode").and_then(Value::as_str) == Some("compact") { shell::LayoutMode::Docked } else { shell::LayoutMode::Floating }; diff --git a/crates/ui-egui/src/render_ui/scene.rs b/crates/ui-egui/src/render_ui/scene.rs new file mode 100644 index 000000000..0fcae1ce8 --- /dev/null +++ b/crates/ui-egui/src/render_ui/scene.rs @@ -0,0 +1,472 @@ +//! Render scene content in the shared Browser host and row painter. +use super::{ImageMethod, RenderSelection, cpu, hdr, inspector, setups, studio}; +use crate::{ + SolveApp, + browser::{self, Row}, + context_menu::{self, Item}, + theme::Tokens, + ui_kit, +}; +use egui::Color32; +use serde_json::json; +use solidcraft_engine::{ + Sel, + doc::{ModelBody, appearance::Look}, +}; + +#[derive(Default)] +pub(crate) struct Decoration { + pub swatch: Option, + pub name: String, + pub count: String, +} + +pub(crate) fn decoration(app: &SolveApp, names: &[String]) -> Decoration { + if !super::active(app) { + return Decoration::default(); + } + let state = app.session.world_state(); + let bodies: Vec<_> = names.iter().filter_map(|name| state.body(name)).collect(); + let Some(body) = bodies.first() else { return Decoration::default() }; + let look = object_look(app, body); + let mixed = bodies.iter().any(|b| object_look(app, b) != look); + let count = bodies.iter().map(|b| app.session.doc.face_colors(b).len()).fold(0usize, usize::saturating_add); + Decoration { + swatch: Some(if mixed { Tokens::get().text_dim } else { look_color(app, body, look.as_ref()) }), + name: if mixed { app.tr("render.tree_mixed").into() } else { look_name(app, look.as_ref()) }, + count: if count == 0 { + String::new() + } else { + crate::i18n::format(if count == 1 { "render.tree_face_one" } else { "render.tree_face_count" }, &[("count", &count.to_string())]) + }, + } +} + +fn object_look(app: &SolveApp, body: &ModelBody) -> Option { + let face = app.session.selection.iter().rev().find_map(|s| match s { + Sel::Face { body: name, index, .. } if name == &body.name => Some(*index), + _ => None, + }); + face.map_or_else(|| app.session.doc.model_display_look(body), |face| app.session.doc.model_face_look(body, face)) +} + +pub(crate) fn same_look(app: &SolveApp, names: &[String]) -> bool { + let state = app.session.world_state(); + let mut looks = names.iter().filter_map(|name| state.body(name)).map(|body| app.session.doc.model_display_look(body)); + let Some(first) = looks.next() else { return false }; + looks.all(|look| look == first) +} + +fn look_name(app: &SolveApp, look: Option<&Look>) -> String { + look.map_or_else(|| app.tr("render.tree_default").into(), |look| look.name.clone()) +} +fn look_color(app: &SolveApp, body: &ModelBody, look: Option<&Look>) -> Color32 { + let color = look.map(|l| l.color).or_else(|| app.session.doc.body_color(body).map(|c| c.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8))); + color.map_or(Tokens::get().body, |rgb| crate::theme::srgb(rgb.map(|channel| f32::from(channel) / 255.0))) +} + +fn section(app: &mut SolveApp, ui: &mut egui::Ui, key: &str) -> bool { + let id = format!("render:tree:{key}"); + let open = browser::is_open(app, &id, true); + let label = app.tr(&format!("render.tree_{key}")).to_string(); + let add_label = app.tr(if key == "lights" { "render.tree_add_light" } else { "render.tree_add_shot" }).to_string(); + let pending = app.tr("render.tree_lights_pending").to_string(); + let actions = [ui_kit::TreeAction { + icon: "plus", + hover_only: false, + label: &add_label, + reason: (key == "lights").then_some(pending.as_str()), + target: if key == "lights" { "render:tree:lights:add" } else { "render:tree:shots:add" }, + }]; + let row = browser::draw_row( + ui, + ui.id().with(&id), + &Row { + label: &label, + name: true, + icon: match key { + "lights" => "render_scene", + "shots" => "camera", + _ => "box", + }, + secondary: &match key { + "lights" => light_types(app).len(), + "shots" => app.session.doc.render.setups.len(), + _ => app.session.world_state().bodies.len(), + } + .to_string(), + fold: Some(open), + actions: if matches!(key, "lights" | "shots") { &actions } else { &[] }, + ..Default::default() + }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target(&id, rect); + } + if row.actions.iter().any(|r| r.clicked()) { + // The existing Shots manager owns naming and saving. This navigation never saves. + app.start("render.settings.get"); + } + if row.fold || row.clicked { + browser::toggle(app, &id, true); + } + open +} + +fn select(app: &mut SolveApp, kind: &str, id: Option<&str>) { + let params = id.map_or_else(|| json!({"kind":kind}), |id| json!({"kind":kind,"id":id})); + let _ = app.run("view.render_select", params); +} + +pub(crate) fn light_types(app: &SolveApp) -> Vec<&'static str> { + let view = &app.render_workspace.view; + let mut lights = Vec::new(); + match view.method { + ImageMethod::Raster => {} + ImageMethod::CpuRaytrace => { + lights.extend(view.raytrace.lights.iter().flatten().map(|_| "render.tree_directional")); + lights.extend( + view.raytrace.punctual_lights.iter().flatten().map(|l| if l.cone.is_some() { "render.tree_spot" } else { "render.tree_point" }), + ); + lights.extend(view.raytrace.area_lights.iter().flatten().map(|_| "render.tree_rectangle")); + } + ImageMethod::GpuRaytrace if view.studio.lighting_enabled => { + if view.studio.sun_enabled { + lights.push("render.tree_sun"); + } + lights.extend(view.studio.area_lights.iter().map(|_| "render.tree_rectangle")); + } + ImageMethod::GpuRaytrace => {} + } + lights +} + +pub(crate) fn environment(app: &SolveApp) -> (String, String) { + let view = &app.render_workspace.view; + let fixed = || (app.tr("render.tree_fixed_studio").to_string(), view.draft.environment_rotation, view.draft.environment_intensity); + let source = |input: &hdr::Input| match input { + hdr::Input::EmbeddedResource { resource } => format!("{} {resource}", app.tr("render.tree_hdr")), + hdr::Input::FileCaptured { path, .. } | hdr::Input::FilePending { path } => { + std::path::Path::new(path).file_name().map(|s| s.to_string_lossy().into_owned()).unwrap_or_else(|| app.tr("render.tree_hdr").into()) + } + hdr::Input::Empty => app.tr("render.tree_no_environment").into(), + }; + let (name, rotation, intensity) = match view.method { + ImageMethod::CpuRaytrace => match view.cpu.environment { + cpu::Environment::Hdr => (source(&view.cpu.hdr), view.cpu.rotation_rad, view.cpu.intensity), + cpu::Environment::Constant => (app.tr("render.tree_constant").into(), 0.0, view.cpu.intensity), + cpu::Environment::None => fixed(), + }, + ImageMethod::GpuRaytrace => match view.studio.environment { + studio::Environment::Hdr => (source(&view.studio.hdr), view.studio.rotation_rad, view.studio.intensity), + studio::Environment::Sky => (app.tr("render.tree_sky").into(), view.studio.rotation_rad, view.studio.intensity), + studio::Environment::None => fixed(), + }, + ImageMethod::Raster => fixed(), + }; + ( + name, + crate::i18n::format( + "render.tree_environment_values", + &[("rotation", &format!("{:.0}", rotation.to_degrees())), ("intensity", &format!("{intensity:.2}"))], + ), + ) +} + +pub(crate) fn sections(app: &mut SolveApp, ui: &mut egui::Ui) { + setups::refresh_dirty(app); + let (source, _detail) = environment(app); + let open = browser::is_open(app, "render:tree:environment", true); + let environment_label = app.tr("render.tree_environment").to_string(); + let row = browser::draw_row( + ui, + ui.id().with("render_environment"), + &Row { + label: &environment_label, + name: true, + icon: "environment_map", + subtitle: &source, + fold: Some(open), + selected: app.render_workspace.view.selection == RenderSelection::Environment, + ..Default::default() + }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target("render:tree:environment", rect); + crate::scenario::publish_target("render:tree:environment:current", rect); + } + if row.fold { + browser::toggle(app, "render:tree:environment", true); + } + if row.clicked { + select(app, "environment", None); + app.render_workspace.view.inspector.page = inspector::Page::Environment; + } + if section(app, ui, "lights") { + for (index, key) in light_types(app).iter().enumerate() { + let label = app.tr(key).to_string(); + let id = format!("{}:{key}:{index}", app.render_workspace.view.method.label()); + let solo_target = format!("render:tree:light:{index}:solo"); + let mute_target = format!("render:tree:light:{index}:mute"); + let eye_target = format!("render:tree:light:{index}:visibility"); + let pending = app.tr("render.tree_lights_pending"); + let actions = [ + ui_kit::TreeAction { + icon: "lookat", + hover_only: true, + label: app.tr("render.tree_solo"), + reason: Some(pending), + target: &solo_target, + }, + ui_kit::TreeAction { + icon: "suppress", + hover_only: true, + label: app.tr("render.tree_mute"), + reason: Some(pending), + target: &mute_target, + }, + ui_kit::TreeAction { icon: "eye", hover_only: false, label: app.tr("ui.hide"), reason: Some(pending), target: &eye_target }, + ]; + let row = browser::draw_row( + ui, + ui.id().with(("render_light", &id)), + &Row { + depth: 1, + label: &label, + name: true, + icon: "render_scene", + actions: &actions, + selected: app.render_workspace.view.selection == RenderSelection::Light(id.clone()), + ..Default::default() + }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target(&format!("render:tree:light:{index}"), rect); + } + if row.clicked { + select(app, "light", Some(&id)); + app.render_workspace.view.inspector.page = inspector::Page::Lighting; + } + } + } + if section(app, ui, "shots") { + let names: Vec<_> = app.session.doc.render.setups.keys().cloned().collect(); + for name in names { + let active = name == app.render_workspace.view.name; + let row = browser::draw_row( + ui, + ui.id().with(("render_shot", &name)), + &Row { + depth: 1, + label: &name, + name: true, + icon: "camera", + selected: app.render_workspace.view.selection == RenderSelection::Shot(name.clone()), + radio: Some(active), + radio_hint: app.tr("render.tree_switch"), + modified: active && app.render_workspace.view.dirty, + ..Default::default() + }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target(&format!("render:tree:shot:{name}"), rect); + } + if row.clicked || row.radio { + select(app, "shot", Some(&name)); + super::switch_shot(app, name.clone()); + } + if let Some(response) = row.resp { + ui_kit::Menu::context(&response, |ui| { + for (command, key) in [ + ("render.settings.apply", "render.tree_switch"), + ("render.shot.rename", "render.shot_rename"), + ("render.shot.duplicate", "render.shot_duplicate"), + ("render.shot.remove", "render.shot_remove"), + ] { + let item = Item::action(command, app.tr(key), ""); + if context_menu::list_row(ui, &item).is_some() { + if command == "render.settings.apply" { + super::switch_shot(app, name.clone()); + } else { + inspector::shot_row_action(app, name.clone(), command); + } + ui.close(); + } + } + }); + } + } + } +} + +pub(crate) fn output(app: &mut SolveApp, ui: &mut egui::Ui) { + let (size, format) = super::output_summary(app); + let subtitle = format!("{size} · {format}"); + let row = browser::draw_row( + ui, + ui.id().with("render_output"), + &Row { + label: app.tr("render.tree_output"), + icon: "render_image", + name: true, + subtitle: &subtitle, + selected: app.render_workspace.view.selection == RenderSelection::Output, + ..Default::default() + }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target("render:tree:output", rect); + } + if row.clicked { + select(app, "output", None); + } +} + +#[derive(Debug)] +pub(crate) struct LookGroup { + pub look: Option, + pub objects: Vec, +} + +pub(crate) fn groups(app: &SolveApp) -> Vec { + let mut groups: Vec = Vec::new(); + for body in &app.session.world_state().bodies { + for look in app.session.doc.model_used_looks(body) { + if let Some(group) = groups.iter_mut().find(|g| g.look == look) { + group.objects.push(body.name.clone()); + } else { + groups.push(LookGroup { look, objects: vec![body.name.clone()] }); + } + } + } + groups.sort_by_key(|g| look_name(app, g.look.as_ref())); + groups +} + +/// Returns true when the object section is closed or the By look lens drew its objects. +pub(crate) fn objects(app: &mut SolveApp, ui: &mut egui::Ui, hover_bodies: &mut Vec, hovered: &mut bool) -> bool { + if app.tree.reveal.is_some() { + app.tree.collapsed.remove("render:tree:objects"); + } + if !section(app, ui, "objects") { + return true; + } + if !app.render_workspace.view.by_look { + return false; + } + for (index, group) in groups(app).into_iter().enumerate() { + let key = format!("render:look:{:?}", group.look); + if app.tree.reveal.as_ref().is_some_and(|b| group.objects.contains(b)) { + app.tree.collapsed.remove(&key); + } + let open = browser::is_open(app, &key, true); + let label = look_name(app, group.look.as_ref()); + let count = crate::i18n::format( + if group.objects.len() == 1 { "render.tree_user_one" } else { "render.tree_users" }, + &[("count", &group.objects.len().to_string())], + ); + let row = browser::draw_row( + ui, + ui.id().with(("render_look", &key)), + &Row { + depth: 1, + label: &label, + name: true, + fold: Some(open), + count: &count, + swatch: Some( + group.look.as_ref().map_or(Tokens::get().body, |l| crate::theme::srgb(l.color.map(|channel| f32::from(channel) / 255.0))), + ), + ..Default::default() + }, + ); + if let Some(rect) = row.rect { + crate::scenario::publish_target(&format!("render:tree:look:{index}"), rect); + } + if row.fold { + browser::toggle(app, &key, true); + } + let source = group.objects.first().and_then(|name| { + let state = app.session.world_state(); + let body = state.body(name)?; + let face = if app.session.doc.model_display_look(body) == group.look { + None + } else { + app.session.doc.face_colors(body).into_iter().find(|(_, look)| Some(look) == group.look.as_ref()).map(|(index, _)| index) + }; + Some(json!({"body":name,"face":face})) + }); + if row.clicked + && let Some(params) = &source + { + let _ = app.run("select.same_look", params.clone()); + } + if let Some(response) = row.resp { + ui_kit::Menu::context(&response, |ui| { + let item = context_menu::cmd(app, "select.same_look", "Select Same Look"); + if context_menu::list_row(ui, &item).is_some() + && let Some(params) = &source + { + let _ = app.run("select.same_look", params.clone()); + ui.close(); + } + }); + } + if open { + for name in group.objects { + let decoration = decoration(app, std::slice::from_ref(&name)); + if !matches_query(app, &name, &decoration.name) { + continue; + } + let visible = !app.session.visibility.hidden_bodies.contains(&name); + let selected = app.session.selection.iter().any(|s| match s { + Sel::Occurrence { path } => app.session.occurrence_bodies(path, true).is_ok_and(|bodies| bodies.contains(&name)), + _ => browser::picked_body(s) == Some(&name), + }); + let row = browser::draw_row( + ui, + ui.id().with((&key, &name)), + &Row { + depth: 2, + label: &name, + name: true, + eye: Some(visible), + selected, + dim: !app.session.body_visible(&name), + swatch: decoration.swatch, + secondary: &decoration.name, + count: &decoration.count, + ..Default::default() + }, + ); + if row.clicked { + let _ = app.run( + "select.set", + json!({"items":[Sel::Body {name:name.clone()}],"add":ui.input(|i|i.modifiers.command || i.modifiers.ctrl)}), + ); + } + if row.eye { + let _ = app.run("browser.visibility", json!({"items":[name],"visible":!visible})); + } + if row.hovered { + *hover_bodies = vec![name.clone()]; + *hovered = true; + } + if app.tree.reveal.as_ref() == Some(&name) + && let Some(rect) = row.rect + { + ui.scroll_to_rect(rect, Some(egui::Align::Center)); + } + if let Some(at) = row.secondary { + context_menu::open_for(app, at, context_menu::Target::Body { name }); + } + } + } + } + true +} + +pub(crate) fn matches_query(app: &SolveApp, name: &str, look: &str) -> bool { + let query = app.render_workspace.view.object_query.trim().to_lowercase(); + !app.render_workspace.view.search_objects || query.is_empty() || name.to_lowercase().contains(&query) || look.to_lowercase().contains(&query) +} diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs index b3b102ef6..49facceb7 100644 --- a/crates/ui-egui/src/render_workspace.rs +++ b/crates/ui-egui/src/render_workspace.rs @@ -43,6 +43,9 @@ mod materials; #[path = "render_workspace_setups.rs"] mod setups; +#[path = "render_ui/scene.rs"] +pub(crate) mod scene; + #[path = "render_workspace_studio.rs"] mod studio; #[path = "render_workspace_transport.rs"] @@ -240,11 +243,28 @@ impl Stage { } } +/// Browser focus is transient per-document view state, never part of a saved design. +#[derive(Clone, Debug, Default, PartialEq)] +pub enum RenderSelection { + #[default] + Nothing, + Object(Vec), + Environment, + /// Method/type/index identity until named light commands provide persistent IDs. + Light(String), + Shot(String), + Output, +} + /// Small per-document editor state; GPU uploads and host capabilities stay outside tabs. #[derive(Clone, Debug)] pub struct ViewState { pub name: String, + pub selection: RenderSelection, pub(crate) stage: Stage, + pub(crate) by_look: bool, + pub(crate) search_objects: bool, + pub(crate) object_query: String, draft: RenderSetup, dirty: bool, clean_setup: Option, @@ -299,7 +319,11 @@ impl Default for ViewState { fn default() -> Self { Self { name: "Studio".into(), + selection: RenderSelection::Nothing, stage: Stage::Look, + by_look: false, + search_objects: false, + object_query: String::new(), draft: RenderSetup::default(), dirty: false, clean_setup: None, @@ -557,8 +581,15 @@ pub(crate) fn select_stage(app: &mut SolveApp, key: &str) { }; app.render_workspace.view.stage = stage; app.render_workspace.view.inspector.page = stage.page(); - // The current Browser has model folders only. Reveal Objects for Look; scene-specific - // Lights/Shots/Output expansion belongs to the scene Browser implementation. + let sections: &[&str] = match stage { + Stage::Look => &["objects"], + Stage::Light => &["lights", "environment"], + Stage::Frame => &["shots"], + Stage::Output => &[], + }; + for section in sections { + app.tree.collapsed.remove(&format!("render:tree:{section}")); + } if stage == Stage::Look { app.tree.collapsed.remove("c0"); app.tree.collapsed.remove("c0/bodies"); @@ -590,24 +621,35 @@ pub fn panel(app: &mut SolveApp, ui: &mut egui::Ui) { inspector::panel(app, ui); } +pub(crate) fn apply_browser_controls(app: &mut SolveApp, value: &serde_json::Value) { + let view = &mut app.render_workspace.view; + if let Some(by_look) = value.get("by_look").and_then(serde_json::Value::as_bool) { + view.by_look = by_look; + view.inspector.library_open = false; + } + if let Some(search) = value.get("search").and_then(serde_json::Value::as_bool) { + view.search_objects = search; + view.inspector.library_open = false; + } + if let Some(query) = value.get("query").and_then(serde_json::Value::as_str) { + view.object_query = query.into(); + } +} + /// Local Browser-card content, never a new workspace or an alternative model tree. pub(crate) fn browser_mode(app: &mut SolveApp, ui: &mut egui::Ui) -> bool { if !active(app) { return false; } - let labels = [app.tr("render.browser_model").to_string(), app.tr("render.browser_library").to_string()]; - let mut selected = usize::from(app.render_workspace.view.inspector.library_open); - let top = ui.cursor().min; - let width = ui.available_width(); - crate::ui_kit::segmented(ui, &mut selected, &labels.iter().map(String::as_str).collect::>(), Default::default()); - for (i, name) in ["render:browser-model", "render:browser-library"].iter().enumerate() { - crate::scenario::publish_target( - name, - egui::Rect::from_min_size(top + egui::vec2(width * i as f32 / 2.0, 0.0), egui::vec2(width / 2.0, crate::ui_kit::row_height())), - ); + if app.render_workspace.view.search_objects { + let mut query = app.render_workspace.view.object_query.clone(); + crate::ui_kit::scope(ui, |ui| { + if crate::ui_kit::search_field(ui, ui.id().with("render:tree:query"), &mut query, crate::i18n::tr("render.tree_search")).changed() { + let _ = app.run("view.render_browser", json!({"query":query})); + } + }); } - app.render_workspace.view.inspector.library_open = selected == 1; - if selected == 1 { + if app.render_workspace.view.inspector.library_open { crate::ui_kit::scope(ui, |ui| library::browse(app, ui)); true } else { diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs index 9783ad03d..cd7f87be4 100644 --- a/crates/ui-egui/src/render_workspace_inspector.rs +++ b/crates/ui-egui/src/render_workspace_inspector.rs @@ -162,6 +162,7 @@ struct Pending { #[derive(Clone, Debug)] enum PendingAction { Switch(String), + ManageShot { name: String, command: String }, Reload, Remove(String), } @@ -373,6 +374,15 @@ pub(super) fn switch_shot(app: &mut SolveApp, name: String) { request_action(app, PendingAction::Switch(name)); } +pub(super) fn shot_row_action(app: &mut SolveApp, name: String, command: &str) { + setups::refresh_dirty(app); + if command == "render.shot.remove" { + request_action(app, PendingAction::Remove(name)); + } else { + request_action(app, PendingAction::ManageShot { name, command: command.into() }); + } +} + fn request_action(app: &mut SolveApp, action: PendingAction) { if app.render_workspace.view.dirty || matches!(&action, PendingAction::Remove(_)) { app.render_workspace.view.inspector.pending = @@ -387,11 +397,19 @@ fn perform_action(app: &mut SolveApp, action: PendingAction) -> Result<(), Strin app.render_workspace.view.name = name; setups::load(app); } + PendingAction::ManageShot { name, command } => { + app.render_workspace.view.name = name; + setups::load(app); + // The existing manager owns name validation and command execution. + app.start(&command); + } PendingAction::Reload => setups::load(app), PendingAction::Remove(name) => { app.run("render.shot.remove", json!({"name":name,"expected_revision":app.session.revision}))?; - app.render_workspace.view.name = app.session.doc.render.setups.keys().next().cloned().unwrap_or_else(|| "Studio".into()); - setups::load(app); + if name == app.render_workspace.view.name { + app.render_workspace.view.name = app.session.doc.render.setups.keys().next().cloned().unwrap_or_else(|| "Studio".into()); + setups::load(app); + } } } Ok(()) diff --git a/crates/ui-egui/src/render_workspace_inspector_tests.rs b/crates/ui-egui/src/render_workspace_inspector_tests.rs index 88e816095..898b3560a 100644 --- a/crates/ui-egui/src/render_workspace_inspector_tests.rs +++ b/crates/ui-egui/src/render_workspace_inspector_tests.rs @@ -721,3 +721,39 @@ fn shots_strip_render_submits_the_current_job_request() { assert_eq!(status.request.background, [31, 57, 83]); assert_eq!(h.app.session.doc, document); } + +#[test] +fn browser_shot_menus_keep_target_and_draft_through_confirmation() { + let mut h = fixture(); + h.app.render_workspace.view.name = "A".into(); + setups::save(&mut h.app).unwrap(); + h.app.run("render.settings.set", json!({"name":"B","set":{"width":321,"job":{"method":"raster"}}})).unwrap(); + h.app.render_workspace.view.draft.width = 123; + h.frames(3); + h.step(&json!({"click":{"handle":"render:tree:shot:B"},"button":"right"})).unwrap(); + h.step(&json!({"widget":h.app.tr("render.shot_rename")})).unwrap(); + assert!(confirmation_open(&h.app)); + assert_eq!(h.app.render_workspace.view.name, "A"); + h.step(&json!({"widget":h.app.tr("render.keep_editing")})).unwrap(); + assert_eq!(h.app.render_workspace.view.draft.width, 123); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Output); + shot_row_action(&mut h.app, "B".into(), "render.shot.rename"); + h.frames(3); + h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap(); + assert_eq!(h.app.render_workspace.view.name, "B"); + assert_eq!(h.app.render_workspace.view.inspector.page, Page::Scene); + assert_eq!(h.app.render_workspace.view.draft.width, 321); + h.app.render_workspace.view.draft.width = 456; + shot_row_action(&mut h.app, "A".into(), "render.shot.remove"); + h.frames(3); + assert!(confirmation_open(&h.app)); + h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap(); + assert!( + !h.app.session.doc.render.setups.contains_key("A"), + "pending={:?}, status={:?}", + h.app.render_workspace.view.inspector.pending, + h.app.status + ); + 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"); +} diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs index 8f1ca40a3..851d097a4 100644 --- a/crates/ui-egui/src/render_workspace_tests.rs +++ b/crates/ui-egui/src/render_workspace_tests.rs @@ -3395,7 +3395,8 @@ fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() { let inspector = h.app.shell.workspace_panels["render:inspector"].0; let browser = h.app.shell.workspace_panels["render:browser"].0; let ribbon_bottom = h.app.shell.cards.iter().map(|r| r.bottom()).fold(0.0, f32::max); - assert!((inspector.bottom() - browser.bottom()).abs() < 1.0); + assert!((browser.top() - inspector.top()).abs() < 1.0); + assert!((browser.bottom() - inspector.bottom()).abs() < 1.0); for key in ["render:browser", "render:inspector"] { let card = h.app.shell.workspace_panels[key].0; assert!( @@ -3409,8 +3410,12 @@ fn render_workspace_hosts_float_and_shield_input_in_both_ribbon_layouts() { let header = crate::scenario::rect_of(&format!("{key}:header")).unwrap(); assert!((header.height() - crate::ui_kit::header_height()).abs() < 0.1, "{key}: {header:?}"); assert!((header.top() - card.top()).abs() <= 1.0, "header must have no outer content padding"); - let control = crate::scenario::rect_of(if key == "render:browser" { "render:browser-library" } else { "render:page:output" }).unwrap(); - assert!(control.top() >= header.bottom(), "navigation must be below the standard header: {control:?} {header:?}"); + let control = crate::scenario::rect_of(if key == "render:browser" { "render:tree:by-look" } else { "render:page:output" }).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!(browser.left() > viewport.left() && inspector.right() < viewport.right()); @@ -3461,7 +3466,7 @@ fn render_workspace_card_grips_swap_sides_and_resize_without_design_edits() { assert!(h.app.preferences.render_inspector_width > width); assert!(h.app.shell.workspace_panels["render:inspector"].0.width() > card_width); } - h.step(&json!({"click":{"handle":"render:browser-library"}})).unwrap(); + h.step(&json!({"click":{"handle":"render:tree:by-look"}})).unwrap(); h.frames(3); h.step(&json!({"drag":[{"handle":"render:browser:grip"},[100.0,350.0]],"steps":8})).unwrap(); h.frames(3); @@ -3757,6 +3762,95 @@ fn navigation_bar_render_canvases_filter_slots_and_keep_product_fit() { } } +#[test] +fn render_workspace_browser_sections_and_lights_describe_only_current_job_entries() { + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1100})); + enter(&mut h.app, true).unwrap(); + h.frames(3); + let rows: Vec<_> = crate::browser::drawn_rows().into_iter().map(|r| r.0).collect(); + for section in ["Environment", "Lights", "Shots", "Objects"] { + assert!(rows.iter().any(|label| label == section), "{section}: {rows:?}"); + } + assert!(scene::light_types(&h.app).is_empty()); + assert_eq!(scene::environment(&h.app).0, "Fixed studio"); + h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; + h.app.render_workspace.view.raytrace = serde_json::from_value(json!({ + "lights":[{"direction":[0,0,-1],"color":[1,1,1],"intensity":1}], + "punctual_lights":[ + {"position_mm":[0,0,10],"color":[1,1,1],"intensity":1,"reference_distance_mm":10,"minimum_distance_mm":0.1}, + {"position_mm":[0,0,10],"color":[1,1,1],"intensity":1,"reference_distance_mm":10,"minimum_distance_mm":0.1, + "cone":{"emitted_axis":[0,0,-1],"inner_half_angle_radians":0.1,"outer_half_angle_radians":0.2}} + ], + "area_lights":[{"center_mm":[0,0,10],"edge_u_mm":[1,0,0],"edge_v_mm":[0,-1,0],"color":[1,1,1],"intensity":1}] + })) + .unwrap(); + assert_eq!(scene::light_types(&h.app), ["render.tree_directional", "render.tree_point", "render.tree_spot", "render.tree_rectangle"]); + h.app.render_workspace.view.raytrace.lights = Some(vec![]); + h.app.render_workspace.view.raytrace.punctual_lights = None; + h.app.render_workspace.view.raytrace.area_lights = None; + assert!(scene::light_types(&h.app).is_empty(), "empty explicit rig must stay empty"); + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; + let studio = &mut h.app.render_workspace.view.studio; + studio.sun_enabled = true; + assert!(scene::light_types(&h.app).is_empty(), "disabled rig must not expose editor defaults"); + h.app.render_workspace.view.studio.lighting_enabled = true; + h.app + .render_workspace + .view + .studio + .area_lights + .push(serde_json::from_value(json!({"center":[0,0,10],"u":[1,0,0],"v":[0,-1,0],"radiance":[1,1,1]})).unwrap()); + assert_eq!(scene::light_types(&h.app), ["render.tree_sun", "render.tree_rectangle"]); + h.app.render_workspace.view.studio.environment = studio::Environment::Sky; + h.app.render_workspace.view.studio.rotation_rad = std::f64::consts::FRAC_PI_2; + h.app.render_workspace.view.studio.intensity = 2.5; + assert_eq!(scene::environment(&h.app), ("Sky".into(), "90° · 2.50×".into())); + h.frames(3); + h.step(&json!({"click":{"handle":"render:tree:environment:current"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Environment); + h.step(&json!({"click":{"browser":"Sun"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Lighting); +} + +#[test] +fn render_workspace_browser_look_lens_counts_distinct_objects_and_selects_them() { + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1100})); + for (name, x) in [("A", 0), ("B", 20), ("C", 40)] { + h.app.run("solid.box", json!({"corner":[x,0,0],"length":10,"width":10,"height":10,"body_name":name})).unwrap(); + } + h.app.run("appearance.assign", json!({"bodies":["A","B"],"appearance":"ABS - Red"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["C"],"appearance":"ABS - Blue"})).unwrap(); + // Two faces on C use the same look as A and B: still only one additional user. + h.app.run("appearance.assign", json!({"body":"C","faces":[[40,5,5],[45,0,5]],"appearance":"ABS - Red"})).unwrap(); + enter(&mut h.app, true).unwrap(); + let groups = scene::groups(&h.app); + let red = groups.iter().position(|g| g.look.as_ref().is_some_and(|l| l.name == "ABS - Red")).unwrap(); + assert_eq!(groups[red].objects, ["A", "B", "C"]); + assert_eq!(groups.len(), 2); + h.app.render_workspace.view.by_look = true; + h.frames(3); + let at = crate::scenario::handle_at("row:A").unwrap(); + h.step(&json!({"move":[at.x,at.y]})).unwrap(); + h.frames(2); + assert_eq!(h.app.viewport.hover_bodies, ["A"], "By look rows retain Browser hover outlines"); + h.step(&json!({"move":[1000.0,800.0]})).unwrap(); + h.frames(2); + assert!(h.app.viewport.hover_bodies.is_empty(), "leaving the row clears its hover outline"); + h.step(&json!({"click":{"handle":format!("render:tree:look:{red}")}})).unwrap(); + assert_eq!(h.app.session.selection.len(), 3); + for name in ["A", "B", "C"] { + assert!(h.app.session.selection.contains(&solidcraft_engine::Sel::Body { name: name.into() })); + } + h.step(&json!({"click":{"handle":"eye:A"}})).unwrap(); + assert!(h.app.session.visibility.hidden_bodies.contains(&"A".into())); + let menu = crate::context_menu::items(&h.app, &crate::context_menu::Target::Body { name: "A".into() }); + for id in ["select.set", "select.same_look", "ui.isolate", "ui.show"] { + assert!(menu.iter().any(|i| i.id == id)); + } +} + #[test] fn render_workspace_dock_command_swaps_sides_without_design_edits() { for layout in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] { @@ -3832,3 +3926,317 @@ fn render_workspace_dock_grip_menus_dispatch_the_other_side() { } } } + +#[test] +fn render_workspace_browser_shot_switch_keeps_the_existing_dirty_confirmation() { + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1100})); + enter(&mut h.app, true).unwrap(); + h.app.render_workspace.view.name = "A".into(); + setups::save(&mut h.app).unwrap(); + h.app.run("render.settings.set", json!({"name":"B","set":{"width":321,"job":{"method":"raster"}}})).unwrap(); + h.app.render_workspace.view.draft.width = 123; + h.frames(3); + h.step(&json!({"click":{"handle":"render:tree:shot:B"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.name, "A"); + assert!(inspector::confirmation_open(&h.app)); + h.step(&json!({"widget":h.app.tr("render.keep_editing")})).unwrap(); + assert_eq!(h.app.render_workspace.view.draft.width, 123); + h.step(&json!({"click":{"handle":"render:tree:shot:B"}})).unwrap(); + h.step(&json!({"widget":h.app.tr("render.discard_continue")})).unwrap(); + assert_eq!(h.app.render_workspace.view.name, "B"); + assert_eq!(h.app.render_workspace.view.draft.width, 321); + assert!(!h.app.render_workspace.view.dirty); +} + +#[test] +fn render_workspace_browser_focus_covers_each_kind_without_design_edits() { + use solidcraft_engine::Sel; + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1400})); + h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"body_name":"Object"})).unwrap(); + h.app.run("render.settings.set", json!({"name":"Shot","set":{"job":{"method":"raster"}}})).unwrap(); + enter(&mut h.app, true).unwrap(); + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; + h.app.render_workspace.view.studio.lighting_enabled = true; + h.app.render_workspace.view.studio.sun_enabled = true; + h.frames(3); + let doc = h.app.session.doc.clone(); + let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); + for label in ["Environment", "Lights", "Shots", "Objects", "Output"] { + assert!(crate::browser::drawn_rows().iter().any(|r| r.0 == label), "{label}"); + } + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Nothing); + h.step(&json!({"click":{"handle":"row:Object"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Object(vec![Sel::Body { name: "Object".into() }])); + h.step(&json!({"click":{"handle":"render:tree:environment"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Environment); + assert!(h.app.session.selection.is_empty()); + let focused_revision = h.app.session.revision; + h.step(&json!({"click":{"handle":"render:tree:light:0"}})).unwrap(); + assert!(matches!(&h.app.render_workspace.view.selection, RenderSelection::Light(id) if id.contains("sun"))); + setups::load(&mut h.app); + h.frames(3); + h.step(&json!({"click":{"handle":"render:tree:shot:Shot"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Shot("Shot".into())); + h.step(&json!({"click":{"handle":"render:tree:output"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Output); + let page = h.app.render_workspace.view.inspector.page; + h.app.run("view.render_select", json!({"kind":"nothing"})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Nothing); + assert_eq!(h.app.render_workspace.view.inspector.page, page, "focus alone does not dispatch Inspector editors"); + assert_eq!(h.app.session.revision, focused_revision, "semantic selection only refreshes the view when clearing object picks"); + assert!(Arc::ptr_eq(&doc, &h.app.session.doc)); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty())); + assert!(h.app.dialog.is_none() && h.app.tool.is_none()); +} + +#[test] +fn render_workspace_browser_add_and_light_actions_share_disabled_reasons_and_never_edit() { + fn has_text(shape: &egui::Shape, needle: &str) -> bool { + match shape { + egui::Shape::Text(text) => text.galley.text().contains(needle), + egui::Shape::Vec(shapes) => shapes.iter().any(|shape| has_text(shape, needle)), + _ => false, + } + } + let mut h = Harness::new(); + h.call("ui.resize", json!({"width":1440,"height":1200})); + enter(&mut h.app, true).unwrap(); + h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; + h.app.render_workspace.view.studio.lighting_enabled = true; + h.app.render_workspace.view.studio.sun_enabled = true; + h.frames(3); + let doc = h.app.session.doc.clone(); + let history = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision); + for target in ["render:tree:lights:add", "render:tree:light:0:solo", "render:tree:light:0:mute", "render:tree:light:0:visibility"] { + assert!(crate::scenario::handle_at(target).is_none(), "{target} must be disabled"); + let at = crate::scenario::rect_of(target).unwrap().center(); + h.step(&json!({"move":[at.x,at.y]})).unwrap(); + h.frames(120); + assert!(h.shapes.iter().any(|s| has_text(&s.shape, h.app.tr("render.tree_lights_pending"))), "{target}: must show its disabled reason"); + h.step(&json!({"click":[at.x,at.y]})).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Nothing); + } + assert!(crate::scenario::handle_at("render:tree:shots:add").is_some()); + h.step(&json!({"click":{"handle":"render:tree:shots:add"}})).unwrap(); + assert_eq!(h.app.render_workspace.view.inspector.page, inspector::Page::Scene); + assert!(Arc::ptr_eq(&doc, &h.app.session.doc)); + assert_eq!(history, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision)); + assert!(h.app.dialog.is_none()); +} + +#[test] +fn render_workspace_browser_stage_expansion_never_locks_rows_or_changes_focus() { + let mut h = Harness::new(); + enter(&mut h.app, true).unwrap(); + h.app.run("view.render_select", json!({"kind":"output"})).unwrap(); + let doc = h.app.session.doc.clone(); + let sections = ["objects", "lights", "environment", "shots"]; + for (stage, expanded) in [("look", vec!["objects"]), ("light", vec!["lights", "environment"]), ("frame", vec!["shots"]), ("output", vec![])] { + for section in sections { + h.app.tree.collapsed.insert(format!("render:tree:{section}")); + } + h.app.run("view.render_stage", json!({"stage":stage})).unwrap(); + for section in sections { + assert_eq!(crate::browser::is_open(&h.app, &format!("render:tree:{section}"), true), expanded.contains(§ion), "{stage}/{section}"); + crate::browser::toggle(&mut h.app, &format!("render:tree:{section}"), true); + assert_eq!(crate::browser::is_open(&h.app, &format!("render:tree:{section}"), true), !expanded.contains(§ion)); + } + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Output); + } + assert!(Arc::ptr_eq(&doc, &h.app.session.doc)); +} + +#[test] +fn render_workspace_browser_semantic_focus_survives_clearing_object_picks() { + use solidcraft_engine::Sel; + let mut h = Harness::new(); + h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"body_name":"Object"})).unwrap(); + enter(&mut h.app, true).unwrap(); + let doc = h.app.session.doc.clone(); + let evaluated = h.app.session.world_state(); + let before = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); + for (request, expected) in [ + (json!({"kind":"environment"}), RenderSelection::Environment), + (json!({"kind":"light","id":"sun"}), RenderSelection::Light("sun".into())), + (json!({"kind":"shot","id":"Shot"}), RenderSelection::Shot("Shot".into())), + (json!({"kind":"output"}), RenderSelection::Output), + (json!({"kind":"nothing"}), RenderSelection::Nothing), + ] { + h.app.run("select.set", json!({"items":[Sel::Body { name:"Object".into() }]})).unwrap(); + assert!(matches!(h.app.render_workspace.view.selection, RenderSelection::Object(_))); + h.app.run("view.render_select", request.clone()).unwrap(); + h.frames(2); + assert_eq!(h.app.render_workspace.view.selection, expected, "{request}"); + assert!(h.app.session.selection.is_empty()); + } + assert!(Arc::ptr_eq(&doc, &h.app.session.doc)); + assert!(Arc::ptr_eq(&evaluated, &h.app.session.world_state())); + assert_eq!(before, (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty())); +} + +#[test] +fn render_workspace_browser_focus_is_per_document_and_invalid_selection_is_atomic() { + let mut h = Harness::new(); + h.app.run("view.render_select", json!({"kind":"environment"})).unwrap(); + let doc = h.app.session.doc.clone(); + for request in [ + json!({}), + json!({"kind":"object"}), + json!({"kind":"light"}), + json!({"kind":"shot","id":""}), + json!({"kind":"output","id":"x"}), + json!({"kind":"shot","id":"x".repeat(1025)}), + json!({"kind":"nothing","extra":1}), + ] { + assert!(h.app.run("view.render_select", request).is_err()); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Environment); + } + assert!(Arc::ptr_eq(&doc, &h.app.session.doc)); + crate::documents::open_tab(&mut h.app, Session::default()).unwrap(); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Nothing); + h.app.run("view.render_select", json!({"kind":"output"})).unwrap(); + crate::documents::switch(&mut h.app, 0); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Environment); + crate::documents::switch(&mut h.app, 1); + assert_eq!(h.app.render_workspace.view.selection, RenderSelection::Output); +} + +/// Actual application tree at the approved card width, in both themes and both task states. +#[test] +fn render_workspace_browser_compact_geometry_search_and_theme_evidence() { + let previous = crate::theme::is_dark(); + let mut themes = Vec::new(); + for dark in [false, true] { + let mut h = Harness::new(); + for (name, x, appearance) in [ + ("Plate", 0, "Aluminum - Satin"), + ("Boss", 20, "Aluminum - Anodized Blue"), + ("Knob", 40, "Copper"), + ("Cover", 60, "Glass - Clear"), + ("Spacer", 80, "Aluminum - Satin"), + ("Bolt", 100, "Aluminum - Satin"), + ("Nut", 120, "Aluminum - Satin"), + ] { + h.app.run("solid.box", json!({"corner":[x,0,0],"length":10,"width":10,"height":10,"body_name":name})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":[name],"appearance":appearance})).unwrap(); + } + let group = + h.app.run("browser.group", json!({"folder":"bodies","name":"Spacer, fasteners","items":["Spacer","Bolt","Nut"]})).unwrap()["group"] + .as_u64() + .unwrap(); + h.app.tree.collapsed.insert(format!("c0/g{group}")); + for name in ["Hero", "Front", "Detail"] { + h.app.run("render.settings.set", json!({"name":name,"set":{"width":1920,"height":1080}})).unwrap(); + } + enter(&mut h.app, true).unwrap(); + h.app.preferences.render_browser_width = 266.0; + h.app.render_workspace.view.draft.width = 1920; + h.app.render_workspace.view.draft.height = 1080; + h.app.ui.dark = dark; + h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body {name:"Boss".into()}]})).unwrap(); + let ctx = crate::fonts::test_context(); + let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0)); + let mut textures = std::collections::HashMap::new(); + let mut images = Vec::new(); + for stage in ["look", "light"] { + h.app.run("view.render_stage", json!({"stage":stage})).unwrap(); + h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; + h.app.render_workspace.view.raytrace.lights = Some(serde_json::from_value(json!([{"direction":[0,0,-1],"color":[1,1,1],"intensity":1},{"direction":[1,0,0],"color":[1,1,1],"intensity":1},{"direction":[0,1,0],"color":[1,1,1],"intensity":1}])).unwrap()); + for section in ["lights", "shots", "objects"] { + if (stage == "look" && section == "objects") || (stage == "light" && section == "lights") { + h.app.tree.collapsed.remove(&format!("render:tree:{section}")); + } else { + h.app.tree.collapsed.insert(format!("render:tree:{section}")); + } + } + if stage == "light" { + h.app + .run( + "view.render_select", + json!({"kind":"light","id":format!("{}:render.tree_directional:0",h.app.render_workspace.view.method.label())}), + ) + .unwrap(); + } + let mut image = None; + for frame in 0..12 { + crate::scenario::clear_handles(); + let mut output = ctx.run_ui( + egui::RawInput { + screen_rect: Some(bounds), + time: Some(ctx.cumulative_frame_nr() as f64 / 60.0), + focused: true, + ..Default::default() + }, + |ui| { + h.app.logic(ui.ctx()); + h.app.ui(ui); + }, + ); + crate::ui_kit::test_textures_update(&mut textures, &output.textures_delta); + output.textures_delta.clear(); + if frame == 11 { + let card = crate::scenario::rect_of("browser:card").unwrap(); + assert!((card.width() - 266.0).abs() < 0.1); + let inspector = crate::scenario::rect_of("render:inspector").unwrap(); + assert!((card.top() - inspector.top()).abs() < 0.1); + assert!((card.bottom() - inspector.bottom()).abs() < 0.1); + let header = crate::scenario::rect_of("render:browser:header").unwrap(); + assert!(header.contains_rect(crate::scenario::rect_of("render:tree:by-look").unwrap())); + assert!(crate::scenario::handle_at("render:browser-model").is_none()); + assert!(crate::scenario::handle_at("render:browser-library").is_none()); + for (name, row, _, _) in crate::browser::drawn_rows() { + assert!((row.height() - 28.0).abs() < 0.1, "{name}: {row:?}"); + } + if stage == "look" { + let row = crate::browser::drawn_rows().into_iter().find(|r| r.0 == "Boss").unwrap().1; + assert!((row.width() - (card.width() - 2.0)).abs() < 0.1); + assert!(crate::scenario::handle_at("eye:Boss").unwrap().x > row.right() - 24.0); + } + if std::env::var_os("SOLIDCRAFT_BROWSER_EVIDENCE").is_some() { + let full = crate::ui_kit::test_raster(&ctx, output.shapes, output.pixels_per_point, bounds, &textures); + image = Some( + image::imageops::crop_imm(&full, card.left() as u32, card.top() as u32, card.width() as u32, card.height() as u32) + .to_image(), + ); + } + } + } + if let (Some(image), Ok(dir)) = (image, std::env::var("SOLIDCRAFT_BROWSER_EVIDENCE")) { + std::fs::create_dir_all(&dir).unwrap(); + image.save(std::path::Path::new(&dir).join(format!("scene-{stage}-{}.png", if dark { "dark" } else { "light" }))).unwrap(); + images.push(image); + } + } + if let (Some(look), Some(light), Ok(dir)) = (images.first(), images.get(1), std::env::var("SOLIDCRAFT_BROWSER_EVIDENCE")) { + let mut pair = image::RgbaImage::new(look.width() + light.width(), look.height().max(light.height())); + image::imageops::overlay(&mut pair, look, 0, 0); + image::imageops::overlay(&mut pair, light, 266, 0); + pair.save(std::path::Path::new(&dir).join(format!("scene-stages-{}.png", if dark { "dark" } else { "light" }))).unwrap(); + } + themes.push(images); + h.app.run("view.render_browser", json!({"search":true,"query":"Copper"})).unwrap(); + h.app.tree.collapsed.remove("render:tree:objects"); + h.frames(4); + let rows = crate::browser::drawn_rows(); + assert!(rows.iter().any(|r| r.0 == "Knob")); + assert!(!rows.iter().any(|r| r.0 == "Boss")); + h.app.run("view.render_browser", json!({"search":false})).unwrap(); + h.frames(3); + assert!(crate::browser::drawn_rows().iter().any(|r| r.0 == "Boss")); + for hidden in [true, false] { + h.step(&json!({"click":{"handle":"eye:Boss"}})).unwrap(); + assert_eq!(h.app.session.visibility.hidden_bodies.iter().any(|name| name == "Boss"), hidden); + } + } + if let (Some(light), Some(dark), Ok(dir)) = (themes.first(), themes.get(1), std::env::var("SOLIDCRAFT_BROWSER_EVIDENCE")) { + for (index, stage) in ["look", "light"].iter().enumerate() { + let mut pair = image::RgbaImage::new(light[index].width() + dark[index].width(), light[index].height().max(dark[index].height())); + image::imageops::overlay(&mut pair, &light[index], 0, 0); + image::imageops::overlay(&mut pair, &dark[index], 266, 0); + pair.save(std::path::Path::new(&dir).join(format!("scene-{stage}-themes.png"))).unwrap(); + } + } + crate::theme::set_dark(previous); +} diff --git a/crates/ui-egui/src/ui_kit/choice.rs b/crates/ui-egui/src/ui_kit/choice.rs index 165d7fe99..88a5c61d4 100644 --- a/crates/ui-egui/src/ui_kit/choice.rs +++ b/crates/ui-egui/src/ui_kit/choice.rs @@ -18,6 +18,7 @@ pub(crate) struct Segments<'a> { pub icons: &'a [&'a str], pub workspace_accent: bool, pub dense: bool, + pub small: bool, pub states: &'a [bool], pub compact: bool, pub primary: bool, @@ -32,14 +33,15 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con if crate::prefs_search::querying(ui) && !crate::prefs_search::shows_all(ui) { crate::prefs_search::reveal(ui); } - let Segments { targets, icons, workspace_accent, dense, states, compact, primary, intrinsic, proportional } = config; + let Segments { targets, icons, workspace_accent, dense, small, states, compact, primary, intrinsic, proportional } = config; let accent = crate::theme::TabAccent::current(ui.ctx()); let t = Tokens::get(); + let font_size = if small { t.font_small } else { t.font_label }; let natural: Vec<_> = options .iter() .enumerate() .map(|(index, option)| { - ui.painter().layout_no_wrap((*option).to_owned(), crate::fonts::semibold(t.font_label), t.form_ink).size().x.ceil() + ui.painter().layout_no_wrap((*option).to_owned(), crate::fonts::semibold(font_size), t.form_ink).size().x.ceil() + t.space_16 + if icons.get(index).is_some() { t.space_14 + t.space_6 + t.space_4 } else { 0.0 } }) @@ -48,9 +50,7 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con let segment_width = dimension(ui.available_width()) / options.len().max(1) as f32; let widest = options .iter() - .map(|option| { - ui.painter().layout_no_wrap(crate::i18n::tr_label(option).to_string(), crate::fonts::semibold(t.font_label), t.form_ink).size().x - }) + .map(|option| ui.painter().layout_no_wrap(crate::i18n::tr_label(option).to_string(), crate::fonts::semibold(font_size), t.form_ink).size().x) .fold(0.0, f32::max); // Judged on the whole row, which is what a scrollbar narrows, not on one segment. let need = if intrinsic { total } else { (widest + 2.0 * t.space_8) * options.len() as f32 }; @@ -61,7 +61,19 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con return *selected != before; } let desired = if intrinsic { total.min(dimension(ui.available_width())) } else { dimension(ui.available_width()) }; - let (rect, _) = ui.allocate_exact_size(vec2(desired, if dense { t.control_height - t.space_2 } else { row_height() }), egui::Sense::hover()); + let (rect, _) = ui.allocate_exact_size( + vec2( + desired, + if small { + t.control_height - t.space_4 + } else if dense { + t.control_height - t.space_2 + } else { + row_height() + }, + ), + egui::Sense::hover(), + ); ui.painter().rect_filled(rect, t.control_radius, t.control_fill); let equal_width = rect.width() / options.len().max(1) as f32; let mut clicked = false; @@ -97,7 +109,7 @@ pub(crate) fn segmented(ui: &mut Ui, selected: &mut usize, options: &[&str], con if index > 0 { ui.painter().vline(segment.left(), segment.y_range(), t.control_border_stroke(t.control_border)); } - let font = if on { crate::fonts::semibold(t.font_label) } else { egui::FontId::proportional(t.font_label) }; + let font = if on { crate::fonts::semibold(font_size) } else { egui::FontId::proportional(font_size) }; let galley = ui.painter().layout_no_wrap((*option).to_string(), font.clone(), t.form_ink); let icon_width = if icons.get(index).is_some() { t.space_14 + t.space_6 } else { 0.0 }; let text_rect = egui::Rect::from_min_size( diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs index 6927fcd4c..cb2398f99 100644 --- a/crates/ui-egui/src/ui_kit/gallery.rs +++ b/crates/ui-egui/src/ui_kit/gallery.rs @@ -118,6 +118,51 @@ const ELEMENTS: &[Element] = &[ button(ui, "Reset to default", Button::Normal); }); }), + element!("tree_row_rect", |ui, _| { + for (index, row) in [ + Row { label: "Objects", ..Default::default() }, + Row { label: "Output", subtitle: "1920 × 1080 · PNG", ..Default::default() }, + Row { compact: true, label: "Environment", subtitle: "Studio Soft 2K", ..Default::default() }, + ] + .iter() + .enumerate() + { + let rect = tree_row_rect(ui, row); + assert_eq!(tree_row(ui, ui.id().with(("tree_geometry", index)), row).rect, Some(rect)); + } + }), + element!("tree_row", |ui, _| { + let actions = [TreeAction { icon: "plus", hover_only: false, label: "Add", reason: None, target: "gallery:tree:add" }]; + tree_row(ui, ui.id().with("tree_plain"), &Row { label: "Objects", fold: Some(true), actions: &actions, ..Default::default() }); + tree_row(ui, ui.id().with("tree_subtitle"), &Row { label: "Output", subtitle: "1920 × 1080 · PNG", selected: true, ..Default::default() }); + }), + element!("tree_header", |ui, state| { + tree_header(ui, "Scene", &mut state.selected, &["By object", "By look"], "Search objects"); + tree_row( + ui, + ui.id().with("compact_environment"), + &Row { compact: true, label: "Environment", icon: "environment_map", subtitle: "Studio Soft 2K", ..Default::default() }, + ); + tree_row( + ui, + ui.id().with("compact_object"), + &Row { + compact: true, + depth: 1, + label: "Boss", + swatch: Some(Tokens::get().accent), + eye: Some(true), + secondary: "Anodized Blue", + selected: true, + ..Default::default() + }, + ); + }), + element!("tree_row_disabled_actions", |ui, _| { + let actions = + [TreeAction { icon: "lookat", hover_only: true, label: "Solo", reason: Some("Not available yet"), target: "gallery:tree:solo" }]; + tree_row(ui, ui.id().with("tree_actions"), &Row { label: "Light", actions: &actions, ..Default::default() }); + }), element!("settings_form", |ui, state| { settings_form(ui, Tokens::get().form_label_width, |ui| { row(ui, "Sample", |ui| { @@ -1524,6 +1569,7 @@ fn gallery_covers_every_inline_element() { "sphere.rs", "status.rs", "table.rs", + "tree.rs", ] { let source = std::fs::read_to_string(root.join(file)).unwrap(); let ast = syn::parse_file(&source).unwrap(); @@ -2111,3 +2157,20 @@ fn material_widgets_board_in_both_themes() { } crate::theme::set_dark(previous); } + +#[test] +fn tree_icon_actions_keep_repeated_light_rows_independent() { + let ctx = crate::fonts::test_context(); + let mut ids = std::collections::HashSet::new(); + super::test_support::frame(&ctx, vec![], |ui| { + for index in 0..3 { + let target = format!("light:{index}:visibility"); + let actions = [TreeAction { icon: "eye", hover_only: false, label: "Hide", reason: Some("Not available yet"), target: &target }]; + let row = tree_row(ui, ui.id().with(index), &Row { compact: true, label: "Directional", actions: &actions, ..Default::default() }); + for action in row.actions { + assert!(ids.insert(action.id), "each light action must have its own widget identity"); + } + } + }); + assert_eq!(ids.len(), 3); +} diff --git a/crates/ui-egui/src/ui_kit/mod.rs b/crates/ui-egui/src/ui_kit/mod.rs index e949124de..61a0cd5fb 100644 --- a/crates/ui-egui/src/ui_kit/mod.rs +++ b/crates/ui-egui/src/ui_kit/mod.rs @@ -5,6 +5,8 @@ mod actions; mod assistant; mod assistant_entry; mod checks; +#[cfg(test)] +pub(crate) use checks::tests::{raster as test_raster, textures_update as test_textures_update}; mod choice; mod color; mod confirm; @@ -36,6 +38,7 @@ mod stages; mod status; mod table; mod text; +mod tree; mod value_focus; pub(crate) use actions::*; @@ -76,6 +79,7 @@ pub use sphere::{FinishKind, Sphere, sphere_thumbnail}; pub(crate) use stages::{StageAction, StageBar}; pub(crate) use status::*; pub(crate) use table::*; +pub(crate) use tree::*; pub(crate) use value_focus::*; #[cfg(test)] diff --git a/crates/ui-egui/src/ui_kit/panel.rs b/crates/ui-egui/src/ui_kit/panel.rs index 06e7368d5..457915f60 100644 --- a/crates/ui-egui/src/ui_kit/panel.rs +++ b/crates/ui-egui/src/ui_kit/panel.rs @@ -294,6 +294,29 @@ impl<'a> Panel<'a> { side: &mut String, width: &mut f32, add: impl FnOnce(&mut Ui) -> R, + ) -> Option)>> { + Self::workspace_with_header( + ui, + options, + side, + width, + false, + |ui, options| { + header_impl(ui, (options.icon, None), options.title, None, false, || {}); + }, + add, + ) + } + + /// Shared tree cards can place navigation in the title band and let rows own their insets. + pub(crate) fn workspace_with_header( + ui: &mut Ui, + options: WorkspaceOptions<'_>, + side: &mut String, + width: &mut f32, + tree: bool, + header: impl FnOnce(&mut Ui, &WorkspaceOptions<'_>), + add: impl FnOnce(&mut Ui) -> R, ) -> Option)>> { let container = super::Container::floating_card(super::Surface::Panel); // The ribbon has already reserved the top gap, as for the Design Browser. @@ -340,7 +363,9 @@ impl<'a> Panel<'a> { // persistent; their navigation lives in the separately padded body. ui.spacing_mut().item_spacing.y = 0.0; let band = egui::Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), header_height())); - let grip = ui.interact(band, ui.id().with("workspace_grip"), egui::Sense::click_and_drag()).on_hover_cursor(egui::CursorIcon::Grab); + let grip_rect = if tree { egui::Rect::from_min_size(band.min, vec2(t.space_24 * 2.0 + t.space_8, band.height())) } else { band }; + let grip = + ui.interact(grip_rect, ui.id().with("workspace_grip"), egui::Sense::click_and_drag()).on_hover_cursor(egui::CursorIcon::Grab); scenario::publish_target(&format!("{}:grip", options.id), grip.rect); super::Menu::context(&grip, |ui| { let (target, label) = if left { ("right", "Move to right side") } else { ("left", "Move to left side") }; @@ -351,7 +376,7 @@ impl<'a> Panel<'a> { ui.close(); } }); - header_impl(ui, (options.icon, None), options.title, None, false, || {}); + header(ui, &options); scenario::publish_rect(&format!("{}:header", options.id), band); if grip.dragged() { let frame_nr = ui.ctx().cumulative_frame_nr(); @@ -365,9 +390,12 @@ impl<'a> Panel<'a> { ui.ctx().request_repaint(); } egui::Frame::NONE - .inner_margin(t.space_12) + .inner_margin(if tree { egui::Margin::symmetric(0, t.space_4 as i8) } else { egui::Margin::same(t.space_12 as i8) }) .show(ui, |ui| { ui.spacing_mut().item_spacing.y = t.form_gap_y; + if tree { + ui.spacing_mut().item_spacing.y = 0.0; + } super::scope(ui, add) }) .inner diff --git a/crates/ui-egui/src/ui_kit/tree.rs b/crates/ui-egui/src/ui_kit/tree.rs new file mode 100644 index 000000000..916a51259 --- /dev/null +++ b/crates/ui-egui/src/ui_kit/tree.rs @@ -0,0 +1,355 @@ +//! Shared Browser tree rows; feature modules supply content and dispatch commands. +use crate::icons::glyphs::badge; +use crate::{icons, theme::Tokens}; +use egui::{Color32, FontId, Pos2, Rect, Sense, Stroke, pos2, vec2}; +const ROW_H: f32 = super::TREE_ROW_HEIGHT; +const INDENT: f32 = 14.0; +const DIM_ICON_OPACITY: f32 = 0.4; + +/// Trailing tree action; disabled actions retain their reason and a scenario rectangle. +pub(crate) struct TreeAction<'a> { + pub icon: &'a str, + pub hover_only: bool, + pub label: &'a str, + pub reason: Option<&'a str>, + pub target: &'a str, +} + +#[derive(Default)] +pub(crate) struct Row<'a> { + pub(crate) depth: usize, + /// Compact single-line scene rows, with inset content and a trailing eye. + pub(crate) compact: bool, + /// Some(open) for rows that fold. + pub(crate) fold: Option, + /// Some(visible) for rows with an eye. + pub(crate) eye: Option, + pub(crate) icon: &'a str, + pub(crate) label: &'a str, + /// The label is a name someone gave (a body, sketch, component, …): it is shown as typed, + /// not translated when it happens to match a UI label. + pub(crate) name: bool, + pub(crate) selected: bool, + pub(crate) dim: bool, + pub(crate) color: Option, + /// Component rows: is it the active one? + pub(crate) radio: Option, + /// Trailing badges: "lock", "pin". + pub(crate) badges: &'a [&'a str], + /// A button right after the name: (icon, tooltip label), e.g. a feature's profile sketch. + pub(crate) action: Option<(&'a str, &'a str)>, + /// Lit by the selection or the 3D view's pointer: the item's own row, or a row leading to it. + pub(crate) mark: Mark, + /// Optional document appearance and shared trailing text slots. + pub(crate) swatch: Option, + pub(crate) secondary: &'a str, + pub(crate) count: &'a str, + pub(crate) modified: bool, + pub(crate) subtitle: &'a str, + pub(crate) actions: &'a [TreeAction<'a>], + pub(crate) radio_hint: &'a str, +} + +/// How a row relates to what the selection and the 3D view's pointer light. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub(crate) enum Mark { + #[default] + None, + /// A row a lit item is inside (its component, placement, folder or group): a faint bar. + Branch, + /// A lit item's own row: a solid bar, and the hover colour unless it is selected. + Here, +} + +/// What happened on a row. +#[derive(Default)] +pub(crate) struct RowResp { + pub(crate) rect: Option, + pub(crate) clicked: bool, + pub(crate) double: bool, + pub(crate) secondary: Option, + pub(crate) fold: bool, + pub(crate) eye: bool, + pub(crate) radio: bool, + /// The row's [`Row::action`] button was clicked. + pub(crate) action: bool, + pub(crate) hovered: bool, + /// The row's response (drag and drop). + pub(crate) resp: Option, + /// The press began on the fold arrow, eye or radio (not a drag of the row). + pub(crate) on_control: bool, + pub(crate) actions: Vec, +} + +/// Geometry used by Browser culling and the shared row painter. +pub(crate) fn tree_row_rect(ui: &egui::Ui, row: &Row<'_>) -> Rect { + let t = Tokens::get(); + let row_height = if row.compact { t.control_height } else { ROW_H }; + let height = row_height + if row.compact || row.subtitle.is_empty() { 0.0 } else { t.font_small + t.space_4 }; + Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), height)) +} + +pub(crate) fn tree_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp { + let t = Tokens::get(); + // Rows scrolled out of view only take their space: no widgets, no painting. + let r = tree_row_rect(ui, row); + let height = r.height(); + let row_height = if row.compact { t.control_height } else { ROW_H }; + if !ui.is_rect_visible(r) { + ui.allocate_space(r.size()); + return RowResp { rect: Some(r), ..Default::default() }; + } + // A stable id per row (not the layout position), so a press and its release stay on the + // same row while rows above open or close. + let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), height), Sense::hover()); + let resp = ui.interact(r, id, Sense::click_and_drag()); + // While something is dragged (an appearance swatch, drawn under the pointer) `hovered` is + // off; the row under the pointer still counts, so a drop lands on it. + let dragged_over = egui::DragAndDrop::has_any_payload(ui.ctx()) && ui.input(|i| i.pointer.hover_pos()).is_some_and(|p| r.contains(p)); + let mut out = RowResp { rect: Some(r), hovered: resp.hovered() || dragged_over, ..Default::default() }; + if row.selected { + ui.painter().rect_filled(r, if row.compact { 0 } else { t.radius_sm.saturating_sub(1) }, crate::theme::TabAccent::current(ui.ctx()).soft); + } else if resp.hovered() || row.mark == Mark::Here { + ui.painter().rect_filled(r, t.radius_sm.saturating_sub(1), t.hover); + } + // A lit item (selected, or under the pointer in the 3D view): a bar down the left of its row, + // and a fainter, thinner one on each row leading to it, so the bars trace its branch. + let bar = match if row.compact { Mark::None } else { row.mark } { + Mark::None => None, + Mark::Branch => Some((2.0, t.accent.gamma_multiply(0.4))), + Mark::Here => Some((3.0, t.accent)), + }; + if let Some((w, colour)) = bar { + ui.painter().rect_filled(Rect::from_min_size(r.left_top() + vec2(0.0, t.space_2), vec2(w, r.height() - 4.0)), t.radius_sm / 4, colour); + } + let mut x = r.left() + if row.compact { t.space_8 + row.depth as f32 * t.space_14 } else { 2.0 + row.depth as f32 * INDENT }; + let cy = r.top() + row_height / 2.0; + let action_width = if row.compact { t.space_16 } else { t.form_close_size }; + let action_left = (r.right() - if row.compact { t.space_8 } else { t.space_4 } - action_width * row.actions.len() as f32).max(r.left()); + for (index, action) in row.actions.iter().enumerate() { + let rect = Rect::from_center_size(pos2(action_left + (index as f32 + 0.5) * action_width, cy), vec2(action_width, t.space_24)); + // Hover actions keep a stable hit target and disabled tooltip without boxed letters. + let show = !action.hover_only || r.contains(ui.input(|i| i.pointer.hover_pos()).unwrap_or_default()) || row.selected; + let response = ui + .push_id(action.target, |ui| { + ui.add_enabled_ui(action.reason.is_none(), |ui| { + if show { + super::quiet_icon_button_at(ui, rect, action.icon, action.label) + } else { + ui.interact(rect, ui.id().with(action.target), Sense::hover()) + } + }) + .inner + }) + .inner; + response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, response.enabled(), action.label)); + let response = match action.reason { + Some(reason) => response.on_disabled_hover_text(format!("{}\n{reason}", action.label)), + None => response.on_hover_text(action.label), + }; + crate::scenario::publish_rect(action.target, rect); + if action.reason.is_none() { + crate::scenario::publish_target(action.target, rect); + } + out.actions.push(response); + } + // The row is one widget: where a click lands decides what it does (the fold arrow with + // padding, the eye, the radio, or the row itself), so a click on the arrow never also + // selects the row or starts a drag. + let fold_r = Rect::from_min_max(pos2(x - 4.0, r.top()), pos2(x + 15.0, r.bottom())); + let eye_r = Rect::from_center_size( + pos2(if row.compact { action_left - t.space_6 } else { x + 14.0 + 8.0 }, cy), + vec2(t.space_16 + t.space_3, r.height()), + ); + let radio_r = Rect::from_center_size(pos2(x + 32.0 + 6.0, cy), vec2(t.space_12 + t.space_3, r.height())); + // The button right after the name takes room from the label; it is placed once the label is laid out. + let name_action_width = if row.action.is_some() { 22.0 } else { 0.0 }; + let at = |p: Pos2| -> u8 { + if !row.actions.is_empty() && p.x >= action_left { + 4 + } else if row.fold.is_some() && fold_r.contains(p) { + 1 + } else if row.eye.is_some() && eye_r.contains(p) { + 2 + } else if row.radio.is_some() && radio_r.contains(p) { + 3 + } else { + 0 + } + }; + let press_on = ui.input(|i| i.pointer.press_origin()).map_or(0, at); + let click_on = resp.interact_pointer_pos().map_or(0, at); + let hover_on = resp.hover_pos().map_or(0, at); + // Fold arrow. + if let Some(open) = row.fold { + crate::ui_kit::disclosure(ui.painter(), pos2(x + 6.0, cy), open, if hover_on == 1 { t.text } else { t.text_dim }); + out.fold = resp.clicked() && click_on == 1; + crate::scenario::publish_handle(&format!("fold:{}", row.label), fold_r.center()); + } + x += if row.compact { t.space_16 } else { 14.0 }; + // Eye. + if let Some(vis) = row.eye { + let eye_size = if row.compact { t.space_14 } else { t.space_12 + t.space_3 }; + let er = Rect::from_center_size(eye_r.center(), vec2(eye_size, eye_size)); + // Hidden or faded rows keep main's dimming, with the rounded suppression asset. + icons::paint_icon(ui.painter(), er, if vis { "eye" } else { "suppress" }, if vis && !row.dim { 0.85 } else { DIM_ICON_OPACITY }); + out.eye = resp.clicked() && click_on == 2; + crate::scenario::publish_handle(&format!("eye:{}", row.label), er.center()); + } + if !row.compact { + x += 18.0; + } + // Activation radio (components). + if let Some(active) = row.radio { + let rc = pos2(x + 6.0, cy); + ui.painter().circle_stroke(rc, 5.0, Stroke::new(1.2, if active { t.accent } else { t.text_dim })); + if active { + ui.painter().circle_filled(rc, 2.8, t.accent); + } + out.radio = resp.clicked() && click_on == 3; + x += 15.0; + } + if !row.icon.is_empty() && !(row.compact && row.swatch.is_some()) { + let ir = Rect::from_min_size(pos2(x, cy - 8.0), vec2(t.space_16, t.space_16)); + // Icons are full-colour images (a tint colour only sets their opacity): a hidden or + // faded row draws its icon faint, like its label. + icons::paint_icon(ui.painter(), ir, row.icon, if row.dim { DIM_ICON_OPACITY } else { 1.0 }); + x += 21.0; + } + if let Some(color) = row.swatch { + if row.compact { + x += t.space_3; + } + let size = if row.compact { t.space_14 } else { t.space_12 }; + let swatch = Rect::from_center_size(pos2(x + size / 2.0, cy), vec2(size, size)); + let radius = if row.compact { (size / 2.0) as u8 } else { t.radius_sm }; + ui.painter().rect_filled(swatch, radius, color); + ui.painter().rect_stroke(swatch, radius, t.control_border_stroke(t.control_border), egui::StrokeKind::Inside); + x += if row.compact { t.space_14 + t.space_6 } else { t.space_16 }; + } + let col = + if row.selected { crate::theme::TabAccent::current(ui.ctx()).ink } else { row.color.unwrap_or(if row.dim { t.text_dim } else { t.text }) }; + let label_display = if row.name { crate::i18n::tr_name(row.label) } else { crate::i18n::tr_dyn(row.label) }; + let font = if row.selected { crate::fonts::semibold(t.font_label) } else { FontId::proportional(t.font_label) }; + // The label stops before the badges and the card's edge; a longer name ends in an ellipsis + // and its full text is in the tooltip. + let badges_width = row.badges.len() as f32 * 15.0; + let mut right = if row.compact && row.eye.is_some() { eye_r.left() - t.space_4 } else { action_left } - badges_width; + for text in [row.count, row.secondary, if row.compact { row.subtitle } else { "" }] { + if text.is_empty() { + continue; + } + let max_width = (right - x).max(0.0) * if row.compact { 0.65 } else { 0.45 }; + let mut job = egui::text::LayoutJob::simple(text.to_string(), FontId::proportional(t.font_small), t.text_dim, max_width); + job.wrap.max_rows = 1; + job.wrap.overflow_character = Some('\u{2026}'); + let galley = ui.painter().layout_job(job); + right -= galley.size().x; + ui.painter().with_clip_rect(ui.clip_rect().intersect(r)).galley(pos2(right, cy - galley.size().y / 2.0), galley, t.text_dim); + right -= t.space_6; + } + if row.modified { + right -= t.space_8; + ui.painter().circle_filled(pos2(right, cy), t.space_2, t.accent); + } + if !row.compact && !row.subtitle.is_empty() { + let mut job = egui::text::LayoutJob::simple(row.subtitle.to_string(), FontId::proportional(t.font_small), t.text_dim, (right - x).max(0.0)); + job.wrap.max_rows = 1; + job.wrap.overflow_character = Some('\u{2026}'); + let galley = ui.painter().layout_job(job); + ui.painter().with_clip_rect(ui.clip_rect().intersect(r)).galley(pos2(x, r.top() + ROW_H), galley, t.text_dim); + } + let room = (right - name_action_width - x).max(0.0); + let mut job = egui::text::LayoutJob::simple(label_display.to_string(), font, col, room); + job.wrap.max_rows = 1; + job.wrap.break_anywhere = true; + job.wrap.overflow_character = Some('\u{2026}'); + let galley = ui.painter().layout_job(job); + let lw = galley.size().x; + let elided = galley.elided; + crate::scenario::publish_rect(&format!("row_label:{}", row.label), Rect::from_min_size(pos2(x, cy - galley.size().y / 2.0), galley.size())); + ui.painter().with_clip_rect(ui.painter().clip_rect().intersect(r)).galley(pos2(x, cy - galley.size().y / 2.0), galley, col); + let mut bx = (x + lw + 6.0 + name_action_width).min(r.right() - 16.0); + for b in row.badges { + let br = Rect::from_center_size(pos2(bx + 6.0, cy), vec2(t.space_12, t.space_12)); + badge(ui.painter(), br, b, t.text_dim); + bx += 15.0; + } + // The name's action button sits right after the label; a press on it is not a press on the row. + let action_r = Rect::from_min_size(pos2(x + lw + 2.0, r.top()), vec2(t.space_16 + t.space_4, r.height())); + let over_action = |p: Option| row.action.is_some() && p.is_some_and(|p| action_r.contains(p)); + let action_hover = over_action(resp.hover_pos()); + let action_click = over_action(resp.interact_pointer_pos()); + if let Some((icon, _)) = row.action { + if action_hover { + ui.painter().rect_filled(action_r.shrink2(vec2(1.0, t.space_3)), t.radius_sm.saturating_sub(1), t.hover); + } + let ir = Rect::from_center_size(action_r.center(), vec2(t.space_14, t.space_14)); + icons::paint_icon(ui.painter(), ir, icon, if action_hover { 1.0 } else { 0.6 }); + out.action = resp.clicked() && action_click; + crate::scenario::publish_handle(&format!("action:{}", row.label), action_r.center()); + } + crate::scenario::publish_handle(&format!("row:{}", row.label), r.center()); + let tip = match hover_on { + 0 if action_hover => row.action.map(|(_, tip)| crate::i18n::tr_label(tip)), + 1 => Some(if row.fold == Some(true) { crate::i18n::tr("ui.collapse") } else { crate::i18n::tr("ui.expand") }), + 2 => Some(if row.eye == Some(true) { crate::i18n::tr("ui.hide") } else { crate::i18n::tr("ui.show") }), + 3 if !row.radio_hint.is_empty() => Some(row.radio_hint), + 3 => Some(if row.radio == Some(true) { crate::i18n::tr("ui.active_component") } else { crate::i18n::tr("ui.activate") }), + _ => None, + }; + let resp = match tip { + Some(t) => resp.on_hover_text(t), + None if !row.secondary.is_empty() || !row.count.is_empty() => { + resp.on_hover_text(format!("{label_display}\n{}\n{}", row.secondary, row.count)) + } + None if elided => resp.on_hover_text(label_display.to_string()), + None => resp, + }; + out.on_control = press_on != 0 || over_action(ui.input(|i| i.pointer.press_origin())); + out.clicked = resp.clicked() && click_on == 0 && !action_click; + out.double = resp.double_clicked() && click_on == 0 && !action_click; + out.resp = Some(resp.clone()); + if resp.secondary_clicked() { + out.secondary = resp.interact_pointer_pos().or(Some(r.left_bottom())); + } + out +} + +/// Tree-card title band with compact lens controls and a quiet search action. +pub(crate) fn tree_header(ui: &mut egui::Ui, title: &str, lens: &mut usize, labels: &[&str], search_label: &str) -> bool { + let t = Tokens::get(); + let (band, _) = ui.allocate_exact_size(vec2(ui.available_width(), t.form_header_height), Sense::hover()); + let search = Rect::from_center_size(pos2(band.right() - t.space_8 - t.space_12, band.center().y), vec2(t.space_24, t.space_24)); + let response = super::quiet_icon_button_at(ui, search, "zoom", search_label); + crate::scenario::publish_target("render:tree:search", search); + let lens_width = labels + .iter() + .map(|label| ui.painter().layout_no_wrap((*label).into(), crate::fonts::semibold(t.font_small), t.text).size().x + t.space_16 + t.space_4) + .sum::(); + let lens_rect = Rect::from_min_max( + pos2((search.left() - t.space_8 - lens_width).max(band.left() + t.space_24 * 2.0), band.center().y - (t.control_height - t.space_4) / 2.0), + pos2(search.left() - t.space_8, band.bottom()), + ); + // The header band already owns this space. A scoped layout would advance the + // parent's cursor to the shorter lens control and pull the first row into the header. + let mut lens_ui = ui.new_child(egui::UiBuilder::new().max_rect(lens_rect).id_salt("tree_header_lens")); + super::segmented( + &mut lens_ui, + lens, + labels, + super::Segments { + small: true, + compact: true, + workspace_accent: true, + proportional: true, + targets: &["render:tree:by-object", "render:tree:by-look"], + ..Default::default() + }, + ); + let title_rect = + Rect::from_min_max(band.min + vec2(t.space_12, 0.0), pos2((lens_rect.left() - t.space_8).max(band.left() + t.space_12), band.bottom())); + super::text::paint_text(ui, title_rect, title, crate::fonts::semibold(t.font_heading), t.text, false); + t.secondary_hline(ui.painter(), band.x_range(), band.bottom(), t.dialog_rule); + response.clicked() +} diff --git a/crates/ui-egui/tests/disclosure_render.rs b/crates/ui-egui/tests/disclosure_render.rs index 67f0e7aa4..284358454 100644 --- a/crates/ui-egui/tests/disclosure_render.rs +++ b/crates/ui-egui/tests/disclosure_render.rs @@ -61,3 +61,79 @@ fn appearance_and_browser_folds_keep_handles_and_render_both_states() { } theme::set_dark(previous); } + +#[test] +fn render_browser_uses_shared_rows_in_both_lenses_and_themes() { + let dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/render-browser-review"); + std::fs::create_dir_all(&dir).unwrap(); + for dark in [false, true] { + let mut h = Harness::new(); + h.app.home.open = false; + h.app.session.run_script(&solidcraft_engine::sample::script()).unwrap(); + h.app.run("solid.box", json!({"corner":[60,0,0],"length":10,"width":10,"height":10,"body_name":"Detail block"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Plate"],"appearance":"ABS - Red"})).unwrap(); + h.app.run("appearance.assign", json!({"bodies":["Detail block"],"appearance":"ABS - Blue"})).unwrap(); + h.call("ui.resize", json!({"width":1440,"height":1100})); + h.call("ui.set", json!({"dark":dark})); + h.app + .run( + "render.settings.set", + json!({"name":"Studio","set":{"job":{"method":"gpu_path","options":{ + "lighting":{"environment":[0.2,0.2,0.2],"sun":{"direction":[1,-1,-2],"angular_radius_rad":0.1,"radiance":[2,2,2]}, + "area_lights":[{"center":[10,20,30],"u":[4,0,0],"v":[0,-2,0],"radiance":[1,1,1]}]} + }}}}), + ) + .unwrap(); + h.app.run("render.settings.set", json!({"name":"Detail","set":{"job":{"method":"raster"}}})).unwrap(); + h.call("ui.workspace", json!({"workspace":"render"})); + h.ctx = egui::Context::default(); + solidcraft_ui_egui::fonts::setup_fonts(&h.ctx); + theme::apply(&h.ctx); + let mut textures: HashMap = HashMap::new(); + for _ in 0..8 { + raster::paint(&mut h, &mut textures, vec![]); + } + for lens in ["object", "look"] { + if lens == "look" { + let at = scenario::rect_of("render:tree:by-look").unwrap().center(); + // Capture texture uploads from the input frames too: the look rows may + // introduce glyphs that were absent from the object lens. + for pressed in [true, false] { + raster::paint( + &mut h, + &mut textures, + vec![ + egui::Event::PointerMoved(at), + egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE }, + ], + ); + } + } + for _ in 0..4 { + raster::paint(&mut h, &mut textures, vec![]); + } + let output = raster::paint(&mut h, &mut textures, vec![]); + for section in ["environment", "lights", "shots", "objects", "output"] { + assert!(scenario::rect_of(&format!("render:tree:{section}")).is_some()); + } + for action in ["render:tree:lights:add", "render:tree:light:0:solo", "render:tree:light:0:mute", "render:tree:shots:add"] { + assert!(scenario::rect_of(action).is_some(), "{action}"); + } + assert_eq!(theme::is_dark(), dark); + assert_eq!(scenario::rect_of("render:tree:look:0").is_some(), lens == "look"); + let browser = scenario::rect_of("browser:card").unwrap(); + let screenshot = raster::raster(&mut h, &textures, output); + let ppp = h.ctx.pixels_per_point(); + image::imageops::crop_imm( + &screenshot, + (browser.left() * ppp) as u32, + (browser.top() * ppp) as u32, + (browser.width() * ppp) as u32, + (browser.height() * ppp) as u32, + ) + .to_image() + .save(dir.join(format!("{}-{lens}.png", if dark { "dark" } else { "light" }))) + .unwrap(); + } + } +} diff --git a/crates/ui-egui/tests/scenarios/render_workspace_shell.json b/crates/ui-egui/tests/scenarios/render_workspace_shell.json index eca0a8576..b450c3c4d 100644 --- a/crates/ui-egui/tests/scenarios/render_workspace_shell.json +++ b/crates/ui-egui/tests/scenarios/render_workspace_shell.json @@ -8,7 +8,7 @@ {"click":{"handle":"render:stage:light"}}, {"click":{"handle":"render:stage:frame"}}, {"click":{"handle":"render:stage:output"}}, - {"expect":{"disjoint":["render:browser:header","render:browser-library"]}}, + {"expect":{"disjoint":["render:browser:header","render:tree:environment"]}}, {"expect":{"disjoint":["render:inspector:header","render:page:output"]}}, {"click":{"handle":"render:shots:hide"}}, {"expect":{"shown_handles":["render:shots:show"],"hidden_handles":["render:shots:hide"]}}, diff --git a/docs/render-workspace.md b/docs/render-workspace.md index 796338d2f..93ad643a2 100644 --- a/docs/render-workspace.md +++ b/docs/render-workspace.md @@ -361,3 +361,22 @@ Selection and hover use Design’s highlight drawing and theme tokens in a separ GPU overlay on the live product view. The product scene and its upload stay unchanged. CPU image jobs, exported PNGs, retained images and the Render Result canvas never contain this overlay; the Pick control is disabled on the result canvas. + +## Browser scene focus + +The shared Browser lists Environment (with its source), Lights, saved Shots, +Objects and Output (with image dimensions and format). Shots **+** opens the +existing Shots manager; Lights **+**, Solo and Mute remain faded with an explicit +reason until named light commands exist. Existing light entries describe the +current numerical image setup, without inventing a saved rig. + +`ViewState.selection` exposes `RenderSelection` for Nothing, Object (the existing +engine selection), Environment, Light, Shot and Output. It belongs to each document +view and is never saved in a design. `view.render_select` validates semantic focus +requests without opening dialogs or editing/evaluating a design. Object picks and +Browser selections keep the existing selection commands. Inspector routing stays +as before; the focus state is available to a later Inspector change. + +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. diff --git a/docs/ui-kit.md b/docs/ui-kit.md index ef86c5403..15190a3ea 100644 --- a/docs/ui-kit.md +++ b/docs/ui-kit.md @@ -50,7 +50,10 @@ rules. Its compass is 110 pt; the 48 pt Shots strip clears the docks by 8 pt. - `Panel::workspace` owns grip-based left/right placement and bounded width resizing for floating workspace cards, including in Compact ribbon layouts. It reuses the 40 pt Panel/Window header and padded body, with no second top inset below the ribbon. - Persistent workspace cards omit the close action. `Panel::bottom_strip` + Persistent workspace cards omit the close action. `Panel::workspace_with_header` lets tree cards + compose the shared `tree_header` (title, compact lens and quiet search action). Its tree policy + shares the full dock height and lets rows own their 8 pt side insets; header navigation + retains a separate title grip. `Panel::bottom_strip` uses `Container::bottom_strip_rect`, the same placement as Design History. `Container::navigation_card` supplies the shared Navigation surface for anchored HUDs. Register measured card rectangles and reserved edges with `shell::register_panel` so @@ -114,6 +117,7 @@ table. Panel/Window/Confirm compositions also have dedicated geometry and intera | --- | --- | --- | | assistant: `assistant_header`, `assistant_controls`, `assistant_badge`, `assistant_bubble`, `assistant_prose`, `assistant_tool_frame/row/detail/status`, `AssistantToolState`, `assistant_approval/actions`, `assistant_composer/footer`, `assistant_input`, `assistant_send`, `assistant_empty`, `assistant_banner`, `AssistantTone` | Shared Assistant presentation: 40 pt header, 22 pt state pill, right-aligned user messages limited to 86% width, unboxed assistant prose, bordered tool groups and command detail, tinted approval heading, rounded focused composer with one unframed growing editor and pinned footer, centred setup copy and semantic notices. Closures preserve existing permission choices, protocol routing, queue actions and scenario handles. | `form_header_height/close_size`, `font_label/small/body`, `dialog_body/footer/rule`, `control_fill/border/radius`, `form_ink/dim/primary/success/error`, `accent_soft/selected_ink`, `warning`, radii and spacing | | history: `HistoryChip`, `HistoryStyle`, `history_drop_bar`, `history_marker`, `HistorySeam`, `history_seam` | One painter family for bottom chips, 38 pt vertical icon chips and single-line 26 pt name rows (the browser's shared `TREE_ROW_HEIGHT`). Selected items use the active tab tint/ink/border; all variants retain multi-tone feature artwork using one shared kind-to-accent rule (Sketch green, Surface orange, Mesh yellow, Form purple, solids base blue); rolled-back items have 42% opacity; a reference row (a sketch listed under another feature, #6489) has its name in secondary text. Error/warning badges, suppression strikes, horizontal/vertical drop bars and rollback line/hollow circle are shared. No connector lines. | `control_height`, `space_2/3/4/6/8/10/12/14/16/24`, radii, typography, `TabAccent`, `timeline_item`, `control_border`, `text/dim`, `form_error/fill` | +| tree: `tree_row`, `Row`, `TreeAction` | Shared Browser rows with disclosure, visibility, activation, selection, appearance swatches, optional subtitle and trailing actions. Compact scene rows are 28 pt, with inline right-aligned summaries, circular swatches, trailing eyes and full-width selection tint. Actions use quiet icons and can appear on hover. Disabled actions retain their reasons and cannot select or fold the row. Browser automation records the same row geometry. | `TREE_ROW_HEIGHT`, `font_label/small`, spacing, control radius/border, `text/dim`, workspace selection tint | | search: `CommandSearch`, `MenuItem::search_row` | Ribbon search composition: one persistent ribbon editor expands from 28 to 40 pt and to 520 pt wide with its right edge anchored, magnifier and S/Esc keycap, 38 pt two-line menu row with 26 pt icon tile, accent bold substring, path, shortcut/kind keycap, counts, JSON detail box and footer. The ordinary 30 pt menu row cannot fit a second line; this variant keeps its enabled/selected states and scenario IDs. Ranking and dispatch stay with the caller. | `form_card_width × 2 − space_8` (520 pt), `control_height`, `space_2/3/4/6/8/10/12/14/16/24`, `radius_xl/control_radius`, `control_fill`, `dialog_body/footer/rule/border`, `form_ink/dim/primary/error/error_fill/success/success_fill`, `selected_ink`, `accent_soft`, typography | | menu: `Menu`, `MenuItem` | Shared popup, 30 pt rows, 28 pt icon column, clipped labels, right-aligned mono shortcuts, submenu chevrons, checked/unchecked and document swatches, inert 40% disabled rows and danger ink; headings and separators; ribbon drag/pin targets retained | `dialog_body/border/rule`, `radius_xl`, `control_height/radius`, `form_ink/dim/primary/error`, `accent_soft`, typography and spacing | | radial: `radial_menu` | Eight rounded annular sectors, parallel 4 pt gaps, 9 pt circular corner joins, tab-accent artwork and hover, centre label/key; existing hold/flick/release dispatch | `dialog_body/border`, `form_ink/dim`, `TabAccent`, icon palette, font/spacing tokens |