Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

5.3 KB
Raw Blame
//! 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
}