mod adapter;
mod backdrop;
#[doc(hidden)]
pub mod blur;
mod diagnostics;
mod draw;
mod embed;
mod error;
mod frame;
mod geometry;
mod gpu;
mod init;
#[doc(hidden)]
pub mod materials;
#[doc(hidden)]
pub mod pipeline;
mod pipeline_cache;
mod surface;
#[doc(hidden)]
pub mod textures;
#[doc(hidden)]
pub mod viewport;
use gpu::Gpu;
use std::sync::Arc;
use winit::{dpi::PhysicalSize, window::Window};
pub use diagnostics::{ImageUploadMeasurement, RendererStage, RendererTiming};
pub use embed::{
EmbedAlpha, EmbedColorSpace, EmbedError, EmbedLoad, EmbedOptions, EmbedViewport,
EmbeddedRenderer, PhysicalRect, RecordReport,
};
pub use error::RenderError;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum PresentationMode {
#[default]
Vsync,
Immediate,
}
impl PresentationMode {
pub(super) fn apply(self, config: &mut wgpu::SurfaceConfiguration) {
(config.present_mode, config.desired_maximum_frame_latency) = match self {
Self::Vsync => (wgpu::PresentMode::Fifo, 2),
Self::Immediate => (wgpu::PresentMode::AutoNoVsync, 1),
};
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RenderStatus {
Presented,
Retry,
Dormant,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct RendererStats {
pub presented_frames: u64,
pub geometry_uploads: u64,
pub texture_uploads: u64,
pub geometry_upload_bytes: u64,
pub texture_creations: u64,
pub texture_reuploads: u64,
pub texture_upload_bytes: u64,
pub texture_evictions: u64,
pub draw_calls: u64,
pub image_resident_bytes_estimate: u64,
pub material_draws: u64,
pub material_pipeline_builds: u64,
pub material_pipeline_failures: u64,
pub material_uniform_bytes: u64,
pub blur_effects: u64,
pub blur_batches: u64,
pub blur_batches_reused: u64,
pub blur_passes: u64,
pub blur_pixels: u64,
pub blur_target_bytes: u64,
}
pub struct Renderer {
gpu: Gpu,
surface: wgpu::Surface<'static>,
window: Arc<Window>,
instance: wgpu::Instance,
adapter: wgpu::Adapter,
config: wgpu::SurfaceConfiguration,
presentation_mode: PresentationMode,
attachment_format: wgpu::TextureFormat,
physical_size: PhysicalSize<u32>,
pipelines: Arc<pipeline::PipelineSet>,
}
impl Renderer {
pub fn presentation_mode(&self) -> PresentationMode {
self.presentation_mode
}
pub fn set_presentation_mode(&mut self, mode: PresentationMode) {
if self.presentation_mode == mode {
return;
}
self.presentation_mode = mode;
mode.apply(&mut self.config);
if self.physical_size.width > 0 && self.physical_size.height > 0 {
self.surface.configure(&self.gpu.device, &self.config);
}
}
pub fn stats(&self) -> RendererStats {
self.gpu.stats
}
pub fn adapter_info(&self) -> wgpu::AdapterInfo {
self.adapter.get_info()
}
pub fn supported_present_modes(&self) -> Vec<wgpu::PresentMode> {
self.surface.get_capabilities(&self.adapter).present_modes
}
pub fn wait_idle(&self, timeout: std::time::Duration) -> Result<(), RenderError> {
self.gpu
.device
.poll(wgpu::PollType::Wait {
submission_index: None,
timeout: Some(timeout),
})
.map_err(|error| {
RenderError::Validation(format!("waiting for GPU completion: {error}"))
})?;
if let Some(message) = self.gpu.lost() {
return Err(RenderError::DeviceLost(message));
}
Ok(())
}
}