1use std::{ffi::c_void, mem};
2
3use self::shaders::ToUchar4;
4
5use super::window::RenderContext;
6use crate::{color::ColorU, scene::Layer, Scene};
7use anyhow::{anyhow, Result};
8use metal::{MTLResourceOptions, NSRange};
9use shaders::ToFloat2 as _;
10
11const SHADERS_METALLIB: &'static [u8] =
12 include_bytes!(concat!(env!("OUT_DIR"), "/shaders.metallib"));
13const INSTANCE_BUFFER_SIZE: u64 = 1024 * 1024;
14
15pub struct Renderer {
16 quad_pipeline_state: metal::RenderPipelineState,
17 quad_vertices: metal::Buffer,
18 instances: metal::Buffer,
19}
20
21impl Renderer {
22 pub fn new(device: &metal::DeviceRef, pixel_format: metal::MTLPixelFormat) -> Result<Self> {
23 let library = device
24 .new_library_with_data(SHADERS_METALLIB)
25 .map_err(|message| anyhow!("error building metal library: {}", message))?;
26
27 let quad_vertices = [
28 (0., 0.).to_float2(),
29 (1., 0.).to_float2(),
30 (0., 1.).to_float2(),
31 (0., 1.).to_float2(),
32 (1., 0.).to_float2(),
33 (1., 1.).to_float2(),
34 ];
35 let quad_vertices = device.new_buffer_with_data(
36 quad_vertices.as_ptr() as *const c_void,
37 (quad_vertices.len() * mem::size_of::<shaders::vector_float2>()) as u64,
38 MTLResourceOptions::StorageModeManaged,
39 );
40 let instances =
41 device.new_buffer(INSTANCE_BUFFER_SIZE, MTLResourceOptions::StorageModeManaged);
42
43 Ok(Self {
44 quad_pipeline_state: build_pipeline_state(
45 device,
46 &library,
47 "quad",
48 "quad_vertex",
49 "quad_fragment",
50 pixel_format,
51 )?,
52 quad_vertices,
53 instances,
54 })
55 }
56
57 pub fn render(&mut self, scene: &Scene, ctx: &RenderContext) {
58 ctx.command_encoder.set_viewport(metal::MTLViewport {
59 originX: 0.0,
60 originY: 0.0,
61 width: ctx.drawable_size.x() as f64,
62 height: ctx.drawable_size.y() as f64,
63 znear: 0.0,
64 zfar: 1.0,
65 });
66
67 for layer in scene.layers() {
68 self.render_quads(layer, ctx);
69 }
70 }
71
72 fn render_quads(&mut self, layer: &Layer, ctx: &RenderContext) {
73 ctx.command_encoder
74 .set_render_pipeline_state(&self.quad_pipeline_state);
75 ctx.command_encoder.set_vertex_buffer(
76 shaders::GPUIQuadInputIndex_GPUIQuadInputIndexVertices as u64,
77 Some(&self.quad_vertices),
78 0,
79 );
80 ctx.command_encoder.set_vertex_buffer(
81 shaders::GPUIQuadInputIndex_GPUIQuadInputIndexQuads as u64,
82 Some(&self.instances),
83 0,
84 );
85 ctx.command_encoder.set_vertex_bytes(
86 shaders::GPUIQuadInputIndex_GPUIQuadInputIndexUniforms as u64,
87 mem::size_of::<shaders::GPUIQuadUniforms>() as u64,
88 [shaders::GPUIQuadUniforms {
89 viewport_size: ctx.drawable_size.to_float2(),
90 }]
91 .as_ptr() as *const c_void,
92 );
93
94 let batch_size = self.instances.length() as usize / mem::size_of::<shaders::GPUIQuad>();
95
96 let buffer_contents = self.instances.contents() as *mut shaders::GPUIQuad;
97 for quad_batch in layer.quads().chunks(batch_size) {
98 for (ix, quad) in quad_batch.iter().enumerate() {
99 unsafe {
100 *(buffer_contents.offset(ix as isize)) = shaders::GPUIQuad {
101 origin: quad.bounds.origin().to_float2(),
102 size: quad.bounds.size().to_float2(),
103 background_color: quad
104 .background
105 .unwrap_or(ColorU::transparent_black())
106 .to_uchar4(),
107 };
108 }
109 }
110 self.instances.did_modify_range(NSRange {
111 location: 0,
112 length: (quad_batch.len() * mem::size_of::<shaders::GPUIQuad>()) as u64,
113 });
114
115 ctx.command_encoder.draw_primitives_instanced(
116 metal::MTLPrimitiveType::Triangle,
117 0,
118 6,
119 quad_batch.len() as u64,
120 );
121 }
122 }
123}
124
125fn build_pipeline_state(
126 device: &metal::DeviceRef,
127 library: &metal::LibraryRef,
128 label: &str,
129 vertex_fn_name: &str,
130 fragment_fn_name: &str,
131 pixel_format: metal::MTLPixelFormat,
132) -> Result<metal::RenderPipelineState> {
133 let vertex_fn = library
134 .get_function(vertex_fn_name, None)
135 .map_err(|message| anyhow!("error locating vertex function: {}", message))?;
136 let fragment_fn = library
137 .get_function(fragment_fn_name, None)
138 .map_err(|message| anyhow!("error locating fragment function: {}", message))?;
139
140 let descriptor = metal::RenderPipelineDescriptor::new();
141 descriptor.set_label(label);
142 descriptor.set_vertex_function(Some(vertex_fn.as_ref()));
143 descriptor.set_fragment_function(Some(fragment_fn.as_ref()));
144 descriptor
145 .color_attachments()
146 .object_at(0)
147 .unwrap()
148 .set_pixel_format(pixel_format);
149
150 device
151 .new_render_pipeline_state(&descriptor)
152 .map_err(|message| anyhow!("could not create render pipeline state: {}", message))
153}
154
155mod shaders {
156 #![allow(non_upper_case_globals)]
157 #![allow(non_camel_case_types)]
158 #![allow(non_snake_case)]
159
160 use crate::{color::ColorU, geometry::vector::Vector2F};
161 use std::mem;
162
163 include!(concat!(env!("OUT_DIR"), "/shaders.rs"));
164
165 pub trait ToFloat2 {
166 fn to_float2(&self) -> vector_float2;
167 }
168
169 pub trait ToUchar4 {
170 fn to_uchar4(&self) -> vector_uchar4;
171 }
172
173 impl ToFloat2 for (f32, f32) {
174 fn to_float2(&self) -> vector_float2 {
175 unsafe {
176 let mut output = mem::transmute::<_, u32>(self.1.to_bits()) as vector_float2;
177 output <<= 32;
178 output |= mem::transmute::<_, u32>(self.0.to_bits()) as vector_float2;
179 output
180 }
181 }
182 }
183
184 impl ToFloat2 for Vector2F {
185 fn to_float2(&self) -> vector_float2 {
186 unsafe {
187 let mut output = mem::transmute::<_, u32>(self.y().to_bits()) as vector_float2;
188 output <<= 32;
189 output |= mem::transmute::<_, u32>(self.x().to_bits()) as vector_float2;
190 output
191 }
192 }
193 }
194
195 impl ToUchar4 for ColorU {
196 fn to_uchar4(&self) -> vector_uchar4 {
197 let mut vec = self.a as vector_uchar4;
198 vec <<= 8;
199 vec |= self.b as vector_uchar4;
200 vec <<= 8;
201 vec |= self.g as vector_uchar4;
202 vec <<= 8;
203 vec |= self.r as vector_uchar4;
204 vec
205 }
206 }
207}