mod error;
mod options;
mod pass;
mod target;
mod viewport;
pub use error::EmbedError;
pub use options::{EmbedAlpha, EmbedColorSpace, EmbedOptions};
pub use pass::RecordReport;
pub use viewport::{EmbedLoad, EmbedViewport, PhysicalRect};
use super::{
gpu::{self, Gpu},
pipeline::{PipelineSet, Target},
Renderer, RendererStats,
};
use std::sync::{
atomic::{AtomicU64, Ordering},
Arc, Mutex, MutexGuard, PoisonError,
};
pub struct EmbeddedRenderer {
gpu: Gpu,
options: EmbedOptions,
pass_pipelines: Arc<PipelineSet>,
texture_pipelines: Option<Arc<PipelineSet>>,
prepared: Option<pass::Prepared>,
recorded: Counters,
}
#[derive(Default)]
struct Counters {
frames: AtomicU64,
draws: AtomicU64,
}
pub(super) fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
mutex.lock().unwrap_or_else(PoisonError::into_inner)
}
impl EmbeddedRenderer {
pub fn new(
device: wgpu::Device,
queue: wgpu::Queue,
options: EmbedOptions,
) -> Result<Self, EmbedError> {
Self::with_half_float(device, queue, !cfg!(target_arch = "wasm32"), options)
}
pub fn new_with_adapter(
device: wgpu::Device,
queue: wgpu::Queue,
adapter: &wgpu::Adapter,
options: EmbedOptions,
) -> Result<Self, EmbedError> {
Self::with_half_float(device, queue, gpu::half_float(adapter), options)
}
fn with_half_float(
device: wgpu::Device,
queue: wgpu::Queue,
half_float: bool,
options: EmbedOptions,
) -> Result<Self, EmbedError> {
options.validate(device.features())?;
let gpu = Gpu::new(device, queue, half_float, Arc::default());
Self::from_gpu(gpu, options)
}
fn from_gpu(gpu: Gpu, options: EmbedOptions) -> Result<Self, EmbedError> {
options.validate(gpu.device.features())?;
let pass_pipelines = lock(&gpu.pipelines).get(pass_target(&options));
Ok(Self {
gpu,
options,
pass_pipelines,
texture_pipelines: None,
prepared: None,
recorded: Counters::default(),
})
}
pub fn create_sibling(&self, options: EmbedOptions) -> Result<Self, EmbedError> {
Self::from_gpu(self.gpu.sibling(), options)
}
pub fn options(&self) -> &EmbedOptions {
&self.options
}
pub fn set_options(&mut self, options: EmbedOptions) -> Result<(), EmbedError> {
options.validate(self.gpu.device.features())?;
if options == self.options {
return Ok(());
}
self.prepared = None;
if options.attachment_format() != self.options.attachment_format() {
self.gpu.blur = None;
self.gpu.stats.blur_target_bytes = 0;
self.texture_pipelines = None;
}
self.pass_pipelines = lock(&self.gpu.pipelines).get(pass_target(&options));
self.options = options;
Ok(())
}
pub fn notify_device_lost(&self, reason: impl Into<String>) {
*lock(&self.gpu.device_lost) = Some(reason.into());
}
pub fn is_device_lost(&self) -> bool {
self.gpu.lost().is_some()
}
pub fn release_targets(&mut self) {
self.gpu.blur = None;
self.gpu.stats.blur_target_bytes = 0;
}
pub fn stats(&self) -> RendererStats {
let mut stats = self.gpu.stats;
stats.presented_frames += self.recorded.frames.load(Ordering::Relaxed);
stats.draw_calls += self.recorded.draws.load(Ordering::Relaxed);
stats
}
pub fn clear_image_textures(&mut self) {
self.gpu.clear_image_textures();
}
pub fn material_pipeline_count(&self) -> usize {
self.gpu.material_pipeline_count()
}
pub fn take_material_errors(&mut self) -> Vec<String> {
std::mem::take(&mut self.gpu.material_errors)
}
#[doc(hidden)]
pub fn shared_pipeline_targets(&self) -> usize {
lock(&self.gpu.pipelines).len()
}
fn check_alive(&self) -> Result<(), EmbedError> {
match self.gpu.lost() {
Some(message) => Err(EmbedError::DeviceLost(message)),
None => Ok(()),
}
}
}
impl Renderer {
pub fn create_embedded(&self, options: EmbedOptions) -> Result<EmbeddedRenderer, EmbedError> {
EmbeddedRenderer::from_gpu(self.gpu.sibling(), options)
}
}
fn pass_target(options: &EmbedOptions) -> Target {
Target {
format: options.attachment_format(),
samples: options.sample_count,
depth: options.depth_format,
}
}