use super::device::{MetalDevice, MetalError};
use super::enums::*;
use super::renderer::{MetalRenderStats, MetalRenderer};
use super::target::MetalRenderTarget;
use crate::cameras::Camera;
use crate::scene::Scene;
#[derive(Clone, Copy, Debug)]
pub struct MetalHeadlessConfig {
pub width: u32,
pub height: u32,
pub sample_count: u32,
pub color_format: NSUInteger,
}
impl Default for MetalHeadlessConfig {
fn default() -> Self {
Self {
width: 1024,
height: 1024,
sample_count: 1,
color_format: pixel_format::RGBA8_UNORM_SRGB,
}
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct MetalHeadlessBuilder {
config: MetalHeadlessConfig,
}
impl MetalHeadlessBuilder {
pub fn size(mut self, width: u32, height: u32) -> Self {
self.config.width = width;
self.config.height = height;
self
}
pub fn msaa(mut self, sample_count: u32) -> Self {
self.config.sample_count = sample_count.max(1);
self
}
pub fn color_format(mut self, format: NSUInteger) -> Self {
self.config.color_format = format;
self
}
pub fn build(self) -> Result<MetalHeadlessRenderer, MetalError> {
MetalHeadlessRenderer::new(self.config)
}
}
pub struct MetalHeadlessRenderer {
device: MetalDevice,
renderer: MetalRenderer,
target: MetalRenderTarget,
config: MetalHeadlessConfig,
last_stats: MetalRenderStats,
}
impl MetalHeadlessRenderer {
pub fn builder() -> MetalHeadlessBuilder {
MetalHeadlessBuilder::default()
}
pub fn new(config: MetalHeadlessConfig) -> Result<Self, MetalError> {
let device = MetalDevice::new()?;
let renderer = MetalRenderer::with_device(device.clone())?;
let target = MetalRenderTarget::new(
&device,
config.width,
config.height,
config.color_format,
config.sample_count,
)?;
Ok(Self {
device,
renderer,
target,
config,
last_stats: MetalRenderStats::default(),
})
}
pub fn render_to_rgba(
&mut self,
scene: &mut Scene,
camera: &dyn Camera,
) -> Result<Vec<u8>, MetalError> {
self.last_stats = self
.renderer
.render(scene, camera, &self.target.attachments())?;
self.target.read_rgba(&self.device)
}
pub fn render(
&mut self,
scene: &mut Scene,
camera: &dyn Camera,
) -> Result<MetalRenderStats, MetalError> {
self.last_stats = self
.renderer
.render(scene, camera, &self.target.attachments())?;
Ok(self.last_stats)
}
pub fn resize(&mut self, width: u32, height: u32) -> Result<(), MetalError> {
if (width.max(1), height.max(1)) == self.target.size() {
return Ok(());
}
self.config.width = width.max(1);
self.config.height = height.max(1);
self.target = MetalRenderTarget::new(
&self.device,
self.config.width,
self.config.height,
self.config.color_format,
self.config.sample_count,
)?;
Ok(())
}
pub fn size(&self) -> (u32, u32) {
self.target.size()
}
pub fn stats(&self) -> MetalRenderStats {
self.last_stats
}
pub fn device(&self) -> &MetalDevice {
&self.device
}
pub fn renderer_mut(&mut self) -> &mut MetalRenderer {
&mut self.renderer
}
pub fn target(&self) -> &MetalRenderTarget {
&self.target
}
}
impl std::fmt::Debug for MetalHeadlessRenderer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetalHeadlessRenderer")
.field("device", &self.device.name())
.field("size", &self.target.size())
.field("sample_count", &self.target.sample_count())
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builder_carries_its_settings() {
let b = MetalHeadlessBuilder::default()
.size(320, 240)
.msaa(4)
.color_format(pixel_format::BGRA8_UNORM_SRGB);
assert_eq!(b.config.width, 320);
assert_eq!(b.config.height, 240);
assert_eq!(b.config.sample_count, 4);
assert_eq!(b.config.color_format, pixel_format::BGRA8_UNORM_SRGB);
}
#[test]
fn msaa_never_goes_below_one() {
assert_eq!(
MetalHeadlessBuilder::default().msaa(0).config.sample_count,
1
);
}
}