use anyrender::{
AntiAliasing, PaintScene, RegisterResourceErrorKind, RenderContext, ResourceId, WindowHandle,
WindowRenderer,
};
use debug_timer::debug_timer;
use futures_channel::oneshot;
use peniko::Color;
use std::future::Future;
use std::sync::Arc;
use vello_gpu::{
RenderOptions, RenderSize, RenderTarget, RenderTargetConfig, Renderer as VelloGpuRenderer,
Resources, Scene as VelloGpuScene,
};
use wgpu::{
CommandEncoderDescriptor, CompositeAlphaMode, Features, PresentMode, Texture, TextureFormat,
TextureView, TextureViewDescriptor,
};
use wgpu_context::{DeviceHandle, SurfaceRenderer, SurfaceRendererConfiguration, WGPUContext};
use super::scene::{ExternalTextures, ImageManager, VelloGpuScenePainter};
use crate::common::{ImageCache, VelloGpuRendererOptions};
#[cfg(target_arch = "wasm32")]
fn spawn_init<F: Future<Output = ()> + 'static>(f: F) {
wasm_bindgen_futures::spawn_local(f);
}
#[cfg(not(target_arch = "wasm32"))]
fn spawn_init<F: Future<Output = ()>>(f: F) {
pollster::block_on(f);
}
struct ActiveRenderState {
renderer: VelloGpuRenderer,
resources: Resources,
depth_texture_view: TextureView,
texture_bindings: ExternalTextures,
render_surface: SurfaceRenderer<'static>,
}
struct InitOutput {
active: ActiveRenderState,
}
#[allow(clippy::large_enum_variant)]
enum RenderState {
Suspended,
Pending {
receiver: oneshot::Receiver<InitOutput>,
},
Active(ActiveRenderState),
}
pub struct VelloGpuWindowRenderer {
render_state: RenderState,
window_handle: Option<Arc<dyn WindowHandle>>,
wgpu_context: WGPUContext,
scene: VelloGpuScene,
config: VelloGpuRendererOptions,
cached_images: ImageCache,
}
impl VelloGpuWindowRenderer {
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Self::with_options(VelloGpuRendererOptions::default())
}
pub fn with_options(config: impl Into<VelloGpuRendererOptions>) -> Self {
let config = config.into();
let render_settings = config.render_settings.clone();
let wgpu_context = build_wgpu_context(&config);
Self {
render_state: RenderState::Suspended,
config,
wgpu_context,
window_handle: None,
scene: VelloGpuScene::new_with(0, 0, render_settings.level()),
cached_images: ImageCache::default(),
}
}
pub fn current_device_handle(&self) -> Option<&DeviceHandle> {
match &self.render_state {
RenderState::Active(active) => Some(&active.render_surface.device_handle),
_ => None,
}
}
}
fn build_wgpu_context(config: &VelloGpuRendererOptions) -> WGPUContext {
let features =
config.features.unwrap_or_default() | Features::CLEAR_TEXTURE | Features::PIPELINE_CACHE;
WGPUContext::with_features_and_limits(Some(features), config.limits.clone())
}
#[cfg(target_os = "android")]
const DEFAULT_TEXTURE_FORMAT: TextureFormat = TextureFormat::Rgba8Unorm;
#[cfg(not(target_os = "android"))]
const DEFAULT_TEXTURE_FORMAT: TextureFormat = TextureFormat::Bgra8Unorm;
impl RenderContext for VelloGpuWindowRenderer {
fn renderer_specific_context(&self) -> Option<Box<dyn std::any::Any>> {
match &self.render_state {
RenderState::Active(state) => {
Some(Box::new(state.render_surface.device_handle.clone()) as _)
}
RenderState::Suspended => None,
RenderState::Pending { .. } => None,
}
}
fn try_register_custom_resource(
&mut self,
resource: Box<dyn std::any::Any>,
) -> Result<anyrender::ResourceId, anyrender::RegisterResourceError> {
let RenderState::Active(state) = &mut self.render_state else {
return Err(RegisterResourceErrorKind::Other.into());
};
match resource.downcast::<Texture>() {
Ok(texture) => {
let id = ResourceId::new();
let texture_view = texture.create_view(&TextureViewDescriptor::default());
state.texture_bindings.insert(id, texture_view);
Ok(id)
}
Err(resource) => {
if let Ok(texture_view) = resource.downcast::<TextureView>() {
let id = ResourceId::new();
state.texture_bindings.insert(id, *texture_view);
Ok(id)
}
else {
Err(anyrender::RegisterResourceErrorKind::UnsupportedResourceKind.into())
}
}
}
}
fn unregister_resource(&mut self, resource_id: ResourceId) {
let RenderState::Active(state) = &mut self.render_state else {
return;
};
state.texture_bindings.remove(resource_id);
}
}
impl WindowRenderer for VelloGpuWindowRenderer {
type ScenePainter<'a>
= VelloGpuScenePainter<'a>
where
Self: 'a;
fn is_active(&self) -> bool {
matches!(self.render_state, RenderState::Active { .. })
}
fn is_pending(&self) -> bool {
matches!(self.render_state, RenderState::Pending { .. })
}
fn resume<F: FnOnce() + 'static>(
&mut self,
window_handle: Arc<dyn WindowHandle>,
width: u32,
height: u32,
on_ready: F,
) {
if !matches!(self.render_state, RenderState::Suspended) {
return;
}
let (sender, receiver) = oneshot::channel();
self.render_state = RenderState::Pending { receiver };
self.window_handle = Some(window_handle.clone());
let render_settings = self.config.render_settings.clone();
self.scene = VelloGpuScene::new_with(width as u16, height as u16, render_settings.level());
let surface = self
.wgpu_context
.create_surface(window_handle)
.expect("Error creating surface");
let instance = self.wgpu_context.instance.clone();
let extra_features = self.wgpu_context.extra_features();
let override_limits = self.wgpu_context.override_limits();
let mut composite_alpha_mode = match self.config.composite_alpha_mode {
anyrender::CompositeAlphaMode::Auto => CompositeAlphaMode::Auto,
anyrender::CompositeAlphaMode::Opaque => CompositeAlphaMode::Opaque,
anyrender::CompositeAlphaMode::Transparent => {
#[cfg(target_vendor = "apple")]
{
CompositeAlphaMode::PostMultiplied
}
#[cfg(not(target_vendor = "apple"))]
{
CompositeAlphaMode::PreMultiplied
}
}
};
let desired_maximum_frame_latency = self.config.desired_maximum_frame_latency;
let existing_device_handle = self
.wgpu_context
.find_compatible_device_handle(Some(&surface));
spawn_init(async move {
let device_handle = match existing_device_handle {
Some(device_handle) => device_handle,
None => DeviceHandle::new_from_compatible_surface(
instance,
Some(&surface),
extra_features,
override_limits,
)
.await
.expect("Error creating DeviceHandle"),
};
let adapter = &device_handle.adapter;
let caps = surface.get_capabilities(adapter);
let mut alpha_modes = caps.alpha_modes;
if !alpha_modes.contains(&composite_alpha_mode) {
alpha_modes.sort_unstable_by(
|first: &CompositeAlphaMode, second: &CompositeAlphaMode| {
let first_num = match *first {
CompositeAlphaMode::PreMultiplied => 0,
CompositeAlphaMode::PostMultiplied => 1,
CompositeAlphaMode::Opaque
| CompositeAlphaMode::Inherit
| CompositeAlphaMode::Auto => 2,
};
let second_num = match *second {
CompositeAlphaMode::PreMultiplied => 0,
CompositeAlphaMode::PostMultiplied => 1,
CompositeAlphaMode::Opaque
| CompositeAlphaMode::Inherit
| CompositeAlphaMode::Auto => 2,
};
first_num.cmp(&second_num)
},
);
composite_alpha_mode = alpha_modes
.first()
.copied()
.expect("Surface didn't report any alpha modes");
}
#[cfg(not(target_vendor = "apple"))]
let intermediate_texture = (composite_alpha_mode == CompositeAlphaMode::PostMultiplied)
.then(|| {
use wgpu::TextureUsages;
use wgpu_context::{AlphaConversion, TextureConfiguration};
TextureConfiguration {
usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING,
format: DEFAULT_TEXTURE_FORMAT,
alpha_conversion: Some(AlphaConversion::Unpremultiply),
}
});
#[cfg(target_vendor = "apple")]
let intermediate_texture = None;
let render_surface = SurfaceRenderer::new(
surface,
SurfaceRendererConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
formats: vec![DEFAULT_TEXTURE_FORMAT],
width,
height,
present_mode: PresentMode::AutoVsync,
desired_maximum_frame_latency,
alpha_mode: composite_alpha_mode,
view_formats: vec![],
},
intermediate_texture,
device_handle,
)
.expect("Error creating SurfaceRenderer");
let (renderer, resources) = VelloGpuRenderer::new_with(
render_surface.device(),
render_surface.queue(),
&RenderTargetConfig {
format: DEFAULT_TEXTURE_FORMAT,
width: width as u16,
height: height as u16,
},
render_settings,
);
let depth_texture_view = renderer.create_depth_texture_view(&RenderSize {
width: width as u16,
height: height as u16,
});
let _ = sender.send(InitOutput {
active: ActiveRenderState {
renderer,
resources,
depth_texture_view,
render_surface,
texture_bindings: ExternalTextures::default(),
},
});
on_ready();
});
}
fn complete_resume(&mut self) -> bool {
match &mut self.render_state {
RenderState::Active { .. } => true,
RenderState::Suspended => false,
RenderState::Pending { receiver } => match receiver.try_recv() {
Ok(Some(InitOutput { active })) => {
self.cached_images.clear();
let max = active
.render_surface
.device()
.limits()
.max_texture_dimension_2d
.min(u16::MAX as u32) as u16;
self.cached_images.set_max_image_size((max, max));
let device_handle = active.render_surface.device_handle.clone();
self.wgpu_context.device_pool.push(device_handle);
self.render_state = RenderState::Active(active);
true
}
_ => false,
},
}
}
fn suspend(&mut self) {
self.render_state = RenderState::Suspended;
self.cached_images.clear();
}
fn set_size(&mut self, width: u32, height: u32) {
if width as u16 != self.scene.width() || height as u16 != self.scene.height() {
self.scene = VelloGpuScene::new_with(
width as u16,
height as u16,
self.config.render_settings.level(),
);
if let RenderState::Active(active) = &mut self.render_state {
active.render_surface.resize(width, height);
active.depth_texture_view =
active.renderer.create_depth_texture_view(&RenderSize {
width: width as u16,
height: height as u16,
});
};
}
}
fn render<F: FnOnce(&mut Self::ScenePainter<'_>)>(&mut self, draw_fn: F) {
let RenderState::Active(state) = &mut self.render_state else {
return;
};
let render_surface = &mut state.render_surface;
debug_timer!(timer, feature = "log_frame_times");
let mut encoder =
render_surface
.device()
.create_command_encoder(&CommandEncoderDescriptor {
label: Some("Render scene"),
});
let image_manager = ImageManager {
resources: &mut state.resources,
device: render_surface.device(),
queue: render_surface.queue(),
cache: &mut self.cached_images,
texture_bindings: &mut state.texture_bindings,
};
let mut scene_painter = VelloGpuScenePainter {
scene: &mut self.scene,
layer_stack: Vec::new(),
image_manager,
device_handle: &render_surface.device_handle,
glyph_caching: self.config.glyph_caching,
};
if self.config.base_color != Color::TRANSPARENT {
scene_painter.fill(
peniko::Fill::NonZero,
kurbo::Affine::IDENTITY,
self.config.base_color,
None,
&kurbo::Rect::new(
0.,
0.,
render_surface.config.width as f64,
render_surface.config.height as f64,
),
AntiAliasing::Enabled,
);
}
draw_fn(&mut scene_painter);
timer.record_time("cmd");
let Ok(texture_view) = render_surface.target_texture_view() else {
render_surface.clear_surface_texture();
self.scene.reset();
ImageManager::new(
&mut state.resources,
render_surface.device(),
render_surface.queue(),
&mut self.cached_images,
&mut state.texture_bindings,
)
.finish_frame();
render_surface.queue().submit([encoder.finish()]);
return;
};
state
.renderer
.render(
&self.scene,
&mut state.resources,
&mut encoder,
RenderTarget {
view: &texture_view,
depth_view: Some(&state.depth_texture_view),
},
state.texture_bindings.bindings(),
RenderOptions::default(),
)
.expect("failed to render to texture");
ImageManager::new(
&mut state.resources,
render_surface.device(),
render_surface.queue(),
&mut self.cached_images,
&mut state.texture_bindings,
)
.finish_frame();
render_surface.queue().submit([encoder.finish()]);
timer.record_time("render");
drop(texture_view);
if render_surface.maybe_blit_and_present().is_err() {
self.scene.reset();
return;
}
timer.record_time("present");
render_surface
.device()
.poll(wgpu::PollType::wait_indefinitely())
.unwrap();
timer.record_time("wait");
timer.print_times("vello_gpu: ");
self.scene.reset();
}
}