use super::*;
use std::fmt;
const DEFAULT_MAX_QUARANTINED_DEVICES: usize = 4;
const MAX_QUARANTINED_DEVICES: usize = 8;
pub(super) struct MultisampleTarget {
pub(super) _texture: wgpu::Texture,
pub(super) view: wgpu::TextureView,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RendererPresentMode {
Vsync,
NoVsync,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RendererSurfacePresentMode {
Immediate,
Mailbox,
Fifo,
FifoRelaxed,
}
impl RendererSurfacePresentMode {
pub(super) const fn to_wgpu(self) -> wgpu::PresentMode {
match self {
Self::Immediate => wgpu::PresentMode::Immediate,
Self::Mailbox => wgpu::PresentMode::Mailbox,
Self::Fifo => wgpu::PresentMode::Fifo,
Self::FifoRelaxed => wgpu::PresentMode::FifoRelaxed,
}
}
pub const fn is_refresh_synchronized(self) -> bool {
!matches!(self, Self::Immediate)
}
}
impl fmt::Display for RendererSurfacePresentMode {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Immediate => formatter.write_str("Immediate"),
Self::Mailbox => formatter.write_str("Mailbox"),
Self::Fifo => formatter.write_str("FIFO"),
Self::FifoRelaxed => formatter.write_str("FIFO relaxed"),
}
}
}
pub(super) fn select_surface_present_mode(
requested: RendererPresentMode,
supported: &[wgpu::PresentMode],
) -> RendererSurfacePresentMode {
match requested {
RendererPresentMode::Vsync => RendererSurfacePresentMode::Fifo,
RendererPresentMode::NoVsync => [
RendererSurfacePresentMode::Immediate,
RendererSurfacePresentMode::Mailbox,
RendererSurfacePresentMode::Fifo,
]
.into_iter()
.find(|candidate| supported.contains(&candidate.to_wgpu()))
.unwrap_or(RendererSurfacePresentMode::Fifo),
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct WgpuRendererOptions {
present_mode: RendererPresentMode,
scale_factor: f64,
max_quarantined_devices: usize,
gpu_timing: bool,
}
impl WgpuRendererOptions {
pub fn new(
present_mode: RendererPresentMode,
scale_factor: f64,
) -> Result<Self, RendererConfigurationError> {
validate_scale_factor(scale_factor)?;
Ok(Self {
present_mode,
scale_factor,
max_quarantined_devices: DEFAULT_MAX_QUARANTINED_DEVICES,
gpu_timing: false,
})
}
pub fn with_max_quarantined_devices(
mut self,
limit: usize,
) -> Result<Self, RendererConfigurationError> {
if !(1..=MAX_QUARANTINED_DEVICES).contains(&limit) {
return Err(RendererConfigurationError::InvalidRecoveryLimit { limit });
}
self.max_quarantined_devices = limit;
Ok(self)
}
pub fn present_mode(self) -> RendererPresentMode {
self.present_mode
}
pub fn scale_factor(self) -> f64 {
self.scale_factor
}
pub fn max_quarantined_devices(self) -> usize {
self.max_quarantined_devices
}
pub const fn with_gpu_timing(mut self, enabled: bool) -> Self {
self.gpu_timing = enabled;
self
}
pub const fn gpu_timing(self) -> bool {
self.gpu_timing
}
}
impl Default for WgpuRendererOptions {
fn default() -> Self {
Self {
present_mode: RendererPresentMode::Vsync,
scale_factor: 1.0,
max_quarantined_devices: DEFAULT_MAX_QUARANTINED_DEVICES,
gpu_timing: false,
}
}
}
pub(super) fn create_multisample_target(
device: &wgpu::Device,
config: &wgpu::SurfaceConfiguration,
sample_count: u32,
) -> Option<MultisampleTarget> {
if sample_count <= 1 {
return None;
}
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("sim-engine multisample target"),
size: wgpu::Extent3d {
width: config.width,
height: config.height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count,
dimension: wgpu::TextureDimension::D2,
format: config.format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
});
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
Some(MultisampleTarget {
_texture: texture,
view,
})
}
pub(super) fn validate_scale_factor(scale_factor: f64) -> Result<(), RendererConfigurationError> {
let scale_factor_f32 = scale_factor as f32;
if scale_factor_f32.is_finite()
&& crate::units::stable_physical_per_logical(scale_factor)
&& crate::units::stable_physical_per_logical(f64::from(scale_factor_f32))
{
Ok(())
} else {
Err(RendererConfigurationError::InvalidScaleFactor { scale_factor })
}
}
pub(super) fn validate_surface_dimensions(
width: u32,
height: u32,
limit: u32,
) -> Result<(), RendererConfigurationError> {
if width <= limit && height <= limit {
Ok(())
} else {
Err(RendererConfigurationError::SurfaceDimensionsTooLarge {
width,
height,
limit,
})
}
}
pub(super) fn physical_to_logical_screen(
position: PhysicalScreenPosition,
scale_factor: f32,
) -> Result<LogicalScreenPosition, RendererCoordinateError> {
let logical = position.to_vec2() / scale_factor;
(position.is_finite() && logical.is_finite())
.then_some(LogicalScreenPosition::from_vec2(logical))
.ok_or(RendererCoordinateError::NonFiniteConversion)
}
pub(super) fn logical_to_physical_screen(
position: LogicalScreenPosition,
scale_factor: f32,
) -> Result<PhysicalScreenPosition, RendererCoordinateError> {
let physical = position.to_vec2() * scale_factor;
(position.is_finite() && physical.is_finite())
.then_some(PhysicalScreenPosition::from_vec2(physical))
.ok_or(RendererCoordinateError::NonFiniteConversion)
}
impl WgpuRenderer {
pub async fn recover_device_and_surface(&mut self) -> Result<(), RendererInitError> {
if !recovery_quarantine_has_capacity(
self.retired_devices.len(),
self.max_quarantined_devices,
) {
return Err(RendererInitError::RecoveryLimitReached {
limit: self.max_quarantined_devices,
});
}
self.retired_devices.try_reserve(1).map_err(|_| {
RendererInitError::RecoveryAllocationFailed {
requested_bytes: std::mem::size_of::<RetiredDevice>(),
}
})?;
let _ = self.device.poll(wgpu::PollType::wait_indefinitely());
let adapter = self
._instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
force_fallback_adapter: false,
compatible_surface: Some(&self.surface),
apply_limit_buckets: false,
})
.await
.map_err(RendererInitError::RequestAdapter)?;
let adapter_info = adapter.get_info();
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("sim-engine recovered device"),
required_features: gpu_timing::requested_features(
adapter.features(),
self.gpu_timing_requested,
),
required_limits: wgpu::Limits::default(),
experimental_features: wgpu::ExperimentalFeatures::disabled(),
memory_hints: wgpu::MemoryHints::Performance,
trace: wgpu::Trace::Off,
})
.await
.map_err(RendererInitError::RequestDevice)?;
let dimension_limit = device.limits().max_texture_dimension_2d;
if self.config.width > dimension_limit || self.config.height > dimension_limit {
return Err(RendererInitError::SurfaceDimensionsTooLarge {
width: self.config.width,
height: self.config.height,
limit: dimension_limit,
});
}
let mut config = self
.surface
.get_default_config(&adapter, self.config.width, self.config.height)
.ok_or(RendererInitError::NoSurfaceConfig)?;
let surface_capabilities = self.surface.get_capabilities(&adapter);
let surface_present_mode = select_surface_present_mode(
self.requested_present_mode,
&surface_capabilities.present_modes,
);
config.present_mode = surface_present_mode.to_wgpu();
let sample_count = preferred_sample_count(&adapter, config.format);
let PipelineResources {
pipeline,
target_pipeline,
dynamic_pipeline,
particle_pipeline,
target_particle_pipeline,
heatmap_pipeline,
target_heatmap_pipeline,
composition_pipelines,
target_composition_pipelines,
camera_uniform_buffer,
camera_bind_group,
camera_bind_group_layout,
heatmap_uniform_buffer,
heatmap_bind_group_layout,
} = create_pipeline(&device, config.format, sample_count);
let vertex_buffer = Arc::new(create_vertex_buffer(&device, INITIAL_VERTEX_CAPACITY));
let particle_unit_buffer = create_submitted_particle_unit_buffer(&device, &queue);
let multisample_target = create_multisample_target(&device, &config, sample_count);
let image_renderer = ImageRenderer::new(&device, config.format, sample_count);
let mesh3d_renderer = Mesh3dRenderer::new(&device, config.format);
let gpu_timing =
gpu_timing::GpuTimingCollector::new(&device, &queue, self.gpu_timing_requested);
self.surface.configure(&device, &config);
self.renderer_identity = Arc::new(());
let retired_device = RetiredDevice {
_adapter: std::mem::replace(&mut self._adapter, adapter),
_device: std::mem::replace(&mut self.device, device),
_queue: std::mem::replace(&mut self.queue, queue),
};
self.retired_devices.push(retired_device);
self.adapter_info = adapter_info;
self.config = config;
self.surface_present_mode = surface_present_mode;
self.pipeline = pipeline;
self.target_pipeline = target_pipeline;
self.dynamic_pipeline = dynamic_pipeline;
self.particle_pipeline = particle_pipeline;
self.target_particle_pipeline = target_particle_pipeline;
self.heatmap_pipeline = heatmap_pipeline;
self.target_heatmap_pipeline = target_heatmap_pipeline;
self.composition_pipelines = composition_pipelines;
self.target_composition_pipelines = target_composition_pipelines;
self.image_renderer = image_renderer;
self.mesh3d_renderer = mesh3d_renderer;
self.gpu_timing = gpu_timing;
self.camera_uniform_buffer = camera_uniform_buffer;
self.camera_bind_group = camera_bind_group;
self.camera_bind_group_layout = camera_bind_group_layout;
self.heatmap_uniform_buffer = heatmap_uniform_buffer;
self.heatmap_bind_group_layout = heatmap_bind_group_layout;
self.color_map_cache = None;
self.frame_cache.clear();
self.vertex_buffer = vertex_buffer;
self.particle_unit_buffer = particle_unit_buffer;
self.vertex_capacity = INITIAL_VERTEX_CAPACITY;
self.multisample_target = multisample_target;
self.sample_count = sample_count;
self.vertices.clear();
self.draw_batches.clear();
Ok(())
}
}
pub(super) fn recovery_quarantine_has_capacity(retired: usize, limit: usize) -> bool {
retired < limit
}