use std::sync::Arc;
use crate::cameras::Camera;
use crate::renderer::{RenderTarget, Renderer};
use crate::scene::Scene;
#[derive(Clone, Debug)]
pub struct HeadlessConfig {
pub width: u32,
pub height: u32,
pub supersample: u32,
pub color_format: wgpu::TextureFormat,
pub high_resolution: bool,
pub taa: bool,
pub power_preference: wgpu::PowerPreference,
}
impl Default for HeadlessConfig {
fn default() -> Self {
Self {
width: 1024,
height: 1024,
supersample: 1,
color_format: wgpu::TextureFormat::Rgba8UnormSrgb,
high_resolution: true,
taa: false,
power_preference: wgpu::PowerPreference::HighPerformance,
}
}
}
#[derive(Clone, Debug, Default)]
pub struct HeadlessBuilder {
config: HeadlessConfig,
}
impl HeadlessBuilder {
pub fn size(mut self, width: u32, height: u32) -> Self {
self.config.width = width;
self.config.height = height;
self
}
pub fn supersample(mut self, factor: u32) -> Self {
self.config.supersample = factor.max(1);
self
}
pub fn color_format(mut self, format: wgpu::TextureFormat) -> Self {
self.config.color_format = format;
self
}
pub fn high_resolution(mut self, enabled: bool) -> Self {
self.config.high_resolution = enabled;
self
}
pub fn taa(mut self, enabled: bool) -> Self {
self.config.taa = enabled;
self
}
pub fn power_preference(mut self, preference: wgpu::PowerPreference) -> Self {
self.config.power_preference = preference;
self
}
pub fn build(self) -> Result<HeadlessRenderer, String> {
HeadlessRenderer::new(self.config)
}
}
pub struct HeadlessRenderer {
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
renderer: Renderer,
target: RenderTarget,
config: HeadlessConfig,
render_width: u32,
render_height: u32,
}
impl HeadlessRenderer {
pub fn builder() -> HeadlessBuilder {
HeadlessBuilder::default()
}
pub fn new(config: HeadlessConfig) -> Result<Self, String> {
let width = config.width.max(1);
let height = config.height.max(1);
let ss = config.supersample.max(1);
let render_width = width.saturating_mul(ss).max(1);
let render_height = height.saturating_mul(ss).max(1);
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::PRIMARY,
..Default::default()
});
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: config.power_preference,
compatible_surface: None,
force_fallback_adapter: false,
}))
.ok_or_else(|| "no suitable wgpu adapter for headless rendering".to_string())?;
let limits = if config.high_resolution {
wgpu::Limits::downlevel_defaults().using_resolution(adapter.limits())
} else {
wgpu::Limits::downlevel_defaults()
};
let (device, queue) = pollster::block_on(adapter.request_device(
&wgpu::DeviceDescriptor {
label: Some("threers headless device"),
required_features: wgpu::Features::empty(),
required_limits: limits,
},
None,
))
.map_err(|e| format!("wgpu request_device failed: {e:?}"))?;
let device = Arc::new(device);
let queue = Arc::new(queue);
let mut renderer = Renderer::new(
device.clone(),
queue.clone(),
config.color_format,
render_width,
render_height,
);
renderer.set_taa(config.taa);
let target = RenderTarget::new(&device, render_width, render_height, config.color_format);
Ok(Self {
device,
queue,
renderer,
target,
config,
render_width,
render_height,
})
}
pub fn renderer(&mut self) -> &mut Renderer {
&mut self.renderer
}
pub fn device(&self) -> &Arc<wgpu::Device> {
&self.device
}
pub fn queue(&self) -> &Arc<wgpu::Queue> {
&self.queue
}
pub fn set_taa(&mut self, enabled: bool) {
self.renderer.set_taa(enabled);
}
pub fn set_msaa(&mut self, samples: u32) {
self.renderer.set_msaa(samples);
}
pub fn render_size(&self) -> (u32, u32) {
(self.render_width, self.render_height)
}
pub fn config(&self) -> &HeadlessConfig {
&self.config
}
pub fn render(&mut self, scene: &mut Scene, camera: &dyn Camera) {
if self.renderer.msaa() > 1 {
let linear = self.config.color_format == wgpu::TextureFormat::Rgba16Float;
self.renderer.render(scene, camera, &self.target.color_view, linear);
} else {
self.renderer.render_to(scene, camera, &self.target);
}
}
pub fn render_to_rgba(&mut self, scene: &mut Scene, camera: &dyn Camera) -> Vec<u8> {
self.render(scene, camera);
self.read_rgba()
}
pub fn read_rgba(&self) -> Vec<u8> {
let (w, h) = (self.render_width, self.render_height);
let unpadded = w * 4;
let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
let padded = unpadded.div_ceil(align) * align;
let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("threers headless readback"),
size: (padded * h) as u64,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut enc = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("threers headless readback"),
});
enc.copy_texture_to_buffer(
wgpu::ImageCopyTexture {
texture: &self.target.color_texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
wgpu::ImageCopyBuffer {
buffer: &buffer,
layout: wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: Some(padded),
rows_per_image: Some(h),
},
},
wgpu::Extent3d {
width: w,
height: h,
depth_or_array_layers: 1,
},
);
self.queue.submit(Some(enc.finish()));
let (tx, rx) = std::sync::mpsc::channel();
buffer.slice(..).map_async(wgpu::MapMode::Read, move |r| {
let _ = tx.send(r);
});
self.device.poll(wgpu::Maintain::Wait);
let _ = rx.recv();
let data = buffer.slice(..).get_mapped_range();
let mut pixels = Vec::with_capacity((unpadded * h) as usize);
for row in data.chunks(padded as usize) {
pixels.extend_from_slice(&row[..unpadded as usize]);
}
drop(data);
buffer.unmap();
pixels
}
}