1use crate::core::{Color, Rectangle, Size};
2use crate::graphics::compositor::{self, Information};
3use crate::graphics::damage;
4use crate::graphics::error::{self, Error};
5use crate::graphics::{self, Viewport};
6use crate::{Layer, Renderer, Settings};
7
8use std::collections::VecDeque;
9use std::num::NonZeroU32;
10
11#[allow(missing_debug_implementations)]
12pub struct Compositor {
13 context: softbuffer::Context<Box<dyn compositor::Window>>,
14 settings: Settings,
15}
16
17#[allow(missing_debug_implementations)]
18pub struct Surface {
19 window: softbuffer::Surface<
20 Box<dyn compositor::Window>,
21 Box<dyn compositor::Window>,
22 >,
23 clip_mask: tiny_skia::Mask,
24 layer_stack: VecDeque<Vec<Layer>>,
25 background_color: Color,
26 max_age: u8,
27}
28
29impl crate::graphics::Compositor for Compositor {
30 type Renderer = Renderer;
31 type Surface = Surface;
32
33 async fn with_backend<W: compositor::Window>(
34 settings: graphics::Settings,
35 compatible_window: W,
36 backend: Option<&str>,
37 ) -> Result<Self, Error> {
38 match backend {
39 None | Some("tiny-skia") | Some("tiny_skia") => {
40 Ok(new(settings.into(), compatible_window))
41 }
42 Some(backend) => Err(Error::GraphicsAdapterNotFound {
43 backend: "tiny-skia",
44 reason: error::Reason::DidNotMatch {
45 preferred_backend: backend.to_owned(),
46 },
47 }),
48 }
49 }
50
51 fn create_renderer(&self) -> Self::Renderer {
52 Renderer::new(
53 self.settings.default_font,
54 self.settings.default_text_size,
55 )
56 }
57
58 fn create_surface<W: compositor::Window + Clone>(
59 &mut self,
60 window: W,
61 width: u32,
62 height: u32,
63 ) -> Self::Surface {
64 let window = softbuffer::Surface::new(
65 &self.context,
66 Box::new(window.clone()) as _,
67 )
68 .expect("Create softbuffer surface for window");
69
70 let mut surface = Surface {
71 window,
72 clip_mask: tiny_skia::Mask::new(width, height)
73 .expect("Create clip mask"),
74 layer_stack: VecDeque::new(),
75 background_color: Color::BLACK,
76 max_age: 0,
77 };
78
79 self.configure_surface(&mut surface, width, height);
80
81 surface
82 }
83
84 fn configure_surface(
85 &mut self,
86 surface: &mut Self::Surface,
87 width: u32,
88 height: u32,
89 ) {
90 surface
91 .window
92 .resize(
93 NonZeroU32::new(width).expect("Non-zero width"),
94 NonZeroU32::new(height).expect("Non-zero height"),
95 )
96 .expect("Resize surface");
97
98 surface.clip_mask =
99 tiny_skia::Mask::new(width, height).expect("Create clip mask");
100 surface.layer_stack.clear();
101 }
102
103 fn fetch_information(&self) -> Information {
104 Information {
105 adapter: String::from("CPU"),
106 backend: String::from("tiny-skia"),
107 }
108 }
109
110 fn present(
111 &mut self,
112 renderer: &mut Self::Renderer,
113 surface: &mut Self::Surface,
114 viewport: &Viewport,
115 background_color: Color,
116 on_pre_present: impl FnOnce(),
117 ) -> Result<(), compositor::SurfaceError> {
118 present(
119 renderer,
120 surface,
121 viewport,
122 background_color,
123 on_pre_present,
124 )
125 }
126
127 fn screenshot(
128 &mut self,
129 renderer: &mut Self::Renderer,
130 viewport: &Viewport,
131 background_color: Color,
132 ) -> Vec<u8> {
133 screenshot(renderer, viewport, background_color)
134 }
135}
136
137pub fn new<W: compositor::Window>(
138 settings: Settings,
139 compatible_window: W,
140) -> Compositor {
141 #[allow(unsafe_code)]
142 let context = softbuffer::Context::new(Box::new(compatible_window) as _)
143 .expect("Create softbuffer context");
144
145 Compositor { context, settings }
146}
147
148pub fn present(
149 renderer: &mut Renderer,
150 surface: &mut Surface,
151 viewport: &Viewport,
152 background_color: Color,
153 on_pre_present: impl FnOnce(),
154) -> Result<(), compositor::SurfaceError> {
155 let physical_size = viewport.physical_size();
156
157 let mut buffer = surface
158 .window
159 .buffer_mut()
160 .map_err(|_| compositor::SurfaceError::Lost)?;
161
162 let last_layers = {
163 let age = buffer.age();
164
165 surface.max_age = surface.max_age.max(age);
166 surface.layer_stack.truncate(surface.max_age as usize);
167
168 if age > 0 {
169 surface.layer_stack.get(age as usize - 1)
170 } else {
171 None
172 }
173 };
174
175 let damage = last_layers
176 .and_then(|last_layers| {
177 (surface.background_color == background_color).then(|| {
178 damage::diff(
179 last_layers,
180 renderer.layers(),
181 |layer| vec![layer.bounds],
182 Layer::damage,
183 )
184 })
185 })
186 .unwrap_or_else(|| vec![Rectangle::with_size(viewport.logical_size())]);
187
188 if damage.is_empty() {
189 return Ok(());
190 }
191
192 surface.layer_stack.push_front(renderer.layers().to_vec());
193 surface.background_color = background_color;
194
195 let damage =
196 damage::group(damage, Rectangle::with_size(viewport.logical_size()));
197
198 let mut pixels = tiny_skia::PixmapMut::from_bytes(
199 bytemuck::cast_slice_mut(&mut buffer),
200 physical_size.width,
201 physical_size.height,
202 )
203 .expect("Create pixel map");
204
205 renderer.draw(
206 &mut pixels,
207 &mut surface.clip_mask,
208 viewport,
209 &damage,
210 background_color,
211 );
212
213 on_pre_present();
214 buffer.present().map_err(|_| compositor::SurfaceError::Lost)
215}
216
217pub fn screenshot(
218 renderer: &mut Renderer,
219 viewport: &Viewport,
220 background_color: Color,
221) -> Vec<u8> {
222 let size = viewport.physical_size();
223
224 let mut offscreen_buffer: Vec<u32> =
225 vec![0; size.width as usize * size.height as usize];
226
227 let mut clip_mask = tiny_skia::Mask::new(size.width, size.height)
228 .expect("Create clip mask");
229
230 renderer.draw(
231 &mut tiny_skia::PixmapMut::from_bytes(
232 bytemuck::cast_slice_mut(&mut offscreen_buffer),
233 size.width,
234 size.height,
235 )
236 .expect("Create offscreen pixel map"),
237 &mut clip_mask,
238 viewport,
239 &[Rectangle::with_size(Size::new(
240 size.width as f32,
241 size.height as f32,
242 ))],
243 background_color,
244 );
245
246 offscreen_buffer.iter().fold(
247 Vec::with_capacity(offscreen_buffer.len() * 4),
248 |mut acc, pixel| {
249 const A_MASK: u32 = 0xFF_00_00_00;
250 const R_MASK: u32 = 0x00_FF_00_00;
251 const G_MASK: u32 = 0x00_00_FF_00;
252 const B_MASK: u32 = 0x00_00_00_FF;
253
254 let a = ((A_MASK & pixel) >> 24) as u8;
255 let r = ((R_MASK & pixel) >> 16) as u8;
256 let g = ((G_MASK & pixel) >> 8) as u8;
257 let b = (B_MASK & pixel) as u8;
258
259 acc.extend([r, g, b, a]);
260 acc
261 },
262 )
263}