src/render_job.rs

render_job.rs 9.4 KiB Download Raw

1	//! Actual production pass order and GUI state. The bounded worker/mailbox and
2	//! GPU service are implemented in `production`; previews retain native size.
3
4	use crate::preview::{paperdoll_yaws_deg, PAPERDOLL_PITCHES_DEG};
5	pub use crate::production::{spawn, RenderJob, RenderThread};
6
7	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8	pub enum PassKind {
9	HighresImage,
10	DetailMap,
11	TargetResolution,
12	Depth,
13	Normal,
14	Specular,
15	}
16
17	impl PassKind {
18	pub fn label(self) -> &'static str {
19	match self {
20	Self::HighresImage => "highres",
21	Self::DetailMap => "detail",
22	Self::TargetResolution => "doelresolutie",
23	Self::Depth => "depth",
24	Self::Normal => "normal",
25	Self::Specular => "specular",
26	}
27	}
28
29	pub fn produces_image(self) -> bool {
30	true
31	}
32	}
33
34	pub const PASS_ORDER: [PassKind; 6] = [
35	PassKind::HighresImage,
36	PassKind::DetailMap,
37	PassKind::TargetResolution,
38	PassKind::Depth,
39	PassKind::Normal,
40	PassKind::Specular,
41	];
42
43	#[derive(Debug, Clone, Copy, PartialEq)]
44	pub struct ViewAngle {
45	pub pitch_deg: f32,
46	pub yaw_deg: f32,
47	}
48
49	#[derive(Debug, Clone, Copy, PartialEq)]
50	pub struct PassStep {
51	pub pitch_deg: f32,
52	pub yaw_deg: f32,
53	pub kind: PassKind,
54	}
55
56	#[derive(Debug, Clone, PartialEq, Eq)]
57	pub struct ImageBuf {
58	pub width: u32,
59	pub height: u32,
60	pub rgba: Vec<u8>,
61	}
62
63	#[derive(Debug, Clone, PartialEq, Eq)]
64	pub struct Progress {
65	pub completed: u32,
66	pub total: u32,
67	pub label: String,
68	}
69
70	#[derive(Debug, Clone, PartialEq, Eq)]
71	pub enum RenderEvent {
72	Step {
73	index: u32,
74	total: u32,
75	label: String,
76	},
77	Pass {
78	index: u32,
79	total: u32,
80	label: String,
81	image: Option<ImageBuf>,
82	},
83	Failed(String),
84	Cancelled,
85	Finished {
86	saved: Option<String>,
87	},
88	}
89
90	#[derive(Debug, Clone, PartialEq, Eq)]
91	pub struct RenderUiState {
92	pub progress: Progress,
93	pub preview: Option<ImageBuf>,
94	pub preview_label: String,
95	pub preview_revision: u64,
96	pub saved: Option<String>,
97	pub error: Option<String>,
98	pub running: bool,
99	}
100
101	impl RenderUiState {
102	pub fn idle() -> Self {
103	Self {
104	progress: Progress {
105	completed: 0,
106	total: 0,
107	label: String::new(),
108	},
109	preview: None,
110	preview_label: String::new(),
111	preview_revision: 0,
112	saved: None,
113	error: None,
114	running: false,
115	}
116	}
117
118	pub fn apply(&mut self, event: RenderEvent) {
119	match event {
120	RenderEvent::Step {
121	index,
122	total,
123	label,
124	} => {
125	self.progress = Progress {
126	completed: index,
127	total,
128	label,
129	};
130	self.running = true;
131	}
132	RenderEvent::Pass {
133	index,
134	total,
135	label,
136	image,
137	} => {
138	self.progress = Progress {
139	completed: index + 1,
140	total,
141	label,
142	};
143	if let Some(image) = image {
144	self.preview_label = self.progress.label.clone();
145	self.preview_revision = self.preview_revision.wrapping_add(1);
146	self.preview = Some(image);
147	}
148	self.running = true;
149	}
150	RenderEvent::Cancelled => {
151	self.running = false;
152	self.progress.label = "Geannuleerd; gedeeltelijke uitvoer behouden".into();
153	}
154	RenderEvent::Failed(message) => {
155	self.error = Some(message);
156	self.running = false;
157	}
158	RenderEvent::Finished { saved } => {
159	self.saved = saved;
160	self.running = false;
161	if self.progress.total > 0 {
162	self.progress.completed = self.progress.total;
163	}
164	}
165	}
166	}
167	}
168
169	pub fn export_views() -> Vec<ViewAngle> {
170	let mut views = Vec::with_capacity(PAPERDOLL_PITCHES_DEG.len() * paperdoll_yaws_deg().len());
171	for pitch in PAPERDOLL_PITCHES_DEG {
172	for yaw in paperdoll_yaws_deg() {
173	views.push(ViewAngle {
174	pitch_deg: pitch,
175	yaw_deg: yaw,
176	});
177	}
178	}
179	views
180	}
181
182	pub fn pass_sequence(views: &[ViewAngle]) -> Vec<PassStep> {
183	let mut steps = Vec::with_capacity(views.len() * PASS_ORDER.len());
184	for view in views {
185	for kind in PASS_ORDER {
186	steps.push(PassStep {
187	pitch_deg: view.pitch_deg,
188	yaw_deg: view.yaw_deg,
189	kind,
190	});
191	}
192	}
193	steps
194	}
195
196	/// Nearest-neighbor stretch. Every destination pixel is filled, so the
197	/// preview box has no empty border.
198	pub fn nearest_stretch(src: &[u8], sw: u32, sh: u32, dw: u32, dh: u32) -> Vec<u8> {
199	let mut out = vec![0u8; (dw as usize) * (dh as usize) * 4];
200	if sw == 0 \|\| sh == 0 \|\| dw == 0 \|\| dh == 0 {
201	return out;
202	}
203	for y in 0..dh {
204	let sy = ((y as u64 * sh as u64) / dh as u64) as u32;
205	let sy = sy.min(sh - 1);
206	for x in 0..dw {
207	let sx = ((x as u64 * sw as u64) / dw as u64) as u32;
208	let sx = sx.min(sw - 1);
209	let from = ((sy * sw + sx) * 4) as usize;
210	let to = ((y * dw + x) * 4) as usize;
211	out[to..to + 4].copy_from_slice(&src[from..from + 4]);
212	}
213	}
214	out
215	}
216
217	#[derive(Debug, Clone, Copy, PartialEq)]
218	pub struct PreviewFit {
219	pub size: [f32; 2],
220	pub offset: [f32; 2],
221	}
222
223	pub fn fit_preview(image: [u32; 2], bounds: [f32; 2]) -> PreviewFit {
224	if image.contains(&0) \|\| bounds.iter().any(\|v\| !v.is_finite() \|\| *v <= 0.0) {
225	return PreviewFit {
226	size: [0.; 2],
227	offset: [0.; 2],
228	};
229	}
230	let scale = (bounds[0] / image[0] as f32).min(bounds[1] / image[1] as f32);
231	let size = [image[0] as f32 * scale, image[1] as f32 * scale];
232	PreviewFit {
233	size,
234	offset: [(bounds[0] - size[0]) * 0.5, (bounds[1] - size[1]) * 0.5],
235	}
236	}
237
238	#[cfg(test)]
239	mod tests {
240	use super::*;
241
242	#[test]
243	fn full_view_order_is_pitch_then_yaw_then_passes() {
244	let views = export_views();
245	assert_eq!(views.len(), 36);
246	assert_eq!(views[0].pitch_deg, -30.0);
247	assert_eq!(views[0].yaw_deg, 0.0);
248	assert_eq!(views[11].yaw_deg, 330.0);
249	assert_eq!(views[12].pitch_deg, 0.0);
250	let steps = pass_sequence(&views);
251	assert_eq!(steps.len(), 36 * 6);
252	let first: Vec<_> = steps.iter().take(6).map(\|step\| step.kind).collect();
253	assert_eq!(first, PASS_ORDER.to_vec());
254	assert_eq!(steps[6].yaw_deg, 30.0);
255	assert_eq!(steps[6].kind, PassKind::HighresImage);
256	}
257
258	#[test]
259	fn preview_uniform_scale_centers_and_letterboxes_all_aspects() {
260	let square = fit_preview([128, 128], [480., 640.]);
261	assert_eq!(square.size, [480., 480.]);
262	assert_eq!(square.offset, [0., 80.]);
263	let landscape = fit_preview([640, 320], [300., 300.]);
264	assert_eq!(landscape.size, [300., 150.]);
265	assert_eq!(landscape.offset, [0., 75.]);
266	let portrait = fit_preview([64, 128], [400., 200.]);
267	assert_eq!(portrait.size, [100., 200.]);
268	assert_eq!(portrait.offset, [150., 0.]);
269	assert_eq!(fit_preview([0, 128], [400., 200.]).size, [0., 0.]);
270	assert_eq!(fit_preview([128, 128], [f32::NAN, 200.]).size, [0., 0.]);
271	}
272
273	#[test]
274	fn nearest_non_square_uses_source_height_for_rows() {
275	let src = [255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255];
276	let out = nearest_stretch(&src, 1, 3, 2, 6);
277	for y in 0..6 {
278	assert_eq!(&out[y * 8..y * 8 + 4], &src[(y / 2) * 4..(y / 2) * 4 + 4]);
279	}
280	}
281
282	#[test]
283	fn nearest_stretch_fills_the_box() {
284	let src = [
285	255, 0, 0, 255, 0, 0, 255, 255, // 2x1
286	];
287	let out = nearest_stretch(&src, 2, 1, 4, 3);
288	assert_eq!(out.len(), 4 * 3 * 4);
289	for y in 0..3 {
290	for x in 0..4 {
291	let pixel = &out[(y * 4 + x) * 4..(y * 4 + x) * 4 + 4];
292	if x < 2 {
293	assert_eq!(pixel, &[255, 0, 0, 255]);
294	} else {
295	assert_eq!(pixel, &[0, 0, 255, 255]);
296	}
297	}
298	}
299	}
300
301	#[test]
302	fn pass_progress_cancellation_and_last_image_are_preserved() {
303	let mut ui = RenderUiState::idle();
304	ui.apply(RenderEvent::Pass {
305	index: 1,
306	total: 6,
307	label: "detail".into(),
308	image: Some(ImageBuf {
309	width: 1,
310	height: 1,
311	rgba: vec![1, 2, 3, 255],
312	}),
313	});
314	ui.apply(RenderEvent::Step {
315	index: 2,
316	total: 6,
317	label: "target".into(),
318	});
319	assert_eq!(ui.preview.as_ref().unwrap().rgba, vec![1, 2, 3, 255]);
320	assert_eq!(ui.preview_revision, 1);
321	assert_eq!(ui.preview_label, "detail");
322	assert_eq!(ui.progress.label, "target");
323	ui.apply(RenderEvent::Cancelled);
324	assert!(!ui.running);
325	assert_eq!(ui.progress.completed, 2);
326	assert_eq!(ui.preview_revision, 1);
327	assert_eq!(ui.preview.as_ref().unwrap().rgba, vec![1, 2, 3, 255]);
328	}
329	}