#![deny(clippy::unwrap_used)]
#![deny(clippy::expect_used)]
pub mod binding;
pub mod buffers;
pub mod config;
pub mod cpu_reference;
pub mod gaussian;
pub mod pipeline;
pub mod pool;
pub mod rasterizer;
pub mod sort;
pub use config::RasterConfig;
pub use cpu_reference::{CpuCamera, CpuRasterizer, CpuRenderOutput};
pub use pool::{BufferPool, PoolStats, PooledBuffer};
pub use rasterizer::{GaussianGradients, Rasterizer, RenderCamera, RenderOutput};
use thiserror::Error;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DeviceLostReason {
Destroyed,
Unknown,
DeviceDisconnected,
DriverUpdate,
OutOfMemory,
}
impl std::fmt::Display for DeviceLostReason {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Destroyed => write!(f, "device destroyed"),
Self::Unknown => write!(f, "unknown reason"),
Self::DeviceDisconnected => write!(f, "device disconnected"),
Self::DriverUpdate => write!(f, "driver update"),
Self::OutOfMemory => write!(f, "out of memory"),
}
}
}
#[derive(Debug, Error)]
pub enum RenderError {
#[error("GPU initialization error: {0}")]
GpuInit(String),
#[error("No suitable GPU adapter found")]
AdapterNotFound,
#[error("Failed to create GPU device: {0}")]
DeviceCreationFailed(String),
#[error("GPU device lost ({reason}): {message}")]
DeviceLost {
reason: DeviceLostReason,
message: String,
},
#[error("Shader compilation failed for '{shader_name}': {error}")]
ShaderCompilation {
shader_name: String,
error: String,
},
#[error("Shader validation failed for '{shader_name}': {error}")]
ShaderValidation {
shader_name: String,
error: String,
},
#[error("Buffer allocation failed for '{buffer_name}' (requested {requested_size} bytes)")]
BufferAllocation {
buffer_name: String,
requested_size: u64,
},
#[error("Buffer overflow for '{buffer_name}' (max: {max_size}, requested: {requested})")]
BufferOverflow {
buffer_name: String,
max_size: u64,
requested: u64,
},
#[error("Buffer map failed for '{buffer_name}': {error}")]
BufferMapFailed {
buffer_name: String,
error: String,
},
#[error("Rasterization error: {0}")]
Rasterize(String),
#[error("Dispatch limit exceeded for {dimension}: requested {requested}, max {max}")]
DispatchLimitExceeded {
dimension: String,
requested: u32,
max: u32,
},
#[error("Too many Gaussians: {count} exceeds maximum {max}")]
TooManyGaussians {
count: u32,
max: u32,
},
#[error("Too many tile pairs: {count} exceeds allocated {allocated}")]
TooManyTilePairs {
count: u32,
allocated: u32,
},
#[error("Invalid Gaussian at index {index}: {reason}")]
InvalidGaussian {
index: usize,
reason: String,
},
#[error("Invalid quaternion at index {index}: norm = {norm}")]
InvalidQuaternion {
index: usize,
norm: f32,
},
#[error("Invalid scale at index {index}: values = {values:?}")]
InvalidScale {
index: usize,
values: [f32; 3],
},
#[error("Mismatched buffer sizes: expected {expected}, got {actual}")]
MismatchedBufferSizes {
expected: usize,
actual: usize,
},
#[error("Image save failed: {0}")]
ImageSaveFailed(String),
#[error("Gradient readback failed: {0}")]
GradientReadbackFailed(String),
#[error("Channel receive error: {0}")]
ChannelRecvError(String),
}
impl From<wgpu::RequestDeviceError> for RenderError {
fn from(err: wgpu::RequestDeviceError) -> Self {
RenderError::DeviceCreationFailed(err.to_string())
}
}
impl From<std::sync::mpsc::RecvError> for RenderError {
fn from(err: std::sync::mpsc::RecvError) -> Self {
RenderError::ChannelRecvError(err.to_string())
}
}
impl From<image::ImageError> for RenderError {
fn from(err: image::ImageError) -> Self {
RenderError::ImageSaveFailed(err.to_string())
}
}