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 log::info!("render {} {:?}", ix, quad);
100 unsafe {
101 *(buffer_contents.offset(ix as isize)) = shaders::GPUIQuad {
102 origin: quad.bounds.origin().to_float2(),
103 size: quad.bounds.size().to_float2(),
104 background_color: quad
105 .background
106 .unwrap_or(ColorU::transparent_black())
107 .to_uchar4(),
108 };
109 }
110 }
111 self.instances.did_modify_range(NSRange {
112 location: 0,
113 length: (quad_batch.len() * mem::size_of::<shaders::GPUIQuad>()) as u64,
114 });
115
116 ctx.command_encoder.draw_primitives_instanced(
117 metal::MTLPrimitiveType::Triangle,
118 0,
119 6,
120 quad_batch.len() as u64,
121 );
122 }
123 }
124}
125
126fn build_pipeline_state(
127 device: &metal::DeviceRef,
128 library: &metal::LibraryRef,
129 label: &str,
130 vertex_fn_name: &str,
131 fragment_fn_name: &str,
132 pixel_format: metal::MTLPixelFormat,
133) -> Result<metal::RenderPipelineState> {
134 let vertex_fn = library
135 .get_function(vertex_fn_name, None)
136 .map_err(|message| anyhow!("error locating vertex function: {}", message))?;
137 let fragment_fn = library
138 .get_function(fragment_fn_name, None)
139 .map_err(|message| anyhow!("error locating fragment function: {}", message))?;
140
141 let descriptor = metal::RenderPipelineDescriptor::new();
142 descriptor.set_label(label);
143 descriptor.set_vertex_function(Some(vertex_fn.as_ref()));
144 descriptor.set_fragment_function(Some(fragment_fn.as_ref()));
145 descriptor
146 .color_attachments()
147 .object_at(0)
148 .unwrap()
149 .set_pixel_format(pixel_format);
150
151 device
152 .new_render_pipeline_state(&descriptor)
153 .map_err(|message| anyhow!("could not create render pipeline state: {}", message))
154}
155
156mod shaders {
157 #![allow(non_upper_case_globals)]
158 #![allow(non_camel_case_types)]
159 #![allow(non_snake_case)]
160
161 use crate::{color::ColorU, geometry::vector::Vector2F};
162 use std::mem;
163
164 include!(concat!(env!("OUT_DIR"), "/shaders.rs"));
165
166 pub trait ToFloat2 {
167 fn to_float2(&self) -> vector_float2;
168 }
169
170 pub trait ToUchar4 {
171 fn to_uchar4(&self) -> vector_uchar4;
172 }
173
174 impl ToFloat2 for (f32, f32) {
175 fn to_float2(&self) -> vector_float2 {
176 unsafe {
177 let mut output = mem::transmute::<_, u32>(self.1.to_bits()) as vector_float2;
178 output <<= 32;
179 output |= mem::transmute::<_, u32>(self.0.to_bits()) as vector_float2;
180 output
181 }
182 }
183 }
184
185 impl ToFloat2 for Vector2F {
186 fn to_float2(&self) -> vector_float2 {
187 unsafe {
188 let mut output = mem::transmute::<_, u32>(self.y().to_bits()) as vector_float2;
189 output <<= 32;
190 output |= mem::transmute::<_, u32>(self.x().to_bits()) as vector_float2;
191 output
192 }
193 }
194 }
195
196 impl ToUchar4 for ColorU {
197 fn to_uchar4(&self) -> vector_uchar4 {
198 let mut vec = self.a as vector_uchar4;
199 vec <<= 8;
200 vec |= self.b as vector_uchar4;
201 vec <<= 8;
202 vec |= self.g as vector_uchar4;
203 vec <<= 8;
204 vec |= self.r as vector_uchar4;
205 vec
206 }
207 }
208}