SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Read back only bounded allocation metadata; radiance remains in the existing
//! film and source leases. The report counts work, not certified image error.
use super::*;
use solidcraft_render::job::adaptive::SamplingReport;
fn internal(message: &str) -> JobError {
JobError::new(ErrorCode::Internal, message)
}
fn production_count(options: &JobOptions, bytes: Option<&[u8]>) -> Result<u32> {
let adaptive = options.adaptive.ok_or_else(|| internal("missing adaptive preview options"))?;
let bytes: [u8; 4] = bytes.and_then(|bytes| bytes.try_into().ok()).ok_or_else(|| internal("missing adaptive preview budget"))?;
let value = f32::from_le_bytes(bytes);
if !value.is_finite() || value.fract() != 0.0 || value < adaptive.min_samples as f32 || value > options.samples as f32 {
return Err(internal("invalid adaptive preview production count"));
}
Ok(value as u32)
}
pub(super) fn preview_divisor(options: &JobOptions, completed: u32, budget: Option<&[u8]>) -> Result<f32> {
let adaptive = options.adaptive.ok_or_else(|| internal("missing adaptive preview options"))?;
let total = options.samples.checked_add(adaptive.pilot_samples).ok_or_else(|| internal("adaptive preview target overflow"))?;
if completed == 0 || completed > total {
return Err(internal("adaptive preview iteration exceeds its target"));
}
if completed <= adaptive.pilot_samples {
return Ok(1.0);
}
let production = completed - adaptive.pilot_samples;
let target = production_count(options, budget)?;
// The shader divides a finished pixel exactly once, then leaves that mean alone.
Ok(if production < target { production as f32 } else { 1.0 })
}
pub(super) fn preview_paths(task: &Task, budgets: Option<&[u8]>) -> Result<u64> {
let options = task.options.adaptive.ok_or_else(|| internal("missing adaptive preview options"))?;
let pixels = u64::from(task.request.width) * u64::from(task.request.height);
if task.sample <= options.pilot_samples {
return Ok(pixels * u64::from(task.sample));
}
let production = task.sample - options.pilot_samples;
let mut paths = pixels * u64::from(options.pilot_samples);
let bytes = budgets.ok_or_else(|| internal("missing adaptive preview budgets"))?;
for (index, pixel) in bytes.as_chunks::<16>().0.iter().enumerate() {
if index % 4096 == 0 {
task.cancel.check()?;
}
paths += u64::from(production.min(production_count(&task.options, pixel.get(..4))?)) * u64::from(task.options.transmission_samples);
}
Ok(paths)
}
pub(super) fn report(task: &Task) -> Result<SamplingReport> {
task.cancel.check()?;
task.context.ensure_available()?;
let pixels = u64::from(task.request.width) * u64::from(task.request.height);
let mut report = SamplingReport {
pilot_samples_per_pixel: task.options.adaptive.map_or(0, |a| a.pilot_samples),
minimum_production_samples: task.options.samples,
maximum_production_samples: task.options.samples,
production_samples: pixels * u64::from(task.options.samples),
primary_path_evaluations: pixels * u64::from(task.options.samples) * u64::from(task.options.transmission_samples),
pixels_at_cap: pixels,
transmission_strata: task.options.transmission_samples,
};
let Some(options) = task.options.adaptive else { return Ok(report) };
let bytes = pixels * 16;
let context = &task.context;
let scopes = scopes(&context.device);
let mut encoder = context.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("adaptive budget report") });
encoder.copy_buffer_to_buffer(&task.accumulation, bytes * 2, &task.readback, 0, bytes);
let submission = context.queue.submit([encoder.finish()]);
checked(scopes)?;
let slice = task.readback.slice(0..bytes);
let (tx, rx) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |result| {
let _ = tx.send(result);
});
context.wait(submission, TIMEOUT)?;
rx.try_recv().map_err(gpu)?.map_err(gpu)?;
let result = (|| {
let data = slice.get_mapped_range().map_err(gpu)?;
report.maximum_production_samples = 0;
report.production_samples = 0;
report.pixels_at_cap = 0;
for (index, record) in data.as_chunks::<16>().0.iter().enumerate() {
if index % 4096 == 0 {
task.cancel.check()?;
}
let value = f32::from_le_bytes([record[0], record[1], record[2], record[3]]);
if !value.is_finite() || value.fract() != 0.0 || value < options.min_samples as f32 || value > task.options.samples as f32 {
return Err(JobError::new(ErrorCode::Internal, "invalid GPU adaptive production count"));
}
let count = value as u32;
report.minimum_production_samples = report.minimum_production_samples.min(count);
report.maximum_production_samples = report.maximum_production_samples.max(count);
report.production_samples += u64::from(count);
report.pixels_at_cap += u64::from(count == task.options.samples);
}
report.primary_path_evaluations =
pixels * u64::from(report.pilot_samples_per_pixel) + report.production_samples * u64::from(report.transmission_strata);
task.cancel.check()?;
Ok(report)
})();
task.readback.unmap();
result
}