+2

Cargo.lock

Reviewed

··· 212 212 "bone-document", 213 213 "bone-render", 214 214 "bone-types", 215 215 + "bone-ui", 215 216 "pollster", 216 217 "thiserror 2.0.18", 217 218 "tracing", ··· 314 315 "insta", 315 316 "lyon_tessellation", 316 317 "palette", 318 318 + "png", 317 319 "ron", 318 320 "serde", 319 321 "swash",

+1

crates/bone-ui/Cargo.toml

Reviewed

··· 10 10 bone-text = { workspace = true } 11 11 lyon_tessellation = { workspace = true } 12 12 palette = { workspace = true } 13 13 + png = { workspace = true } 13 14 serde = { workspace = true } 14 15 swash = { workspace = true } 15 16 taffy = { workspace = true }

+462

crates/bone-ui/src/raster.rs

Reviewed

··· 1 1 + use std::io::Cursor; 2 2 + 3 3 + use crate::layout::{LayoutPx, LayoutRect}; 4 4 + use crate::theme::{Color, ElevationLevel, SurfaceLevel, Theme}; 5 5 + use crate::widgets::WidgetPaint; 6 6 + 7 7 + #[derive(Debug, thiserror::Error)] 8 8 + pub enum PngError { 9 9 + #[error("png encode failed: {0}")] 10 10 + Encode(String), 11 11 + #[error("png decode failed: {0}")] 12 12 + Decode(String), 13 13 + #[error("png dimensions {got_w}x{got_h} differ from expected {want_w}x{want_h}")] 14 14 + Dimensions { 15 15 + got_w: CanvasPx, 16 16 + got_h: CanvasPx, 17 17 + want_w: CanvasPx, 18 18 + want_h: CanvasPx, 19 19 + }, 20 20 + #[error("png decoded buffer size {got} differs from expected {want}")] 21 21 + Length { got: usize, want: usize }, 22 22 + } 23 23 + 24 24 + #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] 25 25 + pub struct CanvasPx(u32); 26 26 + 27 27 + impl CanvasPx { 28 28 + #[must_use] 29 29 + pub const fn new(value: u32) -> Self { 30 30 + Self(value) 31 31 + } 32 32 + 33 33 + #[must_use] 34 34 + pub const fn value(self) -> u32 { 35 35 + self.0 36 36 + } 37 37 + } 38 38 + 39 39 + impl core::fmt::Display for CanvasPx { 40 40 + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 41 41 + self.0.fmt(f) 42 42 + } 43 43 + } 44 44 + 45 45 + #[derive(Copy, Clone, Debug, PartialEq, Eq)] 46 46 + pub struct CanvasSize { 47 47 + pub width: CanvasPx, 48 48 + pub height: CanvasPx, 49 49 + } 50 50 + 51 51 + impl CanvasSize { 52 52 + #[must_use] 53 53 + pub const fn new(width: CanvasPx, height: CanvasPx) -> Self { 54 54 + Self { width, height } 55 55 + } 56 56 + 57 57 + #[must_use] 58 58 + pub const fn pixel_count(self) -> usize { 59 59 + (self.width.value() as usize) * (self.height.value() as usize) 60 60 + } 61 61 + } 62 62 + 63 63 + #[derive(Clone, Debug)] 64 64 + struct Canvas { 65 65 + size: CanvasSize, 66 66 + pixels: Vec<[f32; 4]>, 67 67 + } 68 68 + 69 69 + impl Canvas { 70 70 + fn new(size: CanvasSize, clear: Color) -> Self { 71 71 + let fill = clear.linear_rgba_premul(); 72 72 + Self { 73 73 + size, 74 74 + pixels: vec![fill; size.pixel_count()], 75 75 + } 76 76 + } 77 77 + 78 78 + fn fill_rect(&mut self, rect: LayoutRect, color: Color) { 79 79 + let bounds = self.bounds(rect); 80 80 + let src = color.linear_rgba_premul(); 81 81 + composite_band(&mut self.pixels, self.size.width.value(), bounds, src); 82 82 + } 83 83 + 84 84 + fn outline_rect(&mut self, rect: LayoutRect, color: Color, thickness: f32) { 85 85 + let outer = self.bounds(rect); 86 86 + if outer.is_empty() { 87 87 + return; 88 88 + } 89 89 + #[allow( 90 90 + clippy::cast_possible_truncation, 91 91 + clippy::cast_sign_loss, 92 92 + reason = "stroke widths are small non-negative pixel counts" 93 93 + )] 94 94 + let t = thickness.max(1.0).round() as u32; 95 95 + let h = outer.y1 - outer.y0; 96 96 + let w = outer.x1 - outer.x0; 97 97 + let top_h = t.min(h); 98 98 + let bot_h = t.min(h - top_h); 99 99 + let left_w = t.min(w); 100 100 + let right_w = t.min(w - left_w); 101 101 + let mid_y0 = outer.y0 + top_h; 102 102 + let mid_y1 = outer.y1 - bot_h; 103 103 + let src = color.linear_rgba_premul(); 104 104 + let bands = [ 105 105 + PixelBounds { 106 106 + x0: outer.x0, 107 107 + y0: outer.y0, 108 108 + x1: outer.x1, 109 109 + y1: mid_y0, 110 110 + }, 111 111 + PixelBounds { 112 112 + x0: outer.x0, 113 113 + y0: mid_y1, 114 114 + x1: outer.x1, 115 115 + y1: outer.y1, 116 116 + }, 117 117 + PixelBounds { 118 118 + x0: outer.x0, 119 119 + y0: mid_y0, 120 120 + x1: outer.x0 + left_w, 121 121 + y1: mid_y1, 122 122 + }, 123 123 + PixelBounds { 124 124 + x0: outer.x1 - right_w, 125 125 + y0: mid_y0, 126 126 + x1: outer.x1, 127 127 + y1: mid_y1, 128 128 + }, 129 129 + ]; 130 130 + bands.iter().for_each(|band| { 131 131 + composite_band(&mut self.pixels, self.size.width.value(), *band, src); 132 132 + }); 133 133 + } 134 134 + 135 135 + fn bounds(&self, rect: LayoutRect) -> PixelBounds { 136 136 + let x0 = clamp_axis(rect.min_x(), self.size.width); 137 137 + let y0 = clamp_axis(rect.min_y(), self.size.height); 138 138 + let x1 = clamp_axis(rect.max_x(), self.size.width); 139 139 + let y1 = clamp_axis(rect.max_y(), self.size.height); 140 140 + PixelBounds { 141 141 + x0, 142 142 + y0, 143 143 + x1: x1.max(x0), 144 144 + y1: y1.max(y0), 145 145 + } 146 146 + } 147 147 + 148 148 + fn into_srgb_rgba8(self) -> Vec<u8> { 149 149 + self.pixels 150 150 + .iter() 151 151 + .flat_map(|p| pixel_to_srgb_u8(*p)) 152 152 + .collect() 153 153 + } 154 154 + } 155 155 + 156 156 + #[derive(Copy, Clone, Debug, PartialEq, Eq)] 157 157 + struct PixelBounds { 158 158 + x0: u32, 159 159 + y0: u32, 160 160 + x1: u32, 161 161 + y1: u32, 162 162 + } 163 163 + 164 164 + impl PixelBounds { 165 165 + fn is_empty(self) -> bool { 166 166 + self.x0 >= self.x1 || self.y0 >= self.y1 167 167 + } 168 168 + } 169 169 + 170 170 + fn clamp_axis(value: LayoutPx, limit: CanvasPx) -> u32 { 171 171 + let raw = value.value(); 172 172 + #[allow( 173 173 + clippy::cast_precision_loss, 174 174 + reason = "canvas dimensions far below f32 precision boundary" 175 175 + )] 176 176 + let bounded = raw.clamp(0.0, limit.value() as f32); 177 177 + #[allow( 178 178 + clippy::cast_possible_truncation, 179 179 + clippy::cast_sign_loss, 180 180 + reason = "value clamped to [0, limit] before cast" 181 181 + )] 182 182 + let pixel = bounded.round() as u32; 183 183 + pixel 184 184 + } 185 185 + 186 186 + fn composite_band(pixels: &mut [[f32; 4]], stride: u32, bounds: PixelBounds, src: [f32; 4]) { 187 187 + if bounds.is_empty() { 188 188 + return; 189 189 + } 190 190 + let inv_alpha = 1.0 - src[3]; 191 191 + (bounds.y0..bounds.y1).for_each(|y| { 192 192 + let row_offset = (y as usize) * (stride as usize); 193 193 + (bounds.x0..bounds.x1).for_each(|x| { 194 194 + let idx = row_offset + (x as usize); 195 195 + let dst = pixels[idx]; 196 196 + pixels[idx] = [ 197 197 + src[0] + dst[0] * inv_alpha, 198 198 + src[1] + dst[1] * inv_alpha, 199 199 + src[2] + dst[2] * inv_alpha, 200 200 + src[3] + dst[3] * inv_alpha, 201 201 + ]; 202 202 + }); 203 203 + }); 204 204 + } 205 205 + 206 206 + fn pixel_to_srgb_u8(premul: [f32; 4]) -> [u8; 4] { 207 207 + let alpha = premul[3].clamp(0.0, 1.0); 208 208 + if alpha <= 0.0 { 209 209 + return [0, 0, 0, 0]; 210 210 + } 211 211 + let inv = 1.0 / alpha; 212 212 + let to_u8 = |c: f32| { 213 213 + let unpremul = (c * inv).clamp(0.0, 1.0); 214 214 + unit_to_byte(linear_to_srgb(unpremul)) 215 215 + }; 216 216 + [ 217 217 + to_u8(premul[0]), 218 218 + to_u8(premul[1]), 219 219 + to_u8(premul[2]), 220 220 + unit_to_byte(alpha), 221 221 + ] 222 222 + } 223 223 + 224 224 + fn unit_to_byte(unit: f32) -> u8 { 225 225 + #[allow( 226 226 + clippy::cast_possible_truncation, 227 227 + clippy::cast_sign_loss, 228 228 + reason = "value clamped to [0, 255] before cast" 229 229 + )] 230 230 + let byte = (unit * 255.0).round().clamp(0.0, 255.0) as u8; 231 231 + byte 232 232 + } 233 233 + 234 234 + fn linear_to_srgb(linear: f32) -> f32 { 235 235 + if linear <= 0.003_130_8 { 236 236 + 12.92 * linear 237 237 + } else { 238 238 + 1.055 * linear.powf(1.0 / 2.4) - 0.055 239 239 + } 240 240 + } 241 241 + 242 242 + #[must_use] 243 243 + pub fn rasterize(theme: &Theme, paint: &[WidgetPaint], size: CanvasSize) -> Vec<u8> { 244 244 + let mut canvas = Canvas::new(size, theme.colors.surface(SurfaceLevel::L0)); 245 245 + paint.iter().for_each(|p| draw(&mut canvas, p, theme)); 246 246 + canvas.into_srgb_rgba8() 247 247 + } 248 248 + 249 249 + fn draw(canvas: &mut Canvas, paint: &WidgetPaint, theme: &Theme) { 250 250 + match paint { 251 251 + WidgetPaint::Surface { 252 252 + rect, 253 253 + fill, 254 254 + border, 255 255 + .. 256 256 + } => { 257 257 + canvas.fill_rect(*rect, *fill); 258 258 + if let Some(b) = border { 259 259 + canvas.outline_rect(*rect, b.color, b.width.value_px()); 260 260 + } 261 261 + } 262 262 + WidgetPaint::Label { rect, color, .. } => { 263 263 + canvas.fill_rect(label_bar(*rect), color.with_alpha(0.55 * color.alpha())); 264 264 + } 265 265 + WidgetPaint::Mark { rect, color, .. } => { 266 266 + canvas.fill_rect(centered_square(*rect, 0.55), *color); 267 267 + } 268 268 + WidgetPaint::FocusRing { 269 269 + rect, 270 270 + color, 271 271 + thickness, 272 272 + .. 273 273 + } => { 274 274 + canvas.outline_rect(*rect, *color, thickness.value_px()); 275 275 + } 276 276 + WidgetPaint::SelectionHighlight { rect, color, .. } => { 277 277 + canvas.fill_rect(*rect, color.with_alpha(0.35 * color.alpha())); 278 278 + } 279 279 + WidgetPaint::Caret { rect, color, .. } => { 280 280 + canvas.fill_rect(caret_band(*rect), *color); 281 281 + } 282 282 + WidgetPaint::Tooltip { 283 283 + rect, elevation, .. 284 284 + } => { 285 285 + draw_elevation(canvas, theme, *rect, *elevation); 286 286 + } 287 287 + } 288 288 + } 289 289 + 290 290 + fn draw_elevation(canvas: &mut Canvas, theme: &Theme, rect: LayoutRect, elevation: ElevationLevel) { 291 291 + canvas.fill_rect(rect, theme.colors.surface(elevation.surface)); 292 292 + if let Some(b) = elevation.border { 293 293 + canvas.outline_rect(rect, b.color, b.width.value_px()); 294 294 + } 295 295 + } 296 296 + 297 297 + fn label_bar(rect: LayoutRect) -> LayoutRect { 298 298 + use crate::layout::{LayoutPos, LayoutSize}; 299 299 + let height = (rect.size.height.value() * 0.4).max(2.0); 300 300 + let pad = (rect.size.height.value() - height) * 0.5; 301 301 + let inset_x = (rect.size.width.value() * 0.1).min(8.0); 302 302 + LayoutRect::new( 303 303 + LayoutPos::new( 304 304 + LayoutPx::saturating(rect.origin.x.value() + inset_x), 305 305 + LayoutPx::saturating(rect.origin.y.value() + pad), 306 306 + ), 307 307 + LayoutSize::new( 308 308 + LayoutPx::saturating_nonneg(rect.size.width.value() - 2.0 * inset_x), 309 309 + LayoutPx::saturating_nonneg(height), 310 310 + ), 311 311 + ) 312 312 + } 313 313 + 314 314 + fn centered_square(rect: LayoutRect, factor: f32) -> LayoutRect { 315 315 + use crate::layout::{LayoutPos, LayoutSize}; 316 316 + let side = rect 317 317 + .size 318 318 + .width 319 319 + .value() 320 320 + .min(rect.size.height.value()) 321 321 + .max(0.0) 322 322 + * factor; 323 323 + let cx = rect.origin.x.value() + 0.5 * rect.size.width.value(); 324 324 + let cy = rect.origin.y.value() + 0.5 * rect.size.height.value(); 325 325 + LayoutRect::new( 326 326 + LayoutPos::new( 327 327 + LayoutPx::saturating(cx - 0.5 * side), 328 328 + LayoutPx::saturating(cy - 0.5 * side), 329 329 + ), 330 330 + LayoutSize::new( 331 331 + LayoutPx::saturating_nonneg(side), 332 332 + LayoutPx::saturating_nonneg(side), 333 333 + ), 334 334 + ) 335 335 + } 336 336 + 337 337 + fn caret_band(rect: LayoutRect) -> LayoutRect { 338 338 + use crate::layout::{LayoutPos, LayoutSize}; 339 339 + let width = rect.size.width.value().max(1.0); 340 340 + LayoutRect::new( 341 341 + LayoutPos::new(rect.origin.x, rect.origin.y), 342 342 + LayoutSize::new( 343 343 + LayoutPx::saturating_nonneg(width), 344 344 + rect.size.height, 345 345 + ), 346 346 + ) 347 347 + } 348 348 + 349 349 + pub fn encode_png(rgba: &[u8], size: CanvasSize) -> Result<Vec<u8>, PngError> { 350 350 + let expected = size.pixel_count() * 4; 351 351 + if rgba.len() != expected { 352 352 + return Err(PngError::Length { 353 353 + got: rgba.len(), 354 354 + want: expected, 355 355 + }); 356 356 + } 357 357 + let mut out = Vec::new(); 358 358 + { 359 359 + let mut encoder = png::Encoder::new(&mut out, size.width.value(), size.height.value()); 360 360 + encoder.set_color(png::ColorType::Rgba); 361 361 + encoder.set_depth(png::BitDepth::Eight); 362 362 + encoder.set_compression(png::Compression::Best); 363 363 + let mut writer = encoder 364 364 + .write_header() 365 365 + .map_err(|e| PngError::Encode(e.to_string()))?; 366 366 + writer 367 367 + .write_image_data(rgba) 368 368 + .map_err(|e| PngError::Encode(e.to_string()))?; 369 369 + } 370 370 + Ok(out) 371 371 + } 372 372 + 373 373 + pub fn decode_png(bytes: &[u8], size: CanvasSize) -> Result<Vec<u8>, PngError> { 374 374 + let decoder = png::Decoder::new(Cursor::new(bytes)); 375 375 + let mut reader = decoder 376 376 + .read_info() 377 377 + .map_err(|e| PngError::Decode(e.to_string()))?; 378 378 + let info = reader.info(); 379 379 + if info.width != size.width.value() || info.height != size.height.value() { 380 380 + return Err(PngError::Dimensions { 381 381 + got_w: CanvasPx::new(info.width), 382 382 + got_h: CanvasPx::new(info.height), 383 383 + want_w: size.width, 384 384 + want_h: size.height, 385 385 + }); 386 386 + } 387 387 + let mut buf = vec![0_u8; reader.output_buffer_size()]; 388 388 + let frame = reader 389 389 + .next_frame(&mut buf) 390 390 + .map_err(|e| PngError::Decode(e.to_string()))?; 391 391 + if frame.color_type != png::ColorType::Rgba { 392 392 + return Err(PngError::Decode(format!( 393 393 + "expected rgba color type, got {:?}", 394 394 + frame.color_type, 395 395 + ))); 396 396 + } 397 397 + let rgba = buf[..frame.buffer_size()].to_vec(); 398 398 + let expected = size.pixel_count() * 4; 399 399 + if rgba.len() != expected { 400 400 + return Err(PngError::Length { 401 401 + got: rgba.len(), 402 402 + want: expected, 403 403 + }); 404 404 + } 405 405 + Ok(rgba) 406 406 + } 407 407 + 408 408 + #[cfg(test)] 409 409 + mod tests { 410 410 + use super::{Canvas, CanvasPx, CanvasSize, rasterize}; 411 411 + use crate::gallery::{GALLERY_CANVAS, GalleryState, render}; 412 412 + use crate::theme::Theme; 413 413 + use std::sync::Arc; 414 414 + 415 415 + #[test] 416 416 + fn rasterizer_emits_canvas_sized_buffer() { 417 417 + let mut state = GalleryState::new(); 418 418 + let paint = render(Arc::new(Theme::light()), &mut state); 419 419 + let pixels = rasterize(&Theme::light(), &paint, GALLERY_CANVAS); 420 420 + assert_eq!(pixels.len(), GALLERY_CANVAS.pixel_count() * 4); 421 421 + } 422 422 + 423 423 + #[test] 424 424 + fn light_and_dark_buffers_differ() { 425 425 + let render_for = |theme: Theme| { 426 426 + let mut state = GalleryState::new(); 427 427 + let paint = render(Arc::new(theme.clone()), &mut state); 428 428 + rasterize(&theme, &paint, GALLERY_CANVAS) 429 429 + }; 430 430 + let light = render_for(Theme::light()); 431 431 + let dark = render_for(Theme::dark()); 432 432 + assert_ne!(light, dark, "themes must produce distinct rasterizations"); 433 433 + } 434 434 + 435 435 + #[test] 436 436 + fn outline_rect_corners_render_once_under_translucent_color() { 437 437 + use crate::layout::{LayoutPos, LayoutPx, LayoutRect, LayoutSize}; 438 438 + use crate::theme::Color; 439 439 + let size = CanvasSize::new(CanvasPx::new(8), CanvasPx::new(8)); 440 440 + let bg = Color::TRANSPARENT.with_alpha(1.0); 441 441 + let stroke = Theme::light().colors.focus_ring().with_alpha(0.5); 442 442 + let mut canvas = Canvas::new(size, bg); 443 443 + canvas.outline_rect( 444 444 + LayoutRect::new( 445 445 + LayoutPos::new(LayoutPx::ZERO, LayoutPx::ZERO), 446 446 + LayoutSize::new(LayoutPx::new(8.0), LayoutPx::new(8.0)), 447 447 + ), 448 448 + stroke, 449 449 + 1.0, 450 450 + ); 451 451 + let bytes = canvas.into_srgb_rgba8(); 452 452 + let pixel = |x: usize, y: usize| { 453 453 + let i = (y * size.width.value() as usize + x) * 4; 454 454 + [bytes[i], bytes[i + 1], bytes[i + 2], bytes[i + 3]] 455 455 + }; 456 456 + assert_eq!( 457 457 + pixel(0, 0), 458 458 + pixel(3, 0), 459 459 + "corner pixel must match a non-corner top-edge pixel; double-paint detected", 460 460 + ); 461 461 + } 462 462 + }