editor.rs

editor.rs 80.9 KiB Download Raw

1	//! Project window: start screen, body, equipment, render queue, and 2D preview.
2
3	use std::path::PathBuf;
4
5	use eframe::egui;
6
7	use crate::compositor::MAX_RIM_INTENSITY;
8	use crate::dialogs::{load_candidate, DialogPoll, DialogPurpose, Dialogs, SystemDialogs};
9	use crate::import::{import_project_model, ImportedModel};
10	use crate::preview::{
11	is_drawable_body, load_body_file, PreviewCharacter, PreviewControls, PreviewSex,
12	};
13	use crate::preview2d::{
14	compatible_equipment_sets, compose_preview_frame, discover_completed_runs, open_selection,
15	sync_state_from_catalog, CatalogEntry, ComposeRequest, HoldSign, LightAxis, Preview2dState,
16	};
17	use crate::preview_gl::Viewport;
18	use crate::project::open_project;
19	use crate::render_job::{spawn, ImageBuf, RenderEvent, RenderJob, RenderUiState};
20	use crate::session::{adopt_file, AfterChoice, Intent, Screen, Session, Sex};
21
22	pub struct EditorApp {
23	session: Session,
24	dialogs: Box<dyn Dialogs>,
25	controls: PreviewControls,
26	preview_male: Option<PreviewCharacter>,
27	preview_female: Option<PreviewCharacter>,
28	viewport: Viewport,
29	inventories: [Option<Result<ImportedModel, String>>; 2],
30	render_worker: Option<crate::production::RenderThread>,
31	gpu_renderer: crate::production::GpuRenderer,
32	show_render_frame: bool,
33	render_ui: RenderUiState,
34	pass_texture: Option<egui::TextureHandle>,
35	pass_texture_revision: u64,
36	applied_shell: Option<[f32; 2]>,
37	width_text: String,
38	height_text: String,
39	fps_text: String,
40	allow_close: bool,
41	dialog_pending: bool,
42	equipment_part: usize,
43	preview2d: Preview2dState,
44	preview2d_catalog: Vec<CatalogEntry>,
45	preview2d_texture: Option<egui::TextureHandle>,
46	preview2d_texture_key: Option<(String, u32, i32, u32, u32, String)>,
47	preview2d_image: Option<ImageBuf>,
48	preview2d_speed_text: String,
49	resume_candidates: Vec<crate::resume::ResumeCandidate>,
50	resume_scanned: bool,
51	resume_scan_error: Option<String>,
52	}
53
54	impl EditorApp {
55	pub fn new(dialogs: Box<dyn Dialogs>) -> Self {
56	Self {
57	session: Session::new(),
58	dialogs,
59	controls: PreviewControls::default(),
60	preview_male: None,
61	preview_female: None,
62	viewport: Viewport::new(),
63	inventories: [None, None],
64	render_worker: None,
65	gpu_renderer: Default::default(),
66	show_render_frame: true,
67	render_ui: RenderUiState::idle(),
68	pass_texture: None,
69	pass_texture_revision: 0,
70	applied_shell: None,
71	width_text: "128".to_string(),
72	height_text: "128".to_string(),
73	fps_text: "12".to_string(),
74	allow_close: false,
75	dialog_pending: false,
76	equipment_part: 0,
77	preview2d: Preview2dState::default(),
78	preview2d_catalog: Vec::new(),
79	preview2d_texture: None,
80	preview2d_texture_key: None,
81	preview2d_image: None,
82	preview2d_speed_text: "1.0".to_string(),
83	resume_candidates: Vec::new(),
84	resume_scanned: false,
85	resume_scan_error: None,
86	}
87	}
88
89	pub fn open_path(&mut self, path: PathBuf) {
90	let candidate = std::env::current_dir()
91	.map_err(\|e\| e.to_string())
92	.and_then(\|base\| {
93	crate::file_assoc::resolve_project_argument(&base, &path.to_string_lossy())
94	});
95	let path = match candidate {
96	Ok(path) => path,
97	Err(error) => {
98	self.session.fail(error);
99	return;
100	}
101	};
102	match open_project(&path) {
103	Ok(opened) => {
104	self.session.install_loaded(opened);
105	self.reset_render();
106	self.sync_fields();
107	self.reload_bodies();
108	}
109	Err(error) => {
110	self.session.fail(error.to_string());
111	}
112	}
113	}
114
115	pub fn open_fixture_project(&mut self) {
116	let root = std::env::temp_dir().join(format!(
117	"paperdoll-renderer-fixture-{}-{}",
118	std::process::id(),
119	std::time::SystemTime::now()
120	.duration_since(std::time::UNIX_EPOCH)
121	.unwrap_or_default()
122	.as_nanos()
123	));
124	if let Err(error) = self.session.install_new_project(&root) {
125	self.session.fail(error.to_string());
126	return;
127	}
128	self.sync_fields();
129	self.reload_bodies();
130	self.session.show_body(Sex::Male);
131	self.controls.sex = PreviewSex::Male;
132	self.controls.select_clip("walk");
133	}
134
135	fn reset_render(&mut self) {
136	self.render_worker = None;
137	self.render_ui = RenderUiState::idle();
138	self.pass_texture = None;
139	self.resume_candidates.clear();
140	self.resume_scanned = false;
141	self.resume_scan_error = None;
142	}
143
144	fn sync_fields(&mut self) {
145	if let Some(opened) = &self.session.opened {
146	self.width_text = opened.document.render.target_width.to_string();
147	self.height_text = opened.document.render.target_height.to_string();
148	self.fps_text = opened.document.render.fps.to_string();
149	}
150	}
151
152	fn reload_bodies(&mut self) {
153	self.preview_male = None;
154	self.preview_female = None;
155	self.inventories = [None, None];
156	let Some(root) = self.session.project_root() else {
157	return;
158	};
159	for (index, sex) in [Sex::Male, Sex::Female].into_iter().enumerate() {
160	if let Some(relative) = self.session.body_path(sex) {
161	let imported =
162	import_project_model(&root, relative).map_err(\|error\| error.to_string());
163	// Validate the source and its dependencies before the viewport reads it.
164	if imported.is_ok() && is_drawable_body(std::path::Path::new(relative)) {
165	match load_body_file(&root.join(relative)) {
166	Ok(character) => match sex {
167	Sex::Male => self.preview_male = Some(character),
168	Sex::Female => self.preview_female = Some(character),
169	},
170	Err(error) => self.session.fail(format!("3D: {error}")),
171	}
172	}
173	self.inventories[index] = Some(imported);
174	}
175	}
176	}
177
178	fn character(&self) -> Option<&PreviewCharacter> {
179	match self.controls.sex {
180	PreviewSex::Male => self.preview_male.as_ref(),
181	PreviewSex::Female => self.preview_female.as_ref(),
182	}
183	}
184
185	fn poll_dialogs(&mut self) {
186	let poll = self.dialogs.poll();
187	self.dialog_pending = matches!(poll, DialogPoll::Pending);
188	if let DialogPoll::Ready { purpose, path } = poll {
189	let Some(path) = path else {
190	return;
191	};
192	match purpose {
193	DialogPurpose::NewProject => {
194	if let Err(error) = self.session.install_new_project(&path) {
195	self.session.fail(error.to_string());
196	} else {
197	self.reset_render();
198	self.sync_fields();
199	self.reload_bodies();
200	}
201	}
202	DialogPurpose::LoadProject => match open_project(&load_candidate(&path)) {
203	Ok(opened) => {
204	self.session.install_loaded(opened);
205	self.reset_render();
206	self.sync_fields();
207	self.reload_bodies();
208	}
209	Err(error) => self.session.fail(error.to_string()),
210	},
211	DialogPurpose::Body(sex) => self.take_model(sex, &path),
212	DialogPurpose::EquipmentModel(index) => self.take_equipment(index, &path),
213	DialogPurpose::EquipmentShiny(index, part) => {
214	if let Some(mut preset) = self
215	.session
216	.equipment
217	.get(index)
218	.and_then(\|i\| i.preset.clone())
219	{
220	let result = crate::equipment::import_shiny(&mut preset, part, &path)
221	.and_then(\|_\| self.session.ensure_preset_budget(Some(index), &preset));
222	match result {
223	Ok(()) => self.session.equipment[index].preset = Some(preset),
224	Err(error) => self.session.fail(error),
225	}
226	}
227	}
228	DialogPurpose::ImportEquipment => match crate::equipment::Preset::read(&path) {
229	Ok(mut preset) => {
230	let result = self
231	.session
232	.available_equipment_name(&preset.name)
233	.and_then(\|name\| {
234	preset.name = name;
235	self.session.ensure_preset_budget(None, &preset)
236	});
237	if let Err(error) = result {
238	self.session.fail(error);
239	return;
240	}
241	let index = self.session.equipment.len();
242	self.session.equipment.push(crate::session::EquipmentItem {
243	slug: preset.name.clone(),
244	model: preset.attachments.first().map(\|p\| p.label.clone()),
245	preset: Some(preset),
246	legacy_path: None,
247	error: None,
248	});
249	self.equipment_part = 0;
250	self.session.show_equipment(index);
251	}
252	Err(error) => self.session.fail(error),
253	},
254	}
255	}
256	}
257
258	fn take_model(&mut self, sex: Sex, path: &std::path::Path) {
259	let Some(root) = self.session.project_root() else {
260	return;
261	};
262	match adopt_file(&root, path, "assets/body") {
263	Ok(relative) => {
264	self.session.set_body_path(sex, relative.clone());
265	self.reload_bodies();
266	self.reset_render();
267	let index = if sex == Sex::Male { 0 } else { 1 };
268	if let Some(Err(error)) = &self.inventories[index] {
269	self.session.fail(format!("{relative}: {error}"));
270	} else {
271	self.session.notice = format!("{relative} staat in het project.");
272	self.session.notice_ok = true;
273	}
274	}
275	Err(error) => self.session.fail(error),
276	}
277	}
278
279	fn take_equipment(&mut self, index: usize, path: &std::path::Path) {
280	let sex = if self.session.active_body == Some(Sex::Female) {
281	1
282	} else {
283	0
284	};
285	let body = if sex == 0 {
286	self.preview_male.as_ref()
287	} else {
288	self.preview_female.as_ref()
289	};
290	let Some(item) = self.session.equipment.get(index) else {
291	return;
292	};
293	let mut preset = item
294	.preset
295	.clone()
296	.unwrap_or_else(\|\| crate::equipment::Preset::new(item.slug.clone()));
297	preset.name = item.slug.clone();
298	match crate::equipment::import_model(&mut preset, path) {
299	Ok(part) => {
300	if let Some(body) = body {
301	if !body.joint_nodes.is_empty() {
302	let _ = preset.bind(sex, body, part, 0);
303	}
304	}
305	if let Err(error) = self.session.ensure_preset_budget(Some(index), &preset) {
306	self.session.fail(error);
307	return;
308	}
309	let item = &mut self.session.equipment[index];
310	item.model = Some(preset.attachments[part].label.clone());
311	item.legacy_path = None;
312	item.error = None;
313	item.preset = Some(preset);
314	self.equipment_part = part;
315	self.session.notice =
316	"Onderdeel inclusief materiaal en textures ingesloten. Kies het doelbot."
317	.into();
318	self.session.notice_ok = true;
319	}
320	Err(error) => self.session.fail(error),
321	}
322	}
323
324	pub fn open_equipment_configuration(&mut self, index: usize, sex: Sex) {
325	self.session.active_body = Some(sex);
326	self.session.show_equipment(index);
327	self.equipment_part = 0;
328	}
329
330	fn begin(&mut self, intent: Intent) {
331	if self.session.gate(intent) {
332	self.run_intent(intent);
333	}
334	}
335
336	fn run_intent(&mut self, intent: Intent) {
337	match intent {
338	Intent::Quit => {}
339	Intent::PickNew => self.dialogs.start(DialogPurpose::NewProject),
340	Intent::PickLoad => self.dialogs.start(DialogPurpose::LoadProject),
341	}
342	}
343
344	fn apply_choice(&mut self, choice: crate::session::Choice, ctx: &egui::Context) {
345	match self.session.resolve(choice) {
346	AfterChoice::Stay => {}
347	AfterChoice::SaveThen(intent) => match self.session.save() {
348	Ok(()) => self.finish_intent(intent, ctx),
349	Err(error) => self.session.fail(error.to_string()),
350	},
351	AfterChoice::Go(intent) => self.finish_intent(intent, ctx),
352	}
353	}
354
355	fn finish_intent(&mut self, intent: Intent, ctx: &egui::Context) {
356	if intent == Intent::Quit {
357	self.allow_close = true;
358	ctx.send_viewport_cmd(egui::ViewportCommand::Close);
359	} else {
360	self.run_intent(intent);
361	}
362	}
363
364	fn save(&mut self) {
365	if let Err(error) = self.session.save() {
366	self.session.fail(error.to_string());
367	}
368	}
369
370	fn apply_render_fields(&mut self) {
371	let width = self.width_text.parse::<u32>().unwrap_or(0);
372	let height = self.height_text.parse::<u32>().unwrap_or(0);
373	let fps = self.fps_text.parse::<u32>().unwrap_or(0);
374	self.session.set_render(width, height, fps);
375	}
376
377	/// Open the body editor, also used by the native smoke example.
378	pub fn open_body_configuration(&mut self, sex: Sex) {
379	self.session.show_body(sex);
380	self.controls.sex = match sex {
381	Sex::Male => PreviewSex::Male,
382	Sex::Female => PreviewSex::Female,
383	};
384	}
385	pub fn render_error(&self) -> Option<&str> {
386	self.render_ui.error.as_deref()
387	}
388	/// Same as the Live 3D button: leave the pass preview, show the viewport.
389	pub fn show_live_3d(&mut self) {
390	self.render_ui.preview = None;
391	}
392	pub fn render_all_angles(&mut self) {
393	self.start_render();
394	}
395	/// Legacy smoke entry point, now starts the production batch as well.
396	pub fn render_current_pose(&mut self) {
397	self.render_all_angles();
398	}
399	pub fn render_is_running(&self) -> bool {
400	self.render_ui.running
401	}
402	pub fn render_progress(&self) -> (u32, u32, String) {
403	(
404	self.render_ui.progress.completed,
405	self.render_ui.progress.total,
406	self.render_ui.progress.label.clone(),
407	)
408	}
409	/// The job the Render action would start now (current project, body, equipment).
410	fn build_job(&mut self) -> Option<RenderJob> {
411	let opened = self.session.opened.as_ref()?;
412	if let Err(error) = opened.document.validate_shape() {
413	self.session.fail(error.to_string());
414	return None;
415	}
416	let Some(character) = self.character().cloned() else {
417	self.session
418	.fail("dit lichaam heeft geen tekenbaar glTF/GLB-, FBX- of OBJ-model");
419	return None;
420	};
421	let root = self.session.project_root()?;
422	if let Err(error) =
423	crate::project::prepare_output_dir(&root, &opened.document.output_directory)
424	{
425	self.session.fail(error.to_string());
426	return None;
427	}
428	let sex = usize::from(self.controls.sex == PreviewSex::Female);
429	let preset = match self.session.screen {
430	Screen::Equipment(i) => self.session.equipment.get(i).and_then(\|i\| i.preset.clone()),
431	_ => None,
432	};
433	if matches!(self.session.screen, Screen::Equipment(_)) && preset.is_none() {
434	self.session.fail("configureer eerst het equipment");
435	return None;
436	}
437	let body_rel = match self.controls.sex {
438	PreviewSex::Male => opened.document.male_model.clone(),
439	PreviewSex::Female => opened.document.female_model.clone(),
440	};
441	let Some(body_rel) = body_rel else {
442	self.session.fail("dit lichaam heeft geen modelpad");
443	return None;
444	};
445	if let Err(error) = crate::project::portable_relative(&body_rel) {
446	self.session.fail(error);
447	return None;
448	}
449	let body_path = root.join(&body_rel);
450	let body_sha = match crate::digest::sha256_file(&body_path, 32 * 1024 * 1024) {
451	Ok(hash) => hash,
452	Err(error) => {
453	self.session.fail(format!("body-fingerprint: {error}"));
454	return None;
455	}
456	};
457	let preset_sha256 = match &preset {
458	None => None,
459	Some(p) => match p.encode() {
460	Ok(bytes) => Some(crate::digest::sha256_hex(&bytes)),
461	Err(error) => {
462	self.session.fail(format!("equipment-fingerprint: {error}"));
463	return None;
464	}
465	},
466	};
467	Some(RenderJob {
468	character,
469	sex: if sex == 0 { "male" } else { "female" }.into(),
470	preset,
471	target_width: opened.document.render.target_width,
472	target_height: opened.document.render.target_height,
473	fps: opened.document.render.fps,
474	framing: opened.document.render.framing[sex],
475	output: root.join(&opened.document.output_directory),
476	project_id: opened.document.id.clone(),
477	project_name: opened.document.name.clone(),
478	body_model: crate::production::SourceFingerprint {
479	path: body_rel,
480	sha256: body_sha,
481	},
482	preset_sha256,
483	})
484	}
485	fn start_render(&mut self) {
486	if self.render_ui.running {
487	return;
488	}
489	let Some(job) = self.build_job() else {
490	return;
491	};
492	self.render_worker = Some(spawn(job, None));
493	self.begin_worker();
494	}
495	fn begin_worker(&mut self) {
496	self.render_ui = RenderUiState::idle();
497	self.pass_texture = None;
498	self.render_ui.running = true;
499	self.resume_candidates.clear();
500	self.resume_scanned = false;
501	}
502	/// Find incomplete runs of the current body/equipment set and check their contract.
503	pub fn scan_resumable_runs(&mut self) {
504	self.resume_scanned = true;
505	self.resume_candidates.clear();
506	self.resume_scan_error = None;
507	let Some(job) = self.build_job() else {
508	self.resume_scan_error = Some("geen renderbare job voor deze weergave".into());
509	return;
510	};
511	let output = job.output.clone();
512	let result = crate::production::contract(job)
513	.and_then(\|c\| crate::resume::candidates(&output, &c.render_doc));
514	match result {
515	Ok(found) => self.resume_candidates = found,
516	Err(error) => self.resume_scan_error = Some(error),
517	}
518	}
519	pub fn resumable_runs(&self) -> &[crate::resume::ResumeCandidate] {
520	&self.resume_candidates
521	}
522	/// Resume one incomplete run; the worker re-checks contract, lock and checksums.
523	pub fn resume_run(&mut self, dir: PathBuf) {
524	if self.render_ui.running {
525	return;
526	}
527	let Some(job) = self.build_job() else {
528	return;
529	};
530	self.render_worker = Some(crate::render_job::spawn_resume(job, dir, None));
531	self.begin_worker();
532	}
533	/// Request cancellation of the running batch (same as the GUI button).
534	pub fn request_render_cancel(&mut self) {
535	self.cancel_render();
536	}
537	fn resume_ui(&mut self, ui: &mut egui::Ui) {
538	ui.horizontal_wrapped(\|ui\| {
539	ui.label("Onderbroken renders:");
540	if ui
541	.add_enabled(
542	!self.render_ui.running,
543	egui::Button::new("Zoek onderbroken runs"),
544	)
545	.on_hover_text(
546	"Alleen runs met exact dezelfde bronnen en instellingen kunnen verder.",
547	)
548	.clicked()
549	{
550	self.scan_resumable_runs();
551	}
552	if self.resume_scanned && self.resume_candidates.is_empty() {
553	ui.weak("geen gevonden voor deze set");
554	}
555	});
556	if let Some(error) = &self.resume_scan_error {
557	ui.colored_label(egui::Color32::LIGHT_RED, error);
558	}
559	let mut chosen = None;
560	for candidate in &self.resume_candidates {
561	ui.horizontal_wrapped(\|ui\| {
562	ui.label(format!(
563	"{} · {} · {} van {} PNG's vastgelegd",
564	candidate.name, candidate.state, candidate.journaled, candidate.planned
565	));
566	match &candidate.blocked {
567	None => {
568	if ui
569	.add_enabled(!self.render_ui.running, egui::Button::new("Hervat"))
570	.clicked()
571	{
572	chosen = Some(candidate.dir.clone());
573	}
574	}
575	Some(reason) => {
576	ui.weak(reason);
577	}
578	}
579	});
580	}
581	if let Some(dir) = chosen {
582	self.resume_run(dir);
583	}
584	}
585
586	fn service_gpu(&mut self, gl: Option<&std::sync::Arc<glow::Context>>) {
587	let request = self
588	.render_worker
589	.as_ref()
590	.and_then(\|worker\| worker.gpu.try_recv().ok());
591	if let Some(request) = request {
592	if let Some(gl) = gl {
593	unsafe {
594	request.service(&mut self.gpu_renderer, gl);
595	}
596	} else {
597	request.fail("Glow-context ontbreekt".into());
598	}
599	}
600	}
601	fn drain_render(&mut self) {
602	let Some(worker) = &self.render_worker else {
603	return;
604	};
605	let ended = worker
606	.handle
607	.as_ref()
608	.map(\|h\| h.is_finished())
609	.unwrap_or(true);
610	let events = worker.mailbox.drain();
611	let mut terminal = false;
612	for event in events {
613	terminal \|= matches!(
614	event,
615	RenderEvent::Finished { .. } \| RenderEvent::Failed(_) \| RenderEvent::Cancelled
616	);
617	if let RenderEvent::Finished { saved: Some(path) } = &event {
618	self.session.notice = format!("Batch opgeslagen: {path}");
619	self.session.notice_ok = true;
620	}
621	if let RenderEvent::Failed(error) = &event {
622	self.session.fail(error.clone());
623	}
624	self.render_ui.apply(event);
625	}
626	if terminal {
627	self.render_worker = None;
628	if self.render_ui.saved.is_none() && self.render_ui.error.is_none() {
629	// Cancelled: offer the run for resumption right away.
630	self.scan_resumable_runs();
631	}
632	} else if ended {
633	self.render_ui.apply(RenderEvent::Failed(
634	"De renderworker stopte zonder eindresultaat.".into(),
635	));
636	self.render_worker = None;
637	}
638	}
639	fn cancel_render(&mut self) {
640	if let Some(worker) = &self.render_worker {
641	worker
642	.cancel
643	.store(true, std::sync::atomic::Ordering::Relaxed);
644	}
645	}
646	fn render_progress_ui(&mut self, ui: &mut egui::Ui) {
647	if self.render_ui.progress.total > 0 {
648	ui.add(
649	egui::ProgressBar::new(
650	self.render_ui.progress.completed as f32
651	/ self.render_ui.progress.total.max(1) as f32,
652	)
653	.text(format!(
654	"{} / {} · {}",
655	self.render_ui.progress.completed,
656	self.render_ui.progress.total,
657	self.render_ui.progress.label
658	)),
659	);
660	}
661	if self.render_ui.running && ui.button("Annuleer render").clicked() {
662	self.cancel_render();
663	}
664	}
665	fn framing_ui(&mut self, ui: &mut egui::Ui, sex: usize) {
666	let diagnostic = {
667	let framing = self
668	.session
669	.opened
670	.as_ref()
671	.map(\|opened\| opened.document.render.framing[sex]);
672	let body = match sex {
673	0 => self.preview_male.as_ref(),
674	_ => self.preview_female.as_ref(),
675	};
676	match (body, framing) {
677	(Some(body), Some(framing)) => Some(crate::camera::resolve(body, framing)),
678	_ => None,
679	}
680	};
681	if let Some(opened) = &mut self.session.opened {
682	let camera = &mut opened.document.render.framing[sex];
683	let mut height = camera.height_milli as f32 / 1000.;
684	let mut center = camera.center_y_milli as f32 / 1000.;
685	let mut pivot = diagnostic
686	.as_ref()
687	.map(\|resolved\| {
688	resolved
689	.framing
690	.pivot_y_milli
691	.unwrap_or(resolved.framing.center_y_milli) as f32
692	/ 1000.
693	})
694	.unwrap_or_else(\|\| {
695	camera.pivot_y_milli.unwrap_or(camera.center_y_milli) as f32 / 1000.
696	});
697	ui.horizontal_wrapped(\|ui\| {
698	ui.label("Vaste renderhoogte (m)");
699	if ui
700	.add(
701	egui::DragValue::new(&mut height)
702	.speed(0.01)
703	.range(0.1..=10.),
704	)
705	.changed()
706	{
707	camera.height_milli = (height * 1000.).round() as u32;
708	}
709	ui.label("Centrum Y (m)");
710	if ui
711	.add(
712	egui::DragValue::new(&mut center)
713	.speed(0.01)
714	.range(-10.0..=10.0),
715	)
716	.changed()
717	{
718	camera.center_y_milli = (center * 1000.).round() as i32;
719	}
720	ui.label("Pivot Y (m)");
721	if ui
722	.add(
723	egui::DragValue::new(&mut pivot)
724	.speed(0.01)
725	.range(-10.0..=10.0),
726	)
727	.changed()
728	{
729	camera.pivot_y_milli = Some((pivot * 1000.).round() as i32);
730	}
731	if camera.pivot_y_milli.is_some()
732	&& ui
733	.button("Auto nek")
734	.on_hover_text("Wis handmatige pivot; gebruik rustpose-nekhoogte")
735	.clicked()
736	{
737	camera.pivot_y_milli = None;
738	}
739	ui.checkbox(&mut self.show_render_frame, "Vast renderkader tonen");
740	});
741	if let Some(resolved) = &diagnostic {
742	ui.label(resolved.description());
743	} else {
744	ui.label("Laad een glTF/GLB-, FBX- of OBJ-lichaam om de nekpivot te bepalen.");
745	}
746	}
747	}
748	fn fixed_camera(&self) -> Option<(crate::project::CameraFraming, [u32; 2])> {
749	if !self.show_render_frame {
750	return None;
751	}
752	let r = &self.session.opened.as_ref()?.document.render;
753	let sex = usize::from(self.controls.sex == PreviewSex::Female);
754	Some((r.framing[sex], [r.target_width, r.target_height]))
755	}
756	}
757
758	impl Default for EditorApp {
759	fn default() -> Self {
760	Self::new(Box::new(SystemDialogs::new()))
761	}
762	}
763
764	impl eframe::App for EditorApp {
765	fn on_exit(&mut self, gl: Option<&glow::Context>) {
766	self.render_worker = None;
767	if let Some(gl) = gl {
768	unsafe {
769	self.gpu_renderer.destroy(gl);
770	}
771	self.viewport.destroy(gl);
772	}
773	}
774	fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
775	self.service_gpu(frame.gl());
776	let shell = self.session.shell_size();
777	if self.applied_shell != Some(shell) {
778	ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::vec2(
779	shell[0], shell[1],
780	)));
781	let min = if shell == crate::session::START_WINDOW {
782	egui::vec2(420.0, 220.0)
783	} else {
784	egui::vec2(900.0, 560.0)
785	};
786	ctx.send_viewport_cmd(egui::ViewportCommand::MinInnerSize(min));
787	self.applied_shell = Some(shell);
788	}
789	if ctx.input(\|input\| input.viewport().close_requested())
790	&& !self.allow_close
791	&& self.session.confirm.is_none()
792	{
793	if !self.session.gate(Intent::Quit) {
794	ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
795	}
796	} else if self.session.confirm.is_some()
797	&& ctx.input(\|input\| input.viewport().close_requested())
798	{
799	ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
800	}
801	self.poll_dialogs();
802	self.drain_render();
803	if self.render_ui.running
804	\|\| matches!(self.session.screen, Screen::Preview2d)
805	&& (self.preview2d.playing
806	\|\| self.preview2d.hold_azimuth.is_some()
807	\|\| self.preview2d.hold_elevation.is_some())
808	{
809	ctx.request_repaint();
810	}
811	egui::TopBottomPanel::bottom("notice").show(ctx, \|ui\| {
812	let color = if self.session.notice_ok {
813	egui::Color32::LIGHT_GREEN
814	} else {
815	egui::Color32::LIGHT_RED
816	};
817	ui.colored_label(color, &self.session.notice);
818	});
819	match self.session.screen {
820	Screen::Start => self.show_start(ctx),
821	Screen::Bodies => self.show_bodies(ctx),
822	Screen::Body(_) => self.show_body(ctx),
823	Screen::EquipmentList => self.show_equipment_list(ctx),
824	Screen::Equipment(_) => self.show_equipment(ctx),
825	Screen::Preview2d => self.show_preview2d(ctx),
826	}
827	self.show_confirm(ctx);
828	if self.dialog_pending {
829	ctx.request_repaint_after(std::time::Duration::from_millis(50));
830	}
831	}
832	}
833
834	impl EditorApp {
835	fn show_confirm(&mut self, ctx: &egui::Context) {
836	let Some(_intent) = self.session.confirm else {
837	return;
838	};
839	let mut choice = None;
840	egui::Window::new("Wijzigingen")
841	.anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
842	.collapsible(false)
843	.resizable(false)
844	.show(ctx, \|ui\| {
845	ui.label("Er zijn wijzigingen die nog niet zijn opgeslagen.");
846	ui.horizontal(\|ui\| {
847	if ui.button("Opslaan").clicked() {
848	choice = Some(crate::session::Choice::Save);
849	}
850	if ui.button("Niet opslaan").clicked() {
851	choice = Some(crate::session::Choice::Discard);
852	}
853	if ui.button("Annuleren").clicked() {
854	choice = Some(crate::session::Choice::Cancel);
855	}
856	});
857	});
858	if let Some(choice) = choice {
859	self.apply_choice(choice, ctx);
860	}
861	}
862
863	fn show_start(&mut self, ctx: &egui::Context) {
864	egui::CentralPanel::default().show(ctx, \|ui\| {
865	if self.session.confirm.is_some() \|\| self.dialog_pending {
866	ui.disable();
867	}
868	ui.heading("Paperdoll Renderer");
869	ui.label("Open een bestaand character.ppd of kies een map voor een nieuw project.");
870	ui.add_space(12.0);
871	if ui.button("Project laden").clicked() {
872	self.begin(Intent::PickLoad);
873	}
874	if ui.button("Nieuw project").clicked() {
875	self.begin(Intent::PickNew);
876	}
877	});
878	}
879
880	fn show_bodies(&mut self, ctx: &egui::Context) {
881	self.toolbar(ctx, true);
882	egui::CentralPanel::default().show(ctx, \|ui\| {
883	if self.session.confirm.is_some() \|\| self.dialog_pending {
884	ui.disable();
885	}
886	ui.heading("Body");
887	if let Some(opened) = &mut self.session.opened {
888	ui.horizontal(\|ui\| {
889	ui.label("Naam");
890	ui.text_edit_singleline(&mut opened.document.name);
891	});
892	}
893	self.body_row(ui, Sex::Male, "Man", "Kies man", "Open man");
894	self.body_row(ui, Sex::Female, "Vrouw", "Kies vrouw", "Open vrouw");
895	ui.add_space(8.0);
896	ui.horizontal(\|ui\| {
897	ui.label("Breedte");
898	ui.add(egui::TextEdit::singleline(&mut self.width_text).desired_width(64.0));
899	ui.label("Hoogte");
900	ui.add(egui::TextEdit::singleline(&mut self.height_text).desired_width(64.0));
901	ui.label("fps");
902	ui.add(egui::TextEdit::singleline(&mut self.fps_text).desired_width(48.0));
903	});
904	self.apply_render_fields();
905	ui.add_space(8.0);
906	if ui.button("2D-preview").clicked() {
907	self.open_preview2d();
908	}
909	ui.label("Opent de gerenderde 2D-compositor over voltooide exportsets in renders/.");
910	});
911	}
912
913	fn body_row(&mut self, ui: &mut egui::Ui, sex: Sex, title: &str, pick: &str, open: &str) {
914	ui.horizontal(\|ui\| {
915	ui.label(title);
916	let path = self
917	.session
918	.body_path(sex)
919	.unwrap_or("geen model")
920	.to_string();
921	ui.label(path);
922	if ui.button(pick).clicked() {
923	self.dialogs.start(DialogPurpose::Body(sex));
924	}
925	if ui.button(open).clicked() {
926	self.controls.sex = match sex {
927	Sex::Male => PreviewSex::Male,
928	Sex::Female => PreviewSex::Female,
929	};
930	self.session.show_body(sex);
931	}
932	});
933	let index = if sex == Sex::Male { 0 } else { 1 };
934	if let Some(inventory) = &self.inventories[index] {
935	ui.collapsing(format!("Importoverzicht {title}"), \|ui\| match inventory {
936	Ok(model) => {
937	for mesh in &model.meshes {
938	ui.label(format!(
939	"{}: {} vertices, {} driehoeken",
940	mesh.name, mesh.vertex_count, mesh.triangle_count
941	));
942	}
943	for material in &model.materials {
944	ui.label(format!("materiaal {}", material.name));
945	}
946	for texture in &model.textures {
947	ui.label(format!(
948	"texture {}: {}×{}",
949	texture.source, texture.width, texture.height
950	));
951	}
952	ui.label(format!("{} joints", model.joints.len()));
953	for clip in &model.clips {
954	ui.label(format!("{}: {:.2} s", clip.name, clip.duration_seconds));
955	}
956	for notice in &model.notices {
957	ui.label(notice);
958	}
959	}
960	Err(message) => {
961	ui.colored_label(egui::Color32::LIGHT_RED, message);
962	}
963	});
964	}
965	}
966
967	fn show_body(&mut self, ctx: &egui::Context) {
968	self.toolbar(ctx, true);
969	let sex = match self.session.screen {
970	Screen::Body(sex) => sex,
971	_ => Sex::Male,
972	};
973	self.controls.sex = match sex {
974	Sex::Male => PreviewSex::Male,
975	Sex::Female => PreviewSex::Female,
976	};
977	egui::CentralPanel::default().show(ctx, \|ui\| {
978	if self.session.confirm.is_some() \|\| self.dialog_pending {
979	ui.disable();
980	}
981	ui.horizontal_wrapped(\|ui\| {
982	if ui.button("Terug").clicked() {
983	self.session.show_bodies();
984	}
985	if ui.button("Equipment").clicked() {
986	self.session.show_equipment_list();
987	}
988	if ui
989	.add_enabled(
990	!self.render_ui.running,
991	egui::Button::new("Render alle hoeken"),
992	)
993	.clicked()
994	{
995	self.start_render();
996	}
997	if ui.button("Live 3D").clicked() {
998	self.render_ui.preview = None;
999	}
1000	if ui.button("2D-preview").clicked() {
1001	self.open_preview2d();
1002	}
1003	});
1004	if let Some(reason) = self.character().and_then(PreviewCharacter::static_reason) {
1005	ui.colored_label(
1006	egui::Color32::from_rgb(230, 190, 90),
1007	format!(
1008	"{reason}. Render alle hoeken maakt één bindpose-sample (clip000-bind) × 36 hoeken."
1009	),
1010	);
1011	}
1012	self.framing_ui(ui, usize::from(sex == Sex::Female));
1013	self.render_progress_ui(ui);
1014	self.resume_ui(ui);
1015	if self.render_ui.preview.is_some() {
1016	self.paint_pass(ui);
1017	} else {
1018	let character = match self.controls.sex {
1019	PreviewSex::Male => self.preview_male.as_ref(),
1020	PreviewSex::Female => self.preview_female.as_ref(),
1021	};
1022	if character.is_some() {
1023	let framing = self.fixed_camera();
1024	self.viewport
1025	.show_framed(ui, &mut self.controls, character, &[], framing);
1026	} else {
1027	ui.label("Open een glTF/GLB-, FBX- of OBJ-lichaam voor de live 3D-weergave.");
1028	}
1029	}
1030	});
1031	}
1032
1033	fn paint_pass(&mut self, ui: &mut egui::Ui) {
1034	let Some(image) = &self.render_ui.preview else {
1035	return;
1036	};
1037	ui.label(format!(
1038	"Laatste voltooide pass: {}",
1039	self.render_ui.preview_label
1040	));
1041	if self.pass_texture.is_none()
1042	\|\| self.pass_texture_revision != self.render_ui.preview_revision
1043	{
1044	let color = egui::ColorImage::from_rgba_unmultiplied(
1045	[image.width as usize, image.height as usize],
1046	&image.rgba,
1047	);
1048	let options = egui::TextureOptions::NEAREST;
1049	if let Some(texture) = &mut self.pass_texture {
1050	texture.set(color, options);
1051	} else {
1052	self.pass_texture = Some(ui.ctx().load_texture("render-pass", color, options));
1053	}
1054	self.pass_texture_revision = self.render_ui.preview_revision;
1055	}
1056	let texture = self.pass_texture.as_ref().expect("pass texture installed");
1057	let (bounds, _) = ui.allocate_exact_size(ui.available_size(), egui::Sense::hover());
1058	let fit = crate::render_job::fit_preview(
1059	[image.width, image.height],
1060	[bounds.width(), bounds.height()],
1061	);
1062	let rect = egui::Rect::from_min_size(
1063	bounds.min + egui::vec2(fit.offset[0], fit.offset[1]),
1064	egui::vec2(fit.size[0], fit.size[1]),
1065	);
1066	ui.painter().rect_filled(bounds, 0.0, egui::Color32::BLACK);
1067	ui.painter().image(
1068	texture.id(),
1069	rect,
1070	egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)),
1071	egui::Color32::WHITE,
1072	);
1073	}
1074
1075	fn show_equipment_list(&mut self, ctx: &egui::Context) {
1076	self.toolbar(ctx, true);
1077	egui::CentralPanel::default().show(ctx, \|ui\| {
1078	if self.session.confirm.is_some() \|\| self.dialog_pending {
1079	ui.disable();
1080	}
1081	ui.heading(format!(
1082	"Bodies → {} → Equipment",
1083	match self.session.active_body {
1084	Some(Sex::Male) => "Man",
1085	Some(Sex::Female) => "Vrouw",
1086	None => "Body",
1087	}
1088	));
1089	if ui.button("Terug naar body").clicked() {
1090	self.session.back();
1091	}
1092	let mut open = None;
1093	for (index, item) in self.session.equipment.iter().enumerate() {
1094	let label = match &item.model {
1095	Some(model) => format!("{} {model}", item.slug),
1096	None => item.slug.clone(),
1097	};
1098	if ui.button(label).clicked() {
1099	open = Some(index);
1100	}
1101	}
1102	if ui
1103	.add_enabled(
1104	self.session.equipment.len() < crate::project::MAX_PROJECT_PRESETS,
1105	egui::Button::new("Nieuw"),
1106	)
1107	.clicked()
1108	{
1109	self.equipment_part = 0;
1110	self.session.add_equipment();
1111	}
1112	if ui
1113	.add_enabled(
1114	self.session.equipment.len() < crate::project::MAX_PROJECT_PRESETS,
1115	egui::Button::new("Preset importeren"),
1116	)
1117	.clicked()
1118	{
1119	self.dialogs.start(DialogPurpose::ImportEquipment);
1120	}
1121	if let Some(index) = open {
1122	self.session.show_equipment(index);
1123	}
1124	});
1125	}
1126
1127	fn show_equipment(&mut self, ctx: &egui::Context) {
1128	self.toolbar(ctx, true);
1129	let Screen::Equipment(index) = self.session.screen else {
1130	return;
1131	};
1132	let mut sex = if self.session.active_body == Some(Sex::Female) {
1133	1
1134	} else {
1135	0
1136	};
1137	egui::SidePanel::left("equipment-config")
1138	.default_width(330.0)
1139	.resizable(true)
1140	.show(ctx, \|ui\| {
1141	if self.session.confirm.is_some() \|\| self.dialog_pending {
1142	ui.disable();
1143	}
1144	egui::ScrollArea::vertical().show(ui, \|ui\| {
1145	ui.heading("Equipment-configuratie");
1146	if ui.button("Terug naar equipment").clicked() {
1147	self.session.show_equipment_list();
1148	}
1149	ui.horizontal(\|ui\| {
1150	ui.selectable_value(&mut sex, 0, "Man");
1151	ui.selectable_value(&mut sex, 1, "Vrouw");
1152	});
1153	self.session.active_body = Some(if sex == 0 { Sex::Male } else { Sex::Female });
1154	let Some(item) = self.session.equipment.get_mut(index) else {
1155	return;
1156	};
1157	ui.label("Naam (kleine letters/cijfers/-/_)");
1158	ui.text_edit_singleline(&mut item.slug);
1159	if !crate::equipment::valid_name(&item.slug) {
1160	ui.colored_label(
1161	egui::Color32::LIGHT_RED,
1162	"Ongeldige naam; 'body' is gereserveerd.",
1163	);
1164	}
1165	if let Some(error) = &item.error {
1166	ui.colored_label(egui::Color32::LIGHT_RED, error);
1167	}
1168	if ui.button("Onderdeel toevoegen (OBJ/FBX)").clicked() {
1169	self.dialogs.start(DialogPurpose::EquipmentModel(index));
1170	}
1171	if let Some(preset) = &mut item.preset {
1172	ui.horizontal(\|ui\| {
1173	ui.label("Geldig voor:");
1174	ui.checkbox(&mut preset.applies[0], "Man");
1175	ui.checkbox(&mut preset.applies[1], "Vrouw");
1176	});
1177	if !preset.applies[0] && !preset.applies[1] {
1178	ui.colored_label(
1179	egui::Color32::LIGHT_RED,
1180	"Kies minstens één geslacht.",
1181	);
1182	}
1183	ui.label("Herkomst / licentie (max. 4096 UTF-8 bytes)");
1184	ui.add(
1185	egui::TextEdit::multiline(&mut preset.provenance)
1186	.desired_rows(2)
1187	.char_limit(4096),
1188	);
1189	if preset.provenance.len() > 4096 {
1190	ui.colored_label(
1191	egui::Color32::LIGHT_RED,
1192	"Herkomst/licentie is te lang.",
1193	);
1194	}
1195	if !preset.attachments.is_empty() {
1196	self.equipment_part =
1197	self.equipment_part.min(preset.attachments.len() - 1);
1198	egui::ComboBox::from_id_salt("equipment-part")
1199	.selected_text(&preset.attachments[self.equipment_part].label)
1200	.show_ui(ui, \|ui\| {
1201	for (part, item) in preset.attachments.iter().enumerate() {
1202	ui.selectable_value(
1203	&mut self.equipment_part,
1204	part,
1205	&item.label,
1206	);
1207	}
1208	});
1209	let body = if sex == 0 {
1210	self.preview_male.as_ref()
1211	} else {
1212	self.preview_female.as_ref()
1213	};
1214	let attachment = &mut preset.attachments[self.equipment_part];
1215	ui.label("Positie relatief aan bot (XYZ)");
1216	ui.horizontal(\|ui\| {
1217	for value in &mut attachment.translation {
1218	ui.add(
1219	egui::DragValue::new(value)
1220	.speed(0.005)
1221	.range(-1000.0..=1000.0),
1222	);
1223	}
1224	});
1225	ui.label("Rotatie in graden XYZ (Rz·Ry·Rx)");
1226	ui.horizontal(\|ui\| {
1227	for value in &mut attachment.rotation_deg {
1228	ui.add(
1229	egui::DragValue::new(value)
1230	.speed(0.5)
1231	.range(-3600.0..=3600.0),
1232	);
1233	}
1234	});
1235	ui.add(
1236	egui::Slider::new(&mut attachment.specular, 0.0..=1.0)
1237	.text("Glanssterkte"),
1238	);
1239	let shiny = attachment
1240	.shiny
1241	.and_then(\|i\| preset.assets.get(i))
1242	.map(\|a\| a.path.clone());
1243	ui.label(shiny.unwrap_or_else(\|\| "Glanssterkte zonder texture".into()));
1244	if ui.button("Kies shinymap (PNG)").clicked() {
1245	self.dialogs.start(DialogPurpose::EquipmentShiny(
1246	index,
1247	self.equipment_part,
1248	));
1249	}
1250	let clear_shiny = ui.button("Wis shinymap").clicked();
1251	let selected = attachment.bones[sex].clone();
1252	if clear_shiny {
1253	if let Err(error) =
1254	crate::equipment::clear_shiny(preset, self.equipment_part)
1255	{
1256	item.error = Some(error);
1257	}
1258	}
1259	ui.label(format!(
1260	"Bot: {}",
1261	selected.as_deref().unwrap_or("nog niet gekoppeld")
1262	));
1263	if let Some(reason) = body.and_then(PreviewCharacter::static_reason) {
1264	ui.add_enabled_ui(false, \|ui\| {
1265	ui.collapsing("Skeleton / botten", \|ui\| {
1266	ui.label("Geen botten");
1267	});
1268	});
1269	ui.colored_label(
1270	egui::Color32::LIGHT_RED,
1271	format!("{reason}. Botkoppeling is niet beschikbaar; kies een geskind glTF/GLB- of FBX-lichaam."),
1272	);
1273	} else if let Some(body) = body {
1274	if preset.rigs[sex].as_ref()
1275	!= Some(&crate::equipment::RigSignature::of(body))
1276	{
1277	ui.colored_label(
1278	egui::Color32::LIGHT_RED,
1279	"Rigbinding ontbreekt of wijkt af; selecteer een bot.",
1280	);
1281	}
1282	ui.collapsing("Skeleton / botten", \|ui\| {
1283	if let Some(joint) = bone_tree(ui, body, selected.as_deref()) {
1284	if let Err(error) =
1285	preset.bind(sex, body, self.equipment_part, joint)
1286	{
1287	ui.colored_label(egui::Color32::LIGHT_RED, error);
1288	}
1289	}
1290	});
1291	} else {
1292	ui.colored_label(
1293	egui::Color32::LIGHT_RED,
1294	"Open een geskind glTF/GLB- of FBX-lichaam voor deze rigbinding.",
1295	);
1296	}
1297	if ui.button("Verwijder onderdeel").clicked() {
1298	if let Err(error) =
1299	crate::equipment::remove_attachment(preset, self.equipment_part)
1300	{
1301	item.error = Some(error);
1302	}
1303	self.equipment_part = self.equipment_part.saturating_sub(1);
1304	}
1305	}
1306	}
1307	if ui.button("Verwijder equipmentdefinitie").clicked() {
1308	self.session.delete_equipment(index);
1309	}
1310	});
1311	});
1312	self.controls.sex = if sex == 0 {
1313	PreviewSex::Male
1314	} else {
1315	PreviewSex::Female
1316	};
1317	egui::CentralPanel::default().show(ctx, \|ui\| {
1318	if self.session.confirm.is_some() \|\| self.dialog_pending {
1319	ui.disable();
1320	}
1321	ui.horizontal_wrapped(\|ui\| {
1322	let static_body = self.character().is_some_and(PreviewCharacter::is_static);
1323	if ui
1324	.add_enabled(
1325	!self.render_ui.running && !static_body,
1326	egui::Button::new("Render equipment · alle hoeken"),
1327	)
1328	.on_disabled_hover_text(
1329	"Niet beschikbaar: statisch lichaam zonder skeleton (geen bot om aan te hangen)",
1330	)
1331	.clicked()
1332	{
1333	self.start_render();
1334	}
1335	if ui.button("Live 3D").clicked() {
1336	self.render_ui.preview = None;
1337	}
1338	if ui.button("2D-preview").clicked() {
1339	self.open_preview2d();
1340	}
1341	});
1342	self.render_progress_ui(ui);
1343	self.resume_ui(ui);
1344	if self.render_ui.preview.is_some() {
1345	self.paint_pass(ui);
1346	return;
1347	}
1348	let framing = self.fixed_camera();
1349	let body = if sex == 0 {
1350	self.preview_male.as_ref()
1351	} else {
1352	self.preview_female.as_ref()
1353	};
1354	let preset = self
1355	.session
1356	.equipment
1357	.get(index)
1358	.and_then(\|item\| item.preset.as_ref());
1359	// A static body has no bones; equipment layers are not attached
1360	// to an invented skeleton, so the live view shows only the body.
1361	let presets: Vec<_> = preset
1362	.into_iter()
1363	.filter(\|_\| !body.is_some_and(PreviewCharacter::is_static))
1364	.collect();
1365	if let Some(reason) = body.and_then(PreviewCharacter::static_reason) {
1366	ui.colored_label(
1367	egui::Color32::from_rgb(230, 190, 90),
1368	format!("{reason}. Equipment koppelen en renderen is voor dit lichaam niet beschikbaar."),
1369	);
1370	}
1371	self.viewport
1372	.show_framed(ui, &mut self.controls, body, &presets, framing);
1373	});
1374	}
1375
1376	pub fn open_preview2d(&mut self) {
1377	self.refresh_preview2d_catalog();
1378	sync_state_from_catalog(&mut self.preview2d, &self.preview2d_catalog);
1379	self.preview2d_image = None;
1380	self.preview2d_texture = None;
1381	self.preview2d_texture_key = None;
1382	self.session.show_preview2d();
1383	}
1384
1385	pub fn preview2d_state(&self) -> &Preview2dState {
1386	&self.preview2d
1387	}
1388
1389	pub fn preview2d_image(&self) -> Option<&ImageBuf> {
1390	self.preview2d_image.as_ref()
1391	}
1392
1393	fn refresh_preview2d_catalog(&mut self) {
1394	self.preview2d_catalog = match self.session.project_root() {
1395	Some(root) => discover_completed_runs(&root),
1396	None => Vec::new(),
1397	};
1398	}
1399
1400	fn rebuild_preview2d_frame(&mut self) {
1401	let sex = self.preview2d.sex;
1402	let equipment = self.preview2d.selected_equipment.clone();
1403	let clip = self.preview2d.clip_token.clone();
1404	let frame = self.preview2d.frame_index();
1405	let pitch = self.preview2d.pitch_deg();
1406	let yaw = self.preview2d.yaw_deg();
1407	let light = self.preview2d.light();
1408	let rim = self.preview2d.rim();
1409	if clip.is_empty() {
1410	self.preview2d.diagnostic = Some("geen clip in de voltooide body-export".into());
1411	self.preview2d_image = None;
1412	return;
1413	}
1414	match open_selection(&self.preview2d_catalog, sex, &equipment) {
1415	Ok((body, gear)) => match compose_preview_frame(ComposeRequest {
1416	body: &body,
1417	equipment: &gear,
1418	clip_token: &clip,
1419	frame,
1420	pitch,
1421	yaw,
1422	light,
1423	rim,
1424	}) {
1425	Ok(image) => {
1426	self.preview2d.diagnostic = None;
1427	self.preview2d_image = Some(image);
1428	}
1429	Err(err) => {
1430	self.preview2d.diagnostic = Some(err.to_string());
1431	self.preview2d_image = None;
1432	}
1433	},
1434	Err(err) => {
1435	self.preview2d.diagnostic = Some(err.to_string());
1436	self.preview2d_image = None;
1437	}
1438	}
1439	}
1440
1441	fn show_preview2d(&mut self, ctx: &egui::Context) {
1442	self.toolbar(ctx, true);
1443	let dt = ctx.input(\|i\| i.stable_dt);
1444	let focused = ctx.input(\|i\| i.focused);
1445	let cancel_holds = ctx.input(\|i\| {
1446	!i.focused
1447	\|\| i.pointer.any_released()
1448	\|\| i.events.iter().any(\|e\| {
1449	matches!(
1450	e,
1451	egui::Event::PointerGone \| egui::Event::WindowFocused(false)
1452	)
1453	})
1454	});
1455	if cancel_holds \|\| !focused {
1456	self.preview2d.on_interaction_cancel();
1457	}
1458	self.preview2d.tick(dt);
1459
1460	let mut need_rebuild = false;
1461	let mut refresh_catalog = false;
1462	let mut go_back = false;
1463	let mut set_sex = None;
1464	let mut toggle_set = None;
1465	let mut select_clip = None;
1466	let mut step_yaw = 0i32;
1467	let mut step_pitch = 0i32;
1468	let mut toggle_play = false;
1469	let mut apply_speed = false;
1470	let mut hold_az = None;
1471	let mut hold_el = None;
1472	let mut release_az = false;
1473	let mut release_el = false;
1474
1475	egui::SidePanel::left("preview2d_controls")
1476	.default_width(330.0)
1477	.show(ctx, \|ui\| {
1478	if self.session.confirm.is_some() \|\| self.dialog_pending {
1479	ui.disable();
1480	}
1481	ui.heading("2D-preview");
1482	if ui.button("Terug").clicked() {
1483	go_back = true;
1484	}
1485	ui.separator();
1486	ui.label("Geslacht");
1487	ui.horizontal(\|ui\| {
1488	if ui
1489	.selectable_label(self.preview2d.sex == Sex::Male, "Man")
1490	.clicked()
1491	{
1492	set_sex = Some(Sex::Male);
1493	}
1494	if ui
1495	.selectable_label(self.preview2d.sex == Sex::Female, "Vrouw")
1496	.clicked()
1497	{
1498	set_sex = Some(Sex::Female);
1499	}
1500	});
1501	if ui.button("Vernieuw exportsets").clicked() {
1502	refresh_catalog = true;
1503	}
1504	ui.label(format!(
1505	"{} voltooide exportset(s)",
1506	self.preview2d_catalog.len()
1507	));
1508	ui.separator();
1509	ui.label("Equipment (zelfde project/rig/contract)");
1510	let allowed =
1511	compatible_equipment_sets(&self.preview2d_catalog, self.preview2d.sex);
1512	if allowed.is_empty() {
1513	ui.weak("Geen compatibele equipment-export.");
1514	}
1515	for set in allowed {
1516	let mut checked = self.preview2d.selected_equipment.iter().any(\|s\| s == &set);
1517	if ui.checkbox(&mut checked, &set).changed() {
1518	toggle_set = Some(set);
1519	}
1520	}
1521	ui.separator();
1522	ui.label("Clip");
1523	let sex_token = self.preview2d.sex_token();
1524	let clips: Vec<_> = self
1525	.preview2d_catalog
1526	.iter()
1527	.filter(\|e\| e.sex == sex_token && e.is_body())
1528	.max_by_key(\|e\| e.path.clone())
1529	.map(\|e\| e.clips.clone())
1530	.unwrap_or_default();
1531	if clips.is_empty() {
1532	ui.colored_label(
1533	egui::Color32::LIGHT_RED,
1534	"Geen body-export met clips voor dit geslacht.",
1535	);
1536	}
1537	for (token, name, frames, duration) in &clips {
1538	let label = if name.is_empty() {
1539	format!("{token} ({frames}f)")
1540	} else {
1541	format!("{name} ({token}, {frames}f)")
1542	};
1543	if ui
1544	.selectable_label(self.preview2d.clip_token == *token, label)
1545	.clicked()
1546	{
1547	select_clip = Some((token.clone(), frames, duration));
1548	}
1549	}
1550	ui.separator();
1551	ui.horizontal(\|ui\| {
1552	let play_label = if self.preview2d.playing {
1553	"Pauze"
1554	} else {
1555	"Speel"
1556	};
1557	if ui.button(play_label).clicked() {
1558	toggle_play = true;
1559	}
1560	ui.label(format!(
1561	"frame {}/{} t={:.2}s",
1562	self.preview2d.frame_index() + 1,
1563	self.preview2d.clip_frames.max(1),
1564	self.preview2d.elapsed_secs
1565	));
1566	});
1567	ui.horizontal(\|ui\| {
1568	ui.label("Snelheid");
1569	ui.add(
1570	egui::TextEdit::singleline(&mut self.preview2d_speed_text)
1571	.desired_width(48.0),
1572	);
1573	if ui.button("Pas toe").clicked() {
1574	apply_speed = true;
1575	}
1576	ui.label(format!("export-fps {}", self.preview2d.fps));
1577	});
1578	ui.separator();
1579	ui.label("Hoek (export)");
1580	ui.horizontal(\|ui\| {
1581	if ui.button("Yaw −").clicked() {
1582	step_yaw = -1;
1583	}
1584	if ui.button("Yaw +").clicked() {
1585	step_yaw = 1;
1586	}
1587	ui.label(format!("yaw {}°", self.preview2d.yaw_deg()));
1588	});
1589	ui.horizontal(\|ui\| {
1590	if ui.button("Pitch −").clicked() {
1591	step_pitch = -1;
1592	}
1593	if ui.button("Pitch +").clicked() {
1594	step_pitch = 1;
1595	}
1596	ui.label(format!("pitch {}°", self.preview2d.pitch_deg()));
1597	});
1598	ui.separator();
1599	ui.label("Licht (vasthouden; °/s)");
1600	ui.horizontal(\|ui\| {
1601	let west = ui.button("Azimut −");
1602	let east = ui.button("Azimut +");
1603	if west.is_pointer_button_down_on() {
1604	hold_az = Some(HoldSign::Negative);
1605	} else if east.is_pointer_button_down_on() {
1606	hold_az = Some(HoldSign::Positive);
1607	} else if self.preview2d.hold_azimuth.is_some()
1608	&& !west.is_pointer_button_down_on()
1609	&& !east.is_pointer_button_down_on()
1610	{
1611	release_az = true;
1612	}
1613	ui.label(format!("{:.0}°", self.preview2d.light_azimuth_deg));
1614	});
1615	ui.horizontal(\|ui\| {
1616	let down = ui.button("Elevatie −");
1617	let up = ui.button("Elevatie +");
1618	if down.is_pointer_button_down_on() {
1619	hold_el = Some(HoldSign::Negative);
1620	} else if up.is_pointer_button_down_on() {
1621	hold_el = Some(HoldSign::Positive);
1622	} else if self.preview2d.hold_elevation.is_some()
1623	&& !down.is_pointer_button_down_on()
1624	&& !up.is_pointer_button_down_on()
1625	{
1626	release_el = true;
1627	}
1628	ui.label(format!("{:.0}°", self.preview2d.light_elevation_deg));
1629	});
1630	ui.weak("Azimut 0° = licht van voren (+Z); elevatie geklemd −80…+80.");
1631	ui.separator();
1632	ui.label("Randlicht (preview)");
1633	let mut rim = self.preview2d.rim_intensity;
1634	let rim_slider =
1635	ui.add(egui::Slider::new(&mut rim, 0.0..=MAX_RIM_INTENSITY).text("sterkte"));
1636	if rim_slider.changed() {
1637	self.preview2d.set_rim_intensity(rim);
1638	need_rebuild = true;
1639	}
1640	ui.weak(
1641	"Fresnel + diepterand; 0 = alleen relight. Wijzigt geen opgeslagen diffuse.",
1642	);
1643	});
1644
1645	if go_back {
1646	self.session.back();
1647	return;
1648	}
1649	if refresh_catalog {
1650	self.refresh_preview2d_catalog();
1651	sync_state_from_catalog(&mut self.preview2d, &self.preview2d_catalog);
1652	need_rebuild = true;
1653	}
1654	if let Some(sex) = set_sex {
1655	self.preview2d.set_sex(sex);
1656	sync_state_from_catalog(&mut self.preview2d, &self.preview2d_catalog);
1657	need_rebuild = true;
1658	}
1659	if let Some(set) = toggle_set {
1660	self.preview2d.toggle_equipment(&set);
1661	need_rebuild = true;
1662	}
1663	if let Some((token, frames, duration)) = select_clip {
1664	self.preview2d.set_clip(token, frames, duration);
1665	need_rebuild = true;
1666	}
1667	if toggle_play {
1668	self.preview2d.playing = !self.preview2d.playing;
1669	}
1670	if apply_speed {
1671	if let Ok(speed) = self.preview2d_speed_text.parse::<f32>() {
1672	if speed.is_finite() && speed >= 0.0 {
1673	self.preview2d.playback_speed = speed;
1674	}
1675	}
1676	}
1677	if step_yaw != 0 {
1678	self.preview2d.step_yaw(step_yaw);
1679	need_rebuild = true;
1680	}
1681	if step_pitch != 0 {
1682	self.preview2d.step_pitch(step_pitch);
1683	need_rebuild = true;
1684	}
1685	if let Some(sign) = hold_az {
1686	self.preview2d.hold_light(LightAxis::Azimuth, sign);
1687	} else if release_az {
1688	self.preview2d.release_light(LightAxis::Azimuth);
1689	}
1690	if let Some(sign) = hold_el {
1691	self.preview2d.hold_light(LightAxis::Elevation, sign);
1692	} else if release_el {
1693	self.preview2d.release_light(LightAxis::Elevation);
1694	}
1695
1696	// Continuous light or playing changes the image every tick.
1697	if self.preview2d.playing
1698	\|\| self.preview2d.hold_azimuth.is_some()
1699	\|\| self.preview2d.hold_elevation.is_some()
1700	{
1701	need_rebuild = true;
1702	}
1703
1704	let key = (
1705	self.preview2d.clip_token.clone(),
1706	self.preview2d.frame_index(),
1707	self.preview2d.pitch_deg(),
1708	self.preview2d.yaw_deg(),
1709	self.preview2d.selected_equipment.len() as u32,
1710	format!(
1711	"{:.1}/{:.1}/{:.3}/{}",
1712	self.preview2d.light_azimuth_deg,
1713	self.preview2d.light_elevation_deg,
1714	self.preview2d.rim_intensity,
1715	self.preview2d.sex_token()
1716	),
1717	);
1718	if need_rebuild \|\| self.preview2d_texture_key.as_ref() != Some(&key) {
1719	self.rebuild_preview2d_frame();
1720	self.preview2d_texture_key = Some(key);
1721	self.preview2d_texture = None;
1722	}
1723
1724	egui::CentralPanel::default().show(ctx, \|ui\| {
1725	if self.session.confirm.is_some() \|\| self.dialog_pending {
1726	ui.disable();
1727	}
1728	if let Some(diag) = &self.preview2d.diagnostic {
1729	ui.colored_label(egui::Color32::LIGHT_RED, diag);
1730	}
1731	let Some(image) = &self.preview2d_image else {
1732	ui.label(
1733	"Geen samengesteld frame. Render eerst body (en optioneel equipment) via Render alle hoeken.",
1734	);
1735	return;
1736	};
1737	if self.preview2d_texture.is_none() {
1738	let color = egui::ColorImage::from_rgba_unmultiplied(
1739	[image.width as usize, image.height as usize],
1740	&image.rgba,
1741	);
1742	self.preview2d_texture = Some(ui.ctx().load_texture(
1743	"preview2d-frame",
1744	color,
1745	egui::TextureOptions::NEAREST,
1746	));
1747	}
1748	let texture = self.preview2d_texture.as_ref().expect("texture");
1749	let (bounds, _) = ui.allocate_exact_size(ui.available_size(), egui::Sense::hover());
1750	let fit = crate::render_job::fit_preview(
1751	[image.width, image.height],
1752	[bounds.width(), bounds.height()],
1753	);
1754	let rect = egui::Rect::from_min_size(
1755	bounds.min + egui::vec2(fit.offset[0], fit.offset[1]),
1756	egui::vec2(fit.size[0], fit.size[1]),
1757	);
1758	ui.painter().rect_filled(bounds, 0.0, egui::Color32::BLACK);
1759	ui.painter().image(
1760	texture.id(),
1761	rect,
1762	egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)),
1763	egui::Color32::WHITE,
1764	);
1765	});
1766	}
1767
1768	fn toolbar(&mut self, ctx: &egui::Context, project: bool) {
1769	if !project {
1770	return;
1771	}
1772	egui::TopBottomPanel::top("toolbar").show(ctx, \|ui\| {
1773	if self.session.confirm.is_some() \|\| self.dialog_pending {
1774	ui.disable();
1775	}
1776	ui.horizontal(\|ui\| {
1777	if ui.button("Body").clicked() {
1778	self.session.show_bodies();
1779	}
1780	if ui.button("2D-preview").clicked() {
1781	self.open_preview2d();
1782	}
1783	if ui.button("Opslaan").clicked() {
1784	self.save();
1785	}
1786	if ui
1787	.add_enabled(!self.render_ui.running, egui::Button::new("Nieuw project"))
1788	.clicked()
1789	{
1790	self.begin(Intent::PickNew);
1791	}
1792	if ui
1793	.add_enabled(!self.render_ui.running, egui::Button::new("Ander project"))
1794	.clicked()
1795	{
1796	self.begin(Intent::PickLoad);
1797	}
1798	});
1799	});
1800	}
1801	}
1802
1803	fn bone_tree(ui: &mut egui::Ui, body: &PreviewCharacter, selected: Option<&str>) -> Option<usize> {
1804	fn node(
1805	ui: &mut egui::Ui,
1806	body: &PreviewCharacter,
1807	paths: &[String],
1808	index: usize,
1809	selected: Option<&str>,
1810	choice: &mut Option<usize>,
1811	depth: usize,
1812	) {
1813	if depth > 64 {
1814	return;
1815	}
1816	let joint = body.joint_nodes.iter().position(\|i\| *i == index);
1817	let children: Vec<_> = body
1818	.nodes
1819	.iter()
1820	.enumerate()
1821	.filter(\|(_, n)\| n.parent == Some(index))
1822	.map(\|(i, _)\| i)
1823	.collect();
1824	let label = if body.nodes[index].name.is_empty() {
1825	format!("node-{index}")
1826	} else {
1827	body.nodes[index].name.clone()
1828	};
1829	let select = \|ui: &mut egui::Ui, choice: &mut Option<usize>\| {
1830	if let Some(joint) = joint {
1831	if ui
1832	.selectable_label(
1833	selected == Some(paths[joint].as_str()),
1834	format!("Koppel {label}"),
1835	)
1836	.clicked()
1837	{
1838	*choice = Some(joint);
1839	}
1840	}
1841	};
1842	if children.is_empty() {
1843	select(ui, choice);
1844	} else {
1845	egui::CollapsingHeader::new(&label)
1846	.id_salt(index)
1847	.default_open(depth < 2)
1848	.show(ui, \|ui\| {
1849	select(ui, choice);
1850	for child in children {
1851	node(ui, body, paths, child, selected, choice, depth + 1);
1852	}
1853	});
1854	}
1855	}
1856	let mut choice = None;
1857	let paths = crate::preview::joint_paths(body);
1858	for (index, item) in body.nodes.iter().enumerate() {
1859	if item.parent.is_none() {
1860	node(ui, body, &paths, index, selected, &mut choice, 0);
1861	}
1862	}
1863	choice
1864	}
1865
1866	#[cfg(test)]
1867	mod tests {
1868	use super::*;
1869	use crate::dialogs::ScriptedDialogs;
1870	use crate::session::Choice;
1871
1872	fn root() -> PathBuf {
1873	std::env::temp_dir().join(format!(
1874	"paperdoll-editor-{}",
1875	std::time::SystemTime::now()
1876	.duration_since(std::time::UNIX_EPOCH)
1877	.unwrap()
1878	.as_nanos()
1879	))
1880	}
1881
1882	#[test]
1883	fn picker_creates_project_and_cancelled_switch_preserves_edits() {
1884	let root = root();
1885	let mut dialogs = ScriptedDialogs::default();
1886	dialogs.push(Some(root.clone()));
1887	dialogs.push(None);
1888	let mut app = EditorApp::new(Box::new(dialogs));
1889	assert_eq!(app.session.shell_size(), crate::session::START_WINDOW);
1890	app.begin(Intent::PickNew);
1891	app.poll_dialogs();
1892	assert_eq!(app.session.screen, Screen::Bodies);
1893	assert!(app.preview_male.is_some());
1894	assert!(app.preview_female.is_some());
1895	app.session.set_name("Keep my edit".into());
1896	app.begin(Intent::PickLoad);
1897	assert_eq!(app.session.confirm, Some(Intent::PickLoad));
1898	app.apply_choice(Choice::Discard, &egui::Context::default());
1899	app.poll_dialogs(); // OS picker cancel; no actual project switch happened
1900	assert_eq!(
1901	app.session.opened.as_ref().unwrap().document.name,
1902	"Keep my edit"
1903	);
1904	assert!(app.session.is_dirty());
1905	let _ = std::fs::remove_dir_all(root);
1906	}
1907
1908	#[test]
1909	fn failed_save_never_closes_or_switches_and_invalid_open_keeps_current() {
1910	let root = root();
1911	let mut app = EditorApp::default();
1912	app.session.install_new_project(&root).unwrap();
1913	app.session.set_render(0, 128, 12);
1914	app.begin(Intent::Quit);
1915	app.apply_choice(Choice::Save, &egui::Context::default());
1916	assert!(!app.allow_close);
1917	assert_eq!(app.session.confirm, Some(Intent::Quit));
1918	assert!(app.session.is_dirty());
1919	app.open_path(root.join("missing.ppd"));
1920	assert!(app.session.opened.is_some());
1921	assert_eq!(app.session.screen, Screen::Bodies);
1922	let _ = std::fs::remove_dir_all(root);
1923	}
1924
1925	#[test]
1926	fn fbx_body_and_fbx_equipment_reach_live_view_and_render_job() {
1927	let root = root();
1928	let fixtures = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
1929	let mut app = EditorApp::default();
1930	app.session.install_new_project(&root).unwrap();
1931	let relative = crate::session::adopt_file(
1932	&root,
1933	&fixtures.join("bodies/test-body-male.fbx"),
1934	"assets/body",
1935	)
1936	.unwrap();
1937	app.session.set_body_path(Sex::Male, relative);
1938	app.session.save().unwrap();
1939	app.open_path(root.join("character.ppd"));
1940	let male = app.preview_male.clone().expect("FBX-lichaam in live view");
1941	assert_eq!(male.joint_names.len(), 19);
1942	assert!(male.clips.iter().any(\|c\| c.name.contains("walk")));
1943	assert!(matches!(&app.inventories[0], Some(Ok(_))));
1944	// Rigid FBX equipment through the same picker path, auto-bound to the FBX rig.
1945	let index = app.session.add_equipment();
1946	app.session.equipment[index].slug = "fbxsword".into();
1947	app.session.active_body = Some(Sex::Male);
1948	app.take_equipment(index, &fixtures.join("equipment/sword-fbx.fbx"));
1949	let preset = app.session.equipment[index].preset.clone().expect("preset");
1950	assert_eq!(preset.attachments[0].label, "sword-fbx.fbx");
1951	assert!(preset.attachments[0].bones[0].is_some());
1952	assert_eq!(
1953	preset.rigs[0].as_ref(),
1954	Some(&crate::equipment::RigSignature::of(&male))
1955	);
1956	app.open_body_configuration(Sex::Male);
1957	let job = app.build_job().expect("render job for FBX body");
1958	assert_eq!(job.body_model.path, "assets/body/test-body-male.fbx");
1959	assert_eq!(job.character.positions, male.positions);
1960	let _ = std::fs::remove_dir_all(root);
1961	}
1962
1963	#[test]
1964	fn static_obj_body_reaches_live_view_and_disables_bone_functions() {
1965	let root = root();
1966	let fixtures = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
1967	let mut app = EditorApp::default();
1968	app.session.install_new_project(&root).unwrap();
1969	let mut relative = String::new();
1970	for name in [
1971	"static-body-male.obj",
1972	"static-body-male.mtl",
1973	"static-body-albedo.png",
1974	] {
1975	let r = crate::session::adopt_file(
1976	&root,
1977	&fixtures.join("bodies/static").join(name),
1978	"assets/body",
1979	)
1980	.unwrap();
1981	if name.ends_with(".obj") {
1982	relative = r;
1983	}
1984	}
1985	app.session.set_body_path(Sex::Male, relative.clone());
1986	app.session.save().unwrap();
1987	app.open_path(root.join("character.ppd"));
1988	let male = app
1989	.preview_male
1990	.clone()
1991	.expect("statisch OBJ-lichaam in live view");
1992	assert!(male.is_static());
1993	assert!(male.clips.is_empty() && male.joint_names.is_empty());
1994	let inventory = app.inventories[0].as_ref().unwrap().as_ref().unwrap();
1995	assert!(inventory.joints.is_empty() && inventory.clips.is_empty());
1996	// Equipment can be imported but is never auto-bound to an invented bone.
1997	let index = app.session.add_equipment();
1998	app.session.equipment[index].slug = "sword".into();
1999	app.session.active_body = Some(Sex::Male);
2000	app.take_equipment(index, &fixtures.join("equipment/sword.obj"));
2001	let preset = app.session.equipment[index].preset.clone().expect("preset");
2002	assert!(preset.attachments[0].bones[0].is_none());
2003	assert!(preset.rigs[0].is_none());
2004	app.open_body_configuration(Sex::Male);
2005	let job = app.build_job().expect("render job for static body");
2006	assert_eq!(job.body_model.path, relative);
2007	assert!(job.character.is_static());
2008	let contract = crate::production::contract(job).unwrap();
2009	assert_eq!(contract.plan.images, 36);
2010	assert_eq!(contract.plan.clips[0].token, "clip000-bind");
2011	app.open_equipment_configuration(index, Sex::Male);
2012	let job = app.build_job().expect("equipment job object");
2013	assert!(crate::production::contract(job)
2014	.err()
2015	.unwrap()
2016	.contains("statisch"));
2017	// Headless UI frames for the body and equipment screens must not panic.
2018	let ctx = egui::Context::default();
2019	for screen in 0..2 {
2020	if screen == 0 {
2021	app.open_body_configuration(Sex::Male);
2022	} else {
2023	app.open_equipment_configuration(index, Sex::Male);
2024	}
2025	let _ = ctx.run(egui::RawInput::default(), \|ctx\| match screen {
2026	0 => app.show_body(ctx),
2027	_ => app.show_equipment(ctx),
2028	});
2029	}
2030	let _ = std::fs::remove_dir_all(root);
2031	}
2032
2033	#[test]
2034	fn open_with_project_path_loads_bodies_and_models() {
2035	let root = root().join("project with spaces");
2036	let opened = crate::session::create_seeded_project(&root).unwrap();
2037	let mut app = EditorApp::default();
2038	app.open_path(opened.manifest_path.clone());
2039	assert_eq!(app.session.screen, Screen::Bodies);
2040	assert!(app.preview_male.is_some());
2041	assert_eq!(
2042	app.session.opened.unwrap().manifest_path,
2043	opened.manifest_path
2044	);
2045	let _ = std::fs::remove_dir_all(root.parent().unwrap());
2046	}
2047
2048	#[test]
2049	fn renderer_disconnect_is_reported() {
2050	let mut app = EditorApp::default();
2051	let (_, gpu) = std::sync::mpsc::channel();
2052	app.render_worker = Some(crate::production::RenderThread {
2053	mailbox: Default::default(),
2054	gpu,
2055	cancel: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
2056	handle: None,
2057	});
2058	app.render_ui.running = true;
2059	app.drain_render();
2060	assert!(!app.render_ui.running);
2061	assert!(app.render_ui.error.is_some());
2062	}
2063	}