use std::borrow::Borrow;
use std::hash::{Hash, Hasher};
use std::rc::Rc;
use std::sync::{Mutex, MutexGuard};
use cranpose_render_common::bounded_lru_cache::BoundedLruCache;
use cranpose_render_common::brush_sampling::sample_brush_rgba;
use cranpose_render_common::graph_scene::RenderDiagnostics;
use cranpose_render_common::software_text_raster::{
cursor_x_for_offset_with_font, default_software_text_font, layout_text_with_font,
measure_text_with_font, rasterize_text_to_image, text_offset_for_position_with_font,
SoftwareTextFont,
};
use cranpose_render_common::text_hyphenation::HyphenationDictionaryStore;
use cranpose_ui::text::TextMotion;
use cranpose_ui::text_layout_result::TextLayoutResult;
use cranpose_ui::{TextMeasurer, TextMetrics};
use cranpose_ui_graphics::{BlendMode, ColorFilter, Point, Rect};
use crate::pipeline;
use crate::scene::{ImageDraw, RasterScene, Scene, TextDraw};
use crate::style::point_in_resolved_rounded_rect;
#[derive(Clone)]
pub struct PixelsTextResources {
font: Option<SoftwareTextFont>,
}
impl PixelsTextResources {
pub fn default_font() -> Self {
Self {
font: default_software_text_font(),
}
}
fn font(&self) -> Option<&SoftwareTextFont> {
self.font.as_ref()
}
}
impl Default for PixelsTextResources {
fn default() -> Self {
Self::default_font()
}
}
fn is_blend_mode_supported(mode: BlendMode) -> bool {
matches!(mode, BlendMode::SrcOver | BlendMode::DstOut)
}
fn fallback_char_width(font_size: f32) -> f32 {
font_size.max(1.0) * 0.55
}
fn fallback_line_height(font_size: f32) -> f32 {
font_size.max(1.0) * 1.2
}
fn fallback_text_metrics(text: &str, font_size: f32) -> TextMetrics {
let line_height = fallback_line_height(font_size);
let mut line_count = 0usize;
let mut max_chars = 0usize;
for line in text.split('\n') {
line_count += 1;
max_chars = max_chars.max(line.chars().count());
}
let line_count = line_count.max(1);
TextMetrics {
width: max_chars as f32 * fallback_char_width(font_size),
height: line_count as f32 * line_height,
line_height,
line_count,
}
}
fn fallback_cursor_x_for_byte_offset(text: &str, byte_offset: usize, font_size: f32) -> f32 {
let clamped = byte_offset.min(text.len());
let char_count = if clamped == text.len() {
text.chars().count()
} else {
text.char_indices()
.take_while(|(index, _)| *index < clamped)
.count()
};
char_count as f32 * fallback_char_width(font_size)
}
fn snap_delta_for_anchor(anchor: Point) -> Point {
Point::new(anchor.x.round() - anchor.x, anchor.y.round() - anchor.y)
}
pub struct CachedFontTextMeasurer {
text_resources: PixelsTextResources,
cache: Mutex<TextMetricsCache>,
hyphenation: HyphenationDictionaryStore,
}
#[derive(Clone)]
struct TextKey {
text: Rc<str>,
font_size_bits: u32,
style_hash: u64,
}
impl PartialEq for TextKey {
fn eq(&self, other: &Self) -> bool {
(Rc::ptr_eq(&self.text, &other.text) || *self.text == *other.text)
&& self.font_size_bits == other.font_size_bits
&& self.style_hash == other.style_hash
}
}
impl Eq for TextKey {}
impl Hash for TextKey {
fn hash<H: Hasher>(&self, state: &mut H) {
self.text.hash(state);
self.font_size_bits.hash(state);
self.style_hash.hash(state);
}
}
impl Borrow<str> for TextKey {
fn borrow(&self) -> &str {
&self.text
}
}
struct TextMetricsCache {
map: BoundedLruCache<TextKey, TextMetrics>,
}
impl TextMetricsCache {
fn new(capacity: usize) -> Self {
Self {
map: BoundedLruCache::with_capacity_at_least_one(capacity),
}
}
fn get_or_measure<F>(
&mut self,
text: &str,
font_size: f32,
style_hash: u64,
measure: F,
) -> TextMetrics
where
F: FnOnce(&str, f32) -> TextMetrics,
{
let key = TextKey {
text: Rc::from(text),
font_size_bits: font_size.to_bits(),
style_hash,
};
if let Some(metrics) = self.map.get(&key).copied() {
return metrics;
}
let metrics = measure(text, font_size);
self.map.put(key, metrics);
metrics
}
}
impl CachedFontTextMeasurer {
pub(crate) fn with_text_resources(
text_resources: PixelsTextResources,
capacity: usize,
) -> Self {
Self {
text_resources,
cache: Mutex::new(TextMetricsCache::new(capacity)),
hyphenation: HyphenationDictionaryStore::new(),
}
}
fn lock_cache(&self) -> MutexGuard<'_, TextMetricsCache> {
self.cache
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
}
#[derive(Clone, Copy)]
struct ClipBounds {
min_x: i32,
min_y: i32,
max_x: i32,
max_y: i32,
}
fn clip_rect_to_bounds(
rect: Rect,
clip: Option<Rect>,
width: u32,
height: u32,
) -> Option<ClipBounds> {
let mut min_x = rect.x;
let mut min_y = rect.y;
let mut max_x = rect.x + rect.width;
let mut max_y = rect.y + rect.height;
if let Some(clip_rect) = clip {
min_x = min_x.max(clip_rect.x);
min_y = min_y.max(clip_rect.y);
max_x = max_x.min(clip_rect.x + clip_rect.width);
max_y = max_y.min(clip_rect.y + clip_rect.height);
}
min_x = min_x.max(0.0);
min_y = min_y.max(0.0);
max_x = max_x.min(width as f32);
max_y = max_y.min(height as f32);
if max_x <= min_x || max_y <= min_y {
return None;
}
let min_x = min_x.floor() as i32;
let min_y = min_y.floor() as i32;
let max_x = max_x.ceil() as i32;
let max_y = max_y.ceil() as i32;
let min_x = min_x.clamp(0, width as i32);
let min_y = min_y.clamp(0, height as i32);
let max_x = max_x.clamp(0, width as i32);
let max_y = max_y.clamp(0, height as i32);
if min_x >= max_x || min_y >= max_y {
return None;
}
Some(ClipBounds {
min_x,
min_y,
max_x,
max_y,
})
}
fn resolve_font_size(style: &cranpose_ui::text::TextStyle) -> f32 {
style.resolve_font_size(14.0)
}
impl TextMeasurer for CachedFontTextMeasurer {
fn measure(
&self,
text: &cranpose_ui::text::AnnotatedString,
style: &cranpose_ui::text::TextStyle,
) -> TextMetrics {
let text_str = text.text.as_str();
let font_size = resolve_font_size(style);
let style_hash = style.measurement_hash();
self.lock_cache()
.get_or_measure(text_str, font_size, style_hash, |value, size| {
measure_text_impl(value, style, size, self.text_resources.font())
})
}
fn get_offset_for_position(
&self,
text: &cranpose_ui::text::AnnotatedString,
style: &cranpose_ui::text::TextStyle,
x: f32,
_y: f32,
) -> usize {
let text = text.text.as_str();
if text.is_empty() {
return 0;
}
let Some(font) = self.text_resources.font() else {
let font_size = resolve_font_size(style);
return TextLayoutResult::monospaced(
text,
fallback_char_width(font_size),
fallback_line_height(font_size),
)
.get_offset_for_x(x);
};
text_offset_for_position_with_font(text, style, x, _y, font)
}
fn get_cursor_x_for_offset(
&self,
text: &cranpose_ui::text::AnnotatedString,
style: &cranpose_ui::text::TextStyle,
offset: usize,
) -> f32 {
let text = text.text.as_str();
let clamped_offset = offset.min(text.len());
if clamped_offset == 0 {
return 0.0;
}
let Some(font) = self.text_resources.font() else {
return fallback_cursor_x_for_byte_offset(
text,
clamped_offset,
resolve_font_size(style),
);
};
cursor_x_for_offset_with_font(text, style, clamped_offset, font)
}
fn layout(
&self,
text: &cranpose_ui::text::AnnotatedString,
style: &cranpose_ui::text::TextStyle,
) -> cranpose_ui::text_layout_result::TextLayoutResult {
let font_size = resolve_font_size(style);
let Some(font) = self.text_resources.font() else {
return TextLayoutResult::monospaced(
text.text.as_str(),
fallback_char_width(font_size),
fallback_line_height(font_size),
);
};
layout_text_with_font(text.text.as_str(), style, font)
}
fn choose_auto_hyphen_break(
&self,
line: &str,
style: &cranpose_ui::text::TextStyle,
segment_start_char: usize,
measured_break_char: usize,
) -> Option<usize> {
self.hyphenation.choose_auto_hyphen_break(
line,
style,
segment_start_char,
measured_break_char,
)
}
}
fn measure_text_impl(
text: &str,
style: &cranpose_ui::text::TextStyle,
font_size: f32,
font: Option<&SoftwareTextFont>,
) -> TextMetrics {
let Some(font) = font else {
return fallback_text_metrics(text, font_size);
};
measure_text_with_font(text, style, font_size, font)
}
pub fn draw_scene(frame: &mut [u8], width: u32, height: u32, scene: &Scene) {
let text_resources = PixelsTextResources::default();
draw_scene_with_text_resources(frame, width, height, scene, &text_resources);
}
pub fn draw_scene_with_text_resources(
frame: &mut [u8],
width: u32,
height: u32,
scene: &Scene,
text_resources: &PixelsTextResources,
) {
if let Some(graph) = scene.graph.as_ref() {
let raster_scene = pipeline::build_raster_scene(graph, scene.diagnostics());
draw_raster_scene(
frame,
width,
height,
&raster_scene,
scene.diagnostics(),
text_resources,
);
} else {
clear_frame(frame);
}
}
fn clear_frame(frame: &mut [u8]) {
for chunk in frame.chunks_exact_mut(4) {
chunk.copy_from_slice(&[18, 18, 24, 255]);
}
}
fn draw_raster_scene(
frame: &mut [u8],
width: u32,
height: u32,
scene: &RasterScene,
diagnostics: &RenderDiagnostics,
text_resources: &PixelsTextResources,
) {
clear_frame(frame);
let mut ordered_items =
Vec::with_capacity(scene.shapes.len() + scene.images.len() + scene.texts.len());
for (index, shape) in scene.shapes.iter().enumerate() {
ordered_items.push((shape.z_index, RenderItem::Shape(index)));
}
for (index, image) in scene.images.iter().enumerate() {
ordered_items.push((image.z_index, RenderItem::Image(index)));
}
for (index, text) in scene.texts.iter().enumerate() {
ordered_items.push((text.z_index, RenderItem::Text(index)));
}
ordered_items.sort_by_key(|(z, _)| *z);
for (_, item) in ordered_items {
match item {
RenderItem::Shape(index) => {
draw_shape(frame, width, height, &scene.shapes[index], diagnostics);
}
RenderItem::Image(index) => {
draw_image(frame, width, height, &scene.images[index], diagnostics);
}
RenderItem::Text(index) => {
draw_text(
frame,
width,
height,
&scene.texts[index],
diagnostics,
text_resources,
);
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum RenderItem {
Shape(usize),
Image(usize),
Text(usize),
}
fn draw_shape(
frame: &mut [u8],
width: u32,
height: u32,
draw: &crate::scene::DrawShape,
diagnostics: &RenderDiagnostics,
) {
let snap_delta = draw
.snap_anchor
.map(snap_delta_for_anchor)
.unwrap_or_default();
let rect = draw.rect.translate(snap_delta.x, snap_delta.y);
let clip = draw
.clip
.map(|clip| clip.translate(snap_delta.x, snap_delta.y));
let rect = if draw.snap_to_pixel_grid {
Rect {
x: rect.x.round(),
y: rect.y.round(),
width: if rect.width > 0.0 {
rect.width.ceil().max(1.0)
} else {
rect.width
},
height: if rect.height > 0.0 {
rect.height.ceil().max(1.0)
} else {
rect.height
},
}
} else {
rect
};
let clip_bounds = match clip_rect_to_bounds(rect, clip, width, height) {
Some(bounds) => bounds,
None => return,
};
let Rect {
width: rect_width,
height: rect_height,
..
} = rect;
let resolved_shape = draw
.shape
.map(|shape| shape.resolve(rect_width, rect_height));
for py in clip_bounds.min_y..clip_bounds.max_y {
if py < 0 || py >= height as i32 {
continue;
}
for px in clip_bounds.min_x..clip_bounds.max_x {
if px < 0 || px >= width as i32 {
continue;
}
let center_x = px as f32 + 0.5;
let center_y = py as f32 + 0.5;
if let Some(ref radii) = resolved_shape {
if !point_in_resolved_rounded_rect(center_x, center_y, rect, radii) {
continue;
}
}
let sample = sample_brush_rgba(&draw.brush, rect, center_x, center_y);
let alpha = sample[3];
if alpha <= 0.0 {
continue;
}
let idx = ((py as u32 * width + px as u32) * 4) as usize;
blend_pixel(
&mut frame[idx..idx + 4],
sample,
draw.blend_mode,
diagnostics,
);
}
}
}
fn draw_image(
frame: &mut [u8],
width: u32,
height: u32,
draw: &ImageDraw,
diagnostics: &RenderDiagnostics,
) {
let snap_delta = draw
.snap_anchor
.map(snap_delta_for_anchor)
.unwrap_or_default();
let rect = draw.rect.translate(snap_delta.x, snap_delta.y);
let clip = draw
.clip
.map(|clip| clip.translate(snap_delta.x, snap_delta.y));
if draw.alpha <= 0.0 || rect.width <= 0.0 || rect.height <= 0.0 {
return;
}
let clip_bounds = match clip_rect_to_bounds(rect, clip, width, height) {
Some(bounds) => bounds,
None => return,
};
let img_width = draw.image.width();
let img_height = draw.image.height();
if img_width == 0 || img_height == 0 {
return;
}
let src_pixels = draw.image.pixels();
let (sr_x, sr_y, sr_w, sr_h) = if let Some(sr) = draw.src_rect {
(sr.x, sr.y, sr.width, sr.height)
} else {
(0.0, 0.0, img_width as f32, img_height as f32)
};
for py in clip_bounds.min_y..clip_bounds.max_y {
for px in clip_bounds.min_x..clip_bounds.max_x {
let sample_x = px as f32 + 0.5;
let sample_y = py as f32 + 0.5;
let u = ((sample_x - rect.x) / rect.width).clamp(0.0, 1.0);
let v = ((sample_y - rect.y) / rect.height).clamp(0.0, 1.0);
let mut sample = match draw.sampling {
cranpose_ui_graphics::ImageSampling::Nearest => {
let src_x = ((sr_x + u * sr_w).floor() as i32).clamp(0, img_width as i32 - 1);
let src_y = ((sr_y + v * sr_h).floor() as i32).clamp(0, img_height as i32 - 1);
sample_image_nearest(src_pixels, img_width, src_x as u32, src_y as u32)
}
cranpose_ui_graphics::ImageSampling::Linear => sample_image_linear(
src_pixels,
img_width,
img_height,
sr_x + u * sr_w - 0.5,
sr_y + v * sr_h - 0.5,
),
};
if let Some(filter) = draw.color_filter {
sample = apply_color_filter(sample, filter);
}
sample[3] *= draw.alpha.clamp(0.0, 1.0);
if sample[3] <= 0.0 {
continue;
}
let dst_idx = ((py as u32 * width + px as u32) * 4) as usize;
blend_pixel(
&mut frame[dst_idx..dst_idx + 4],
sample,
draw.blend_mode,
diagnostics,
);
}
}
}
fn sample_image_nearest(src_pixels: &[u8], img_width: u32, src_x: u32, src_y: u32) -> [f32; 4] {
let src_idx = ((src_y * img_width + src_x) * 4) as usize;
[
src_pixels[src_idx] as f32 / 255.0,
src_pixels[src_idx + 1] as f32 / 255.0,
src_pixels[src_idx + 2] as f32 / 255.0,
src_pixels[src_idx + 3] as f32 / 255.0,
]
}
fn sample_image_linear(
src_pixels: &[u8],
img_width: u32,
img_height: u32,
x: f32,
y: f32,
) -> [f32; 4] {
let x = x.clamp(0.0, img_width.saturating_sub(1) as f32);
let y = y.clamp(0.0, img_height.saturating_sub(1) as f32);
let x0 = x.floor();
let y0 = y.floor();
let tx = x - x0;
let ty = y - y0;
let x0 = (x0 as i32).clamp(0, img_width as i32 - 1) as u32;
let y0 = (y0 as i32).clamp(0, img_height as i32 - 1) as u32;
let x1 = (x0 + 1).min(img_width - 1);
let y1 = (y0 + 1).min(img_height - 1);
let top_left = sample_image_nearest(src_pixels, img_width, x0, y0);
let top_right = sample_image_nearest(src_pixels, img_width, x1, y0);
let bottom_left = sample_image_nearest(src_pixels, img_width, x0, y1);
let bottom_right = sample_image_nearest(src_pixels, img_width, x1, y1);
let mut out = [0.0; 4];
for channel in 0..4 {
let top = top_left[channel] + (top_right[channel] - top_left[channel]) * tx;
let bottom = bottom_left[channel] + (bottom_right[channel] - bottom_left[channel]) * tx;
out[channel] = top + (bottom - top) * ty;
}
out
}
fn draw_text(
frame: &mut [u8],
width: u32,
height: u32,
draw: &TextDraw,
diagnostics: &RenderDiagnostics,
text_resources: &PixelsTextResources,
) {
if draw.text.span_styles.is_empty() {
draw_text_plain(frame, width, height, draw, diagnostics, text_resources);
return;
}
draw_text_with_span_styles(frame, width, height, draw, diagnostics, text_resources);
}
fn draw_text_with_span_styles(
frame: &mut [u8],
width: u32,
height: u32,
draw: &TextDraw,
diagnostics: &RenderDiagnostics,
text_resources: &PixelsTextResources,
) {
let boundaries = draw.text.span_boundaries();
let mut cursor_x = draw.rect.x;
let mut cursor_y = draw.rect.y;
let base_line_height = draw
.text_style
.resolve_line_height(14.0, draw.font_size)
.max(1.0);
let mut current_line_height = base_line_height;
for window in boundaries.windows(2) {
let start = window[0];
let end = window[1];
if start == end {
continue;
}
let chunk = &draw.text.text[start..end];
let mut merged_span = draw.text_style.span_style.clone();
for span in &draw.text.span_styles {
if span.range.start <= start && span.range.end >= end {
merged_span = merged_span.merge(&span.item);
}
}
let mut chunk_style = draw.text_style.clone();
chunk_style.span_style = merged_span;
for part in chunk.split_inclusive('\n') {
let has_newline = part.ends_with('\n');
let content = if has_newline {
&part[..part.len().saturating_sub(1)]
} else {
part
};
if !content.is_empty() {
let segment = cranpose_ui::text::AnnotatedString::from(content);
let metrics = cranpose_ui::text::measure_text(&segment, &chunk_style);
let segment_draw = TextDraw {
node_id: draw.node_id,
rect: Rect {
x: cursor_x,
y: cursor_y,
width: metrics.width.max(1.0),
height: metrics.height.max(1.0),
},
snap_anchor: draw.snap_anchor,
text: Rc::new(segment),
color: chunk_style.resolve_text_color(draw.color),
text_style: chunk_style.clone(),
font_size: chunk_style.resolve_font_size(draw.font_size),
scale: draw.scale,
layout_options: draw.layout_options,
z_index: draw.z_index,
clip: draw.clip,
};
draw_text_plain(
frame,
width,
height,
&segment_draw,
diagnostics,
text_resources,
);
cursor_x += metrics.width;
current_line_height = current_line_height.max(metrics.line_height.max(1.0));
}
if has_newline {
cursor_x = draw.rect.x;
cursor_y += current_line_height;
current_line_height = base_line_height;
}
}
}
}
fn draw_text_plain(
frame: &mut [u8],
width: u32,
height: u32,
draw: &TextDraw,
diagnostics: &RenderDiagnostics,
text_resources: &PixelsTextResources,
) {
let text_scale = draw.scale.max(0.0);
if text_scale == 0.0 {
return;
}
let static_text_motion = draw
.text_style
.paragraph_style
.text_motion
.unwrap_or(TextMotion::Static)
== TextMotion::Static;
let snap_delta = if static_text_motion {
draw.snap_anchor
.map(snap_delta_for_anchor)
.unwrap_or_default()
} else {
Point::default()
};
let rect = draw.rect.translate(snap_delta.x, snap_delta.y);
let clip = draw
.clip
.map(|clip| clip.translate(snap_delta.x, snap_delta.y));
let raster_rect = if static_text_motion {
Rect {
x: rect.x.round(),
y: rect.y.round(),
width: if rect.width > 0.0 {
rect.width.ceil().max(1.0)
} else {
rect.width
},
height: if rect.height > 0.0 {
rect.height.ceil().max(1.0)
} else {
rect.height
},
}
} else {
rect
};
let Some(font) = text_resources.font() else {
return;
};
let Some(image) = rasterize_text_to_image(
draw.text.text.as_str(),
raster_rect,
&draw.text_style,
draw.color,
draw.font_size,
text_scale,
font,
) else {
return;
};
let blit_origin = if static_text_motion {
Point::new(raster_rect.x, raster_rect.y)
} else {
Point::new(rect.x, rect.y)
};
let blit_rect = Rect {
x: blit_origin.x,
y: blit_origin.y,
width: image.width() as f32,
height: image.height() as f32,
};
blit_rasterized_text_image(frame, width, height, blit_rect, clip, &image, diagnostics);
}
fn blit_rasterized_text_image(
frame: &mut [u8],
width: u32,
height: u32,
rect: Rect,
clip: Option<Rect>,
image: &cranpose_ui_graphics::ImageBitmap,
diagnostics: &RenderDiagnostics,
) {
if rect.width <= 0.0 || rect.height <= 0.0 {
return;
}
let clip_bounds = match clip_rect_to_bounds(rect, clip, width, height) {
Some(bounds) => bounds,
None => return,
};
let img_width = image.width();
let img_height = image.height();
if img_width == 0 || img_height == 0 {
return;
}
let src_pixels = image.pixels();
for py in clip_bounds.min_y..clip_bounds.max_y {
for px in clip_bounds.min_x..clip_bounds.max_x {
let sample_x = px as f32 + 0.5;
let sample_y = py as f32 + 0.5;
let u = ((sample_x - rect.x) / rect.width).clamp(0.0, 1.0);
let v = ((sample_y - rect.y) / rect.height).clamp(0.0, 1.0);
let src = sample_image_linear(
src_pixels,
img_width,
img_height,
u * img_width.saturating_sub(1) as f32,
v * img_height.saturating_sub(1) as f32,
);
if src[3] <= 0.0 {
continue;
}
let dst_idx = ((py as u32 * width + px as u32) * 4) as usize;
blend_pixel(
&mut frame[dst_idx..dst_idx + 4],
src,
BlendMode::SrcOver,
diagnostics,
);
}
}
}
fn blend_pixel(
dst: &mut [u8],
src: [f32; 4],
blend_mode: BlendMode,
diagnostics: &RenderDiagnostics,
) {
let resolved_blend_mode = if is_blend_mode_supported(blend_mode) {
blend_mode
} else {
if diagnostics.claim_warning_once("pixels.unsupported-blend-mode") {
log::warn!(
"Pixels renderer currently supports BlendMode::SrcOver and BlendMode::DstOut; falling back to SrcOver for unsupported modes"
);
}
BlendMode::SrcOver
};
let src_alpha = src[3].clamp(0.0, 1.0);
if src_alpha <= 0.0 {
return;
}
let dst_r = dst[0] as f32 / 255.0;
let dst_g = dst[1] as f32 / 255.0;
let dst_b = dst[2] as f32 / 255.0;
let dst_a = dst[3] as f32 / 255.0;
let (out_r, out_g, out_b, out_a) = match resolved_blend_mode {
BlendMode::DstOut => {
let keep = 1.0 - src_alpha;
(dst_r * keep, dst_g * keep, dst_b * keep, dst_a * keep)
}
BlendMode::SrcOver => (
src[0].clamp(0.0, 1.0) * src_alpha + dst_r * (1.0 - src_alpha),
src[1].clamp(0.0, 1.0) * src_alpha + dst_g * (1.0 - src_alpha),
src[2].clamp(0.0, 1.0) * src_alpha + dst_b * (1.0 - src_alpha),
src_alpha + dst_a * (1.0 - src_alpha),
),
_ => (
src[0].clamp(0.0, 1.0) * src_alpha + dst_r * (1.0 - src_alpha),
src[1].clamp(0.0, 1.0) * src_alpha + dst_g * (1.0 - src_alpha),
src[2].clamp(0.0, 1.0) * src_alpha + dst_b * (1.0 - src_alpha),
src_alpha + dst_a * (1.0 - src_alpha),
),
};
dst[0] = (out_r.clamp(0.0, 1.0) * 255.0).round() as u8;
dst[1] = (out_g.clamp(0.0, 1.0) * 255.0).round() as u8;
dst[2] = (out_b.clamp(0.0, 1.0) * 255.0).round() as u8;
dst[3] = (out_a.clamp(0.0, 1.0) * 255.0).round() as u8;
}
fn apply_color_filter(sample: [f32; 4], filter: ColorFilter) -> [f32; 4] {
filter.apply_rgba(sample)
}
#[cfg(test)]
mod tests {
use super::*;
use cranpose_render_common::brush_sampling::normalize_gradient_t;
use cranpose_render_common::graph::{
CachePolicy, DrawPrimitiveNode, IsolationReasons, LayerNode, PrimitiveEntry, PrimitiveNode,
PrimitivePhase, ProjectiveTransform, RenderGraph, RenderNode,
};
use cranpose_render_common::raster_cache::LayerRasterCacheHashes;
use cranpose_ui::Brush;
use cranpose_ui_graphics::{Color, TileMode};
fn draw_raster_scene_for_test(frame: &mut [u8], width: u32, height: u32, scene: &RasterScene) {
let diagnostics = RenderDiagnostics::new();
let text_resources = PixelsTextResources::default();
draw_raster_scene(frame, width, height, scene, &diagnostics, &text_resources);
}
#[test]
fn fallback_text_metrics_cover_empty_and_multiline_text() {
let empty = fallback_text_metrics("", 10.0);
assert_eq!(empty.line_count, 1);
assert_eq!(empty.width, 0.0);
assert_eq!(empty.height, fallback_line_height(10.0));
let multiline = fallback_text_metrics("ab\ncde", 10.0);
assert_eq!(multiline.line_count, 2);
assert_eq!(multiline.width, 3.0 * fallback_char_width(10.0));
assert_eq!(multiline.height, 2.0 * fallback_line_height(10.0));
}
#[test]
fn fallback_cursor_position_handles_non_boundary_byte_offsets() {
let text = "éx";
let width = fallback_char_width(12.0);
assert_eq!(fallback_cursor_x_for_byte_offset(text, 0, 12.0), 0.0);
assert_eq!(fallback_cursor_x_for_byte_offset(text, 1, 12.0), width);
assert_eq!(
fallback_cursor_x_for_byte_offset(text, text.len(), 12.0),
width * 2.0
);
}
fn count_non_background_pixels(frame: &[u8], width: u32, height: u32) -> usize {
count_non_background_pixels_in_band(frame, width, 0, height)
}
fn render_single_text_frame(
style: cranpose_ui::TextStyle,
color: Color,
x: f32,
) -> (u32, u32, Vec<u8>) {
let mut raster_scene = RasterScene::new();
raster_scene.push_text(
11,
Rect {
x,
y: 16.0,
width: 320.0,
height: 90.0,
},
Rc::new(cranpose_ui::text::AnnotatedString::from("MMMMMMMM")),
color,
style,
64.0,
1.0,
cranpose_ui::TextLayoutOptions::default(),
None,
);
let width = 360;
let height = 140;
let mut frame = vec![0u8; (width * height * 4) as usize];
draw_raster_scene_for_test(&mut frame, width, height, &raster_scene);
(width, height, frame)
}
fn average_ink_rgb(
frame: &[u8],
width: u32,
x_min: u32,
x_max: u32,
y_min: u32,
y_max: u32,
) -> Option<[f32; 3]> {
let mut sum_r = 0.0f32;
let mut sum_g = 0.0f32;
let mut sum_b = 0.0f32;
let mut count = 0usize;
for y in y_min..y_max {
for x in x_min..x_max {
let idx = ((y * width + x) * 4) as usize;
let px = &frame[idx..idx + 4];
if px == [18, 18, 24, 255] {
continue;
}
sum_r += px[0] as f32 / 255.0;
sum_g += px[1] as f32 / 255.0;
sum_b += px[2] as f32 / 255.0;
count += 1;
}
}
if count == 0 {
return None;
}
Some([
sum_r / count as f32,
sum_g / count as f32,
sum_b / count as f32,
])
}
fn count_non_background_pixels_in_band(
frame: &[u8],
width: u32,
y_min_inclusive: u32,
y_max_exclusive: u32,
) -> usize {
let mut count = 0usize;
for y in y_min_inclusive..y_max_exclusive {
for x in 0..width {
let idx = ((y * width + x) * 4) as usize;
let px = &frame[idx..idx + 4];
if px != [18, 18, 24, 255] {
count += 1;
}
}
}
count
}
fn ink_y_range(frame: &[u8], width: u32, height: u32) -> Option<(u32, u32)> {
let mut top = None;
let mut bottom = 0u32;
for y in 0..height {
for x in 0..width {
let idx = ((y * width + x) * 4) as usize;
if frame[idx..idx + 4] != [18, 18, 24, 255] {
top.get_or_insert(y);
bottom = y + 1;
break;
}
}
}
top.map(|t| (t, bottom))
}
#[test]
fn blend_mode_support_matrix_is_explicit() {
assert!(is_blend_mode_supported(BlendMode::SrcOver));
assert!(is_blend_mode_supported(BlendMode::DstOut));
assert!(!is_blend_mode_supported(BlendMode::Clear));
assert!(!is_blend_mode_supported(BlendMode::Multiply));
}
#[test]
fn unsupported_blend_mode_falls_back_without_abort() {
let diagnostics = RenderDiagnostics::new();
let src = [1.0, 0.0, 0.0, 0.5];
let mut unsupported = [0, 0, 255, 255];
let mut src_over = unsupported;
blend_pixel(&mut unsupported, src, BlendMode::Multiply, &diagnostics);
blend_pixel(&mut src_over, src, BlendMode::SrcOver, &diagnostics);
assert_eq!(unsupported, src_over);
}
#[test]
fn cached_font_text_metrics_cache_recovers_after_poison() {
let measurer =
CachedFontTextMeasurer::with_text_resources(PixelsTextResources::default(), 8);
let text = cranpose_ui::text::AnnotatedString::from("Recovered pixels text");
let poison_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _guard = measurer
.cache
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
panic!("poison pixels text metrics cache for recovery test");
}));
assert!(poison_result.is_err());
let metrics = measurer.measure(&text, &cranpose_ui::text::TextStyle::default());
assert!(metrics.width > 0.0);
assert!(metrics.height > 0.0);
}
#[test]
fn mirror_tile_mode_reflects_second_interval() {
assert_eq!(normalize_gradient_t(1.25, TileMode::Mirror), Some(0.75));
assert_eq!(normalize_gradient_t(1.75, TileMode::Mirror), Some(0.25));
}
#[test]
fn multiline_text_renders_second_line_pixels() {
let mut raster_scene = RasterScene::new();
raster_scene.push_text(
1,
Rect {
x: 8.0,
y: 8.0,
width: 180.0,
height: 80.0,
},
Rc::new(cranpose_ui::text::AnnotatedString::from(
"Dynamic\nModifiers",
)),
Color::WHITE,
cranpose_ui::TextStyle::default(),
14.0,
1.0,
cranpose_ui::TextLayoutOptions::default(),
None,
);
let width = 220;
let height = 100;
let mut frame = vec![0u8; (width * height * 4) as usize];
draw_raster_scene_for_test(&mut frame, width, height, &raster_scene);
let (ink_top, ink_bottom) =
ink_y_range(&frame, width, height).expect("expected ink pixels in rendered text");
let ink_height = ink_bottom - ink_top;
assert!(
ink_height >= 20,
"expected two lines of ink, ink spans only {ink_height}px (y={ink_top}..{ink_bottom})"
);
let mid_y = ink_top + ink_height / 2;
let first_line_ink = count_non_background_pixels_in_band(&frame, width, ink_top, mid_y);
let second_line_ink = count_non_background_pixels_in_band(&frame, width, mid_y, ink_bottom);
assert!(
first_line_ink > 20,
"expected first line to render, got {first_line_ink}"
);
assert!(
second_line_ink > 20,
"expected second line ink, got {second_line_ink}"
);
}
#[test]
fn draw_scene_renders_graph_backed_scene_without_flat_primitives() {
let mut scene = Scene::new();
scene.graph = Some(RenderGraph::new(LayerNode {
node_id: None,
local_bounds: Rect {
x: 0.0,
y: 0.0,
width: 16.0,
height: 16.0,
},
transform_to_parent: ProjectiveTransform::identity(),
motion_context_animated: false,
translated_content_context: false,
translated_content_offset: cranpose_ui_graphics::Point::default(),
graphics_layer: cranpose_ui_graphics::GraphicsLayer::default(),
clip_to_bounds: false,
shadow_clip: None,
hit_test: None,
has_hit_targets: false,
isolation: IsolationReasons::default(),
cache_policy: CachePolicy::None,
cache_hashes: LayerRasterCacheHashes::default(),
cache_hashes_valid: false,
children: vec![RenderNode::Primitive(PrimitiveEntry {
phase: PrimitivePhase::BeforeChildren,
node: PrimitiveNode::Draw(DrawPrimitiveNode {
primitive: cranpose_ui_graphics::DrawPrimitive::Rect {
rect: Rect {
x: 2.0,
y: 3.0,
width: 6.0,
height: 5.0,
},
brush: Brush::solid(Color::WHITE),
},
clip: None,
}),
})],
}));
let width = 20;
let height = 20;
let mut frame = vec![0u8; (width * height * 4) as usize];
draw_scene(&mut frame, width, height, &scene);
assert!(
count_non_background_pixels(&frame, width, height) > 0,
"graph-backed scenes should render even when flat primitive arrays are empty"
);
}
#[test]
fn text_clip_bounds_prevent_drawing_outside_scroll_window() {
let mut raster_scene = RasterScene::new();
raster_scene.push_text(
2,
Rect {
x: 8.0,
y: 40.0,
width: 180.0,
height: 24.0,
},
Rc::new(cranpose_ui::text::AnnotatedString::from("Clipped Text")),
Color::WHITE,
cranpose_ui::TextStyle::default(),
14.0,
1.0,
cranpose_ui::TextLayoutOptions::default(),
Some(Rect {
x: 0.0,
y: 0.0,
width: 220.0,
height: 20.0,
}),
);
let width = 220;
let height = 100;
let mut frame = vec![0u8; (width * height * 4) as usize];
draw_raster_scene_for_test(&mut frame, width, height, &raster_scene);
let total_ink = count_non_background_pixels_in_band(&frame, width, 0, height);
assert_eq!(
total_ink, 0,
"text should be fully clipped but rendered {total_ink} ink pixels"
);
}
#[test]
fn gradient_brush_contract_requires_visible_color_transition() {
let style = cranpose_ui::TextStyle {
span_style: cranpose_ui::SpanStyle {
brush: Some(Brush::linear_gradient_range(
vec![Color(1.0, 0.0, 0.0, 1.0), Color(0.0, 0.0, 1.0, 1.0)],
cranpose_ui_graphics::Point::new(0.0, 0.0),
cranpose_ui_graphics::Point::new(320.0, 0.0),
)),
..Default::default()
},
..Default::default()
};
let (width, _height, frame) = render_single_text_frame(style, Color::WHITE, 12.0);
let left = average_ink_rgb(&frame, width, 20, 150, 20, 120).expect("left ink");
let right = average_ink_rgb(&frame, width, 200, 340, 20, 120).expect("right ink");
assert!(
left[0] > left[2] * 1.15,
"left side should be red-dominant for horizontal gradient, got {left:?}"
);
assert!(
right[2] > right[0] * 1.15,
"right side should be blue-dominant for horizontal gradient, got {right:?}"
);
}
#[test]
fn draw_style_stroke_contract_changes_raster_output() {
let fill_style = cranpose_ui::TextStyle::default();
let stroke_style = cranpose_ui::TextStyle {
span_style: cranpose_ui::SpanStyle {
draw_style: Some(cranpose_ui::text::TextDrawStyle::Stroke { width: 6.0 }),
..Default::default()
},
..Default::default()
};
let (width, height, fill_frame) = render_single_text_frame(fill_style, Color::WHITE, 12.0);
let (_, _, stroke_frame) = render_single_text_frame(stroke_style, Color::WHITE, 12.0);
let fill_ink = count_non_background_pixels(&fill_frame, width, height);
let stroke_ink = count_non_background_pixels(&stroke_frame, width, height);
assert_ne!(
fill_frame, stroke_frame,
"Fill and Stroke text must not rasterize identically"
);
assert!(
fill_ink.abs_diff(stroke_ink) > 250,
"Fill/Stroke ink coverage should differ; fill={fill_ink}, stroke={stroke_ink}"
);
}
#[test]
fn shadow_blur_radius_contract_changes_raster_output() {
let base_shadow = cranpose_ui::text::Shadow {
color: Color(0.0, 0.0, 0.0, 0.85),
offset: cranpose_ui_graphics::Point::new(6.0, 4.0),
blur_radius: 0.0,
};
let zero_blur_style = cranpose_ui::TextStyle {
span_style: cranpose_ui::SpanStyle {
shadow: Some(base_shadow),
..Default::default()
},
..Default::default()
};
let blurred_style = cranpose_ui::TextStyle {
span_style: cranpose_ui::SpanStyle {
shadow: Some(cranpose_ui::text::Shadow {
blur_radius: 10.0,
..base_shadow
}),
..Default::default()
},
..Default::default()
};
let (_, _, zero_frame) = render_single_text_frame(zero_blur_style, Color::WHITE, 12.0);
let (_, _, blur_frame) = render_single_text_frame(blurred_style, Color::WHITE, 12.0);
assert_ne!(
zero_frame, blur_frame,
"Changing shadow blur radius must change rendered output"
);
}
#[test]
fn text_motion_contract_changes_raster_output() {
let static_style = cranpose_ui::TextStyle {
paragraph_style: cranpose_ui::ParagraphStyle {
text_motion: Some(cranpose_ui::text::TextMotion::Static),
..Default::default()
},
..Default::default()
};
let animated_style = cranpose_ui::TextStyle {
paragraph_style: cranpose_ui::ParagraphStyle {
text_motion: Some(cranpose_ui::text::TextMotion::Animated),
..Default::default()
},
..Default::default()
};
let (_, _, static_frame) = render_single_text_frame(static_style, Color::WHITE, 12.35);
let (_, _, animated_frame) = render_single_text_frame(animated_style, Color::WHITE, 12.35);
assert_ne!(
static_frame, animated_frame,
"TextMotion::Static and TextMotion::Animated should not rasterize identically"
);
}
}