/* * Copyright © 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Author(s): Behdad Esfahbod */ #include "hb.hh" #include "hb-raster-paint.hh" #include "hb-raster-svg.hh" #include "hb-machinery.hh" #include /* * Pixel helpers (paint-specific) */ /* Convert unpremultiplied hb_color_t (BGRA order) to premultiplied BGRA32 pixel. */ static inline uint32_t color_to_premul_pixel (hb_color_t color) { uint8_t a = hb_color_get_alpha (color); uint8_t r = hb_raster_div255 (hb_color_get_red (color) * a); uint8_t g = hb_raster_div255 (hb_color_get_green (color) * a); uint8_t b = hb_raster_div255 (hb_color_get_blue (color) * a); return (uint32_t) b | ((uint32_t) g << 8) | ((uint32_t) r << 16) | ((uint32_t) a << 24); } /* * Paint callbacks */ /* Lazy initialization: set up root surface, initial clip and transform. * Called from every paint callback that needs state. * hb_font_paint_glyph() does NOT wrap with push/pop_transform, * so the first callback could be push_clip_glyph or paint_color. */ static void ensure_initialized (hb_raster_paint_t *c) { if (c->surface_stack.length) return; /* Root surface */ hb_raster_image_t *root = c->acquire_surface (); if (unlikely (!root)) return; c->surface_stack.push (root); /* Initial transform */ c->transform_stack.push (c->base_transform); /* Initial clip: full coverage rectangle */ hb_raster_clip_t clip; clip.init_full (c->fixed_extents.width, c->fixed_extents.height); c->clip_stack.push (std::move (clip)); } static void hb_raster_paint_push_transform (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, float xx, float yx, float xy, float yy, float dx, float dy, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); hb_transform_t<> t = c->current_transform (); t.multiply ({xx, yx, xy, yy, dx, dy}); c->transform_stack.push (t); } static void hb_raster_paint_pop_transform (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; c->transform_stack.pop (); } static hb_bool_t hb_raster_paint_color_glyph (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data HB_UNUSED, hb_codepoint_t glyph HB_UNUSED, hb_font_t *font HB_UNUSED, void *user_data HB_UNUSED) { return false; } typedef void (*hb_raster_paint_clip_mask_emit_t) (hb_raster_draw_t *rdr, void *user_data); static void hb_raster_paint_push_empty_clip (hb_raster_paint_t *c, unsigned w, unsigned h) { hb_raster_clip_t new_clip = c->acquire_clip (w, h); new_clip.init_full (w, h); new_clip.is_rect = true; new_clip.rect_x0 = new_clip.rect_y0 = 0; new_clip.rect_x1 = new_clip.rect_y1 = 0; new_clip.min_x = new_clip.min_y = new_clip.max_x = new_clip.max_y = 0; c->clip_stack.push (std::move (new_clip)); } static void hb_raster_paint_push_clip_from_emitter (hb_raster_paint_t *c, hb_raster_paint_clip_mask_emit_t emit, void *emit_data) { ensure_initialized (c); hb_raster_image_t *surf = c->current_surface (); if (unlikely (!surf)) return; unsigned w = surf->extents.width; unsigned h = surf->extents.height; hb_raster_clip_t new_clip = c->acquire_clip (w, h); hb_raster_draw_t *rdr = c->clip_rdr; hb_transform_t<> t = c->current_effective_transform (); hb_raster_draw_set_transform (rdr, t.xx, t.yx, t.xy, t.yy, t.x0, t.y0); emit (rdr, emit_data); hb_raster_image_t *mask_img = hb_raster_draw_render (rdr); if (unlikely (!mask_img)) { hb_raster_paint_push_empty_clip (c, w, h); return; } /* Allocate alpha buffer and intersect with previous clip */ if (unlikely (!new_clip.alpha.resize (new_clip.stride * h))) { hb_raster_draw_recycle_image (rdr, mask_img); hb_raster_paint_push_empty_clip (c, w, h); return; } const uint8_t *mask_buf = hb_raster_image_get_buffer (mask_img); hb_raster_extents_t mask_ext; hb_raster_image_get_extents (mask_img, &mask_ext); const hb_raster_clip_t &old_clip = c->current_clip (); /* Convert mask extents from surface coordinates to clip-buffer coordinates. */ int mask_x0 = mask_ext.x_origin - surf->extents.x_origin; int mask_y0 = mask_ext.y_origin - surf->extents.y_origin; int mask_x1 = mask_x0 + (int) mask_ext.width; int mask_y1 = mask_y0 + (int) mask_ext.height; int ix0_i = hb_max ((int) old_clip.min_x, hb_max (mask_x0, 0)); int iy0_i = hb_max ((int) old_clip.min_y, hb_max (mask_y0, 0)); int ix1_i = hb_min ((int) old_clip.max_x, hb_min (mask_x1, (int) w)); int iy1_i = hb_min ((int) old_clip.max_y, hb_min (mask_y1, (int) h)); if (ix0_i >= ix1_i || iy0_i >= iy1_i) { hb_raster_draw_recycle_image (rdr, mask_img); hb_raster_paint_push_empty_clip (c, w, h); return; } unsigned ix0 = (unsigned) ix0_i; unsigned iy0 = (unsigned) iy0_i; unsigned ix1 = (unsigned) ix1_i; unsigned iy1 = (unsigned) iy1_i; new_clip.min_x = w; new_clip.min_y = h; new_clip.max_x = 0; new_clip.max_y = 0; if (old_clip.is_rect) { for (unsigned y = iy0; y < iy1; y++) { const uint8_t *mask_row = mask_buf + (unsigned) ((int) y - mask_y0) * mask_ext.stride; uint8_t *out_row = new_clip.alpha.arrayZ + y * new_clip.stride; unsigned row_min = ix1; unsigned row_max = ix0; unsigned mx = (unsigned) ((int) ix0 - mask_x0); for (unsigned x = ix0; x < ix1; x++) { uint8_t a = mask_row[mx++]; out_row[x] = a; if (a && row_min == ix1) { row_min = x; row_max = x + 1; } else if (a) row_max = x + 1; } if (row_min < row_max) { new_clip.min_x = hb_min (new_clip.min_x, row_min); new_clip.min_y = hb_min (new_clip.min_y, y); new_clip.max_x = hb_max (new_clip.max_x, row_max); new_clip.max_y = hb_max (new_clip.max_y, y + 1); } } } else { for (unsigned y = iy0; y < iy1; y++) { const uint8_t *old_row = old_clip.alpha.arrayZ + y * old_clip.stride; const uint8_t *mask_row = mask_buf + (unsigned) ((int) y - mask_y0) * mask_ext.stride; uint8_t *out_row = new_clip.alpha.arrayZ + y * new_clip.stride; unsigned row_min = ix1; unsigned row_max = ix0; for (unsigned x = ix0; x < ix1; x++) { unsigned mx = (unsigned) ((int) x - mask_x0); uint8_t a = hb_raster_div255 (mask_row[mx] * old_row[x]); out_row[x] = a; if (a) { row_min = hb_min (row_min, x); row_max = x + 1; } } if (row_min < row_max) { new_clip.min_x = hb_min (new_clip.min_x, row_min); new_clip.min_y = hb_min (new_clip.min_y, y); new_clip.max_x = hb_max (new_clip.max_x, row_max); new_clip.max_y = hb_max (new_clip.max_y, y + 1); } } } hb_raster_draw_recycle_image (rdr, mask_img); c->clip_stack.push (std::move (new_clip)); } struct hb_raster_paint_glyph_clip_data_t { hb_codepoint_t glyph; hb_font_t *font; }; static void hb_raster_paint_emit_clip_glyph_mask (hb_raster_draw_t *rdr, void *user_data) { hb_raster_paint_glyph_clip_data_t *data = (hb_raster_paint_glyph_clip_data_t *) user_data; /* Let draw-render choose tight glyph extents; we map by mask origin below. */ hb_font_draw_glyph (data->font, data->glyph, hb_raster_draw_get_funcs (), rdr); } static void hb_raster_paint_push_clip_glyph (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, hb_codepoint_t glyph, hb_font_t *font, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; hb_raster_paint_glyph_clip_data_t data = {glyph, font}; hb_raster_paint_push_clip_from_emitter (c, hb_raster_paint_emit_clip_glyph_mask, &data); } /* Push clip from arbitrary path emitter (used by SVG rasterizer). * Identical to push_clip_glyph but calls user func instead of hb_font_draw_glyph. */ struct hb_raster_paint_path_clip_data_t { hb_raster_svg_path_func_t func; void *user_data; }; static void hb_raster_paint_emit_clip_path_mask (hb_raster_draw_t *rdr, void *user_data) { hb_raster_paint_path_clip_data_t *data = (hb_raster_paint_path_clip_data_t *) user_data; data->func (hb_raster_draw_get_funcs (), rdr, data->user_data); } void hb_raster_paint_push_clip_path (hb_raster_paint_t *c, hb_raster_svg_path_func_t func, void *user_data) { hb_raster_paint_path_clip_data_t data = {func, user_data}; hb_raster_paint_push_clip_from_emitter (c, hb_raster_paint_emit_clip_path_mask, &data); } static void hb_raster_paint_push_clip_rectangle (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, float xmin, float ymin, float xmax, float ymax, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); if (!c->surface_stack.length) return; hb_transform_t<> t = c->current_effective_transform (); hb_raster_image_t *surf = c->current_surface (); if (unlikely (!surf)) return; unsigned w = surf->extents.width; unsigned h = surf->extents.height; bool is_axis_aligned = (t.xy == 0.f && t.yx == 0.f); /* Transform the four corners to pixel space */ float cx[4], cy[4]; cx[0] = xmin; cy[0] = ymin; cx[1] = xmax; cy[1] = ymin; cx[2] = xmax; cy[2] = ymax; cx[3] = xmin; cy[3] = ymax; for (unsigned i = 0; i < 4; i++) t.transform_point (cx[i], cy[i]); /* Compute bounding box in pixel coords */ float fmin_x = cx[0], fmin_y = cy[0], fmax_x = cx[0], fmax_y = cy[0]; for (unsigned i = 1; i < 4; i++) { fmin_x = hb_min (fmin_x, cx[i]); fmin_y = hb_min (fmin_y, cy[i]); fmax_x = hb_max (fmax_x, cx[i]); fmax_y = hb_max (fmax_y, cy[i]); } int px0 = (int) floorf (fmin_x) - surf->extents.x_origin; int py0 = (int) floorf (fmin_y) - surf->extents.y_origin; int px1 = (int) ceilf (fmax_x) - surf->extents.x_origin; int py1 = (int) ceilf (fmax_y) - surf->extents.y_origin; /* Clamp to surface bounds */ px0 = hb_max (px0, 0); py0 = hb_max (py0, 0); px1 = hb_min (px1, (int) w); py1 = hb_min (py1, (int) h); const hb_raster_clip_t &old_clip = c->current_clip (); hb_raster_clip_t new_clip = c->acquire_clip (w, h); if (is_axis_aligned && old_clip.is_rect) { /* Fast path: axis-aligned rect-on-rect intersection */ new_clip.is_rect = true; new_clip.rect_x0 = hb_max (px0, old_clip.rect_x0); new_clip.rect_y0 = hb_max (py0, old_clip.rect_y0); new_clip.rect_x1 = hb_min (px1, old_clip.rect_x1); new_clip.rect_y1 = hb_min (py1, old_clip.rect_y1); new_clip.update_bounds_from_rect (); } else { /* General case: rasterize transformed quad as alpha mask */ new_clip.is_rect = false; if (unlikely (!new_clip.alpha.resize (new_clip.stride * h))) { hb_raster_paint_push_empty_clip (c, w, h); return; } hb_memset (new_clip.alpha.arrayZ, 0, new_clip.stride * h); /* Convert quad corners to pixel-relative coords */ float qx[4], qy[4]; int ox = surf->extents.x_origin; int oy = surf->extents.y_origin; for (unsigned i = 0; i < 4; i++) { qx[i] = cx[i] - ox; qy[i] = cy[i] - oy; } /* For each pixel in the bounding box, test if inside the quad * using cross-product edge tests (winding order). */ unsigned iy0 = (unsigned) hb_max (py0, (int) old_clip.min_y); unsigned iy1 = (unsigned) hb_min (py1, (int) old_clip.max_y); unsigned ix0 = (unsigned) hb_max (px0, (int) old_clip.min_x); unsigned ix1 = (unsigned) hb_min (px1, (int) old_clip.max_x); new_clip.min_x = w; new_clip.min_y = h; new_clip.max_x = 0; new_clip.max_y = 0; /* Precompute edge normals for point-in-quad test. * Edge i goes from corner i to corner (i+1)%4. * Normal = (dy, -dx); inside test: dot(normal, p-corner) >= 0 */ float enx[4], eny[4], ed[4]; for (unsigned i = 0; i < 4; i++) { unsigned j = (i + 1) & 3; float edx = qx[j] - qx[i], edy = qy[j] - qy[i]; enx[i] = edy; /* normal x */ eny[i] = -edx; /* normal y */ ed[i] = enx[i] * qx[i] + eny[i] * qy[i]; /* distance threshold */ } float area2 = 0.f; for (unsigned i = 0; i < 4; i++) { unsigned j = (i + 1) & 3; area2 += qx[i] * qy[j] - qx[j] * qy[i]; } bool ccw = area2 >= 0.f; if (old_clip.is_rect) { for (unsigned y = iy0; y < iy1; y++) for (unsigned x = ix0; x < ix1; x++) { float px_f = x + 0.5f, py_f = y + 0.5f; /* Test if pixel center is inside the quad */ bool inside = true; for (unsigned i = 0; i < 4; i++) { float d = enx[i] * px_f + eny[i] * py_f; if (ccw ? d < ed[i] : d > ed[i]) { inside = false; break; } } uint8_t a = inside ? 255 : 0; new_clip.alpha[y * new_clip.stride + x] = a; if (a) { new_clip.min_x = hb_min (new_clip.min_x, x); new_clip.min_y = hb_min (new_clip.min_y, y); new_clip.max_x = hb_max (new_clip.max_x, x + 1); new_clip.max_y = hb_max (new_clip.max_y, y + 1); } } } else { for (unsigned y = iy0; y < iy1; y++) { const uint8_t *old_row = old_clip.alpha.arrayZ + y * old_clip.stride; for (unsigned x = ix0; x < ix1; x++) { float px_f = x + 0.5f, py_f = y + 0.5f; /* Test if pixel center is inside the quad */ bool inside = true; for (unsigned i = 0; i < 4; i++) { float d = enx[i] * px_f + eny[i] * py_f; if (ccw ? d < ed[i] : d > ed[i]) { inside = false; break; } } uint8_t a = inside ? old_row[x] : 0; new_clip.alpha[y * new_clip.stride + x] = a; if (a) { new_clip.min_x = hb_min (new_clip.min_x, x); new_clip.min_y = hb_min (new_clip.min_y, y); new_clip.max_x = hb_max (new_clip.max_x, x + 1); new_clip.max_y = hb_max (new_clip.max_y, y + 1); } } } } } c->clip_stack.push (std::move (new_clip)); } static void hb_raster_paint_pop_clip (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; if (!c->clip_stack.length) return; c->release_clip (c->clip_stack.pop ()); } static void hb_raster_paint_push_group (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); hb_raster_image_t *new_surf = c->acquire_surface (); if (unlikely (!new_surf)) return; c->surface_stack.push (new_surf); } static void hb_raster_paint_pop_group (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, hb_paint_composite_mode_t mode, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; if (c->surface_stack.length < 2) return; hb_raster_image_t *src = c->surface_stack.pop (); hb_raster_image_t *dst = c->current_surface (); if (dst && src) hb_raster_image_composite (dst, src, mode); c->release_surface (src); } static void hb_raster_paint_color (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, hb_bool_t is_foreground, hb_color_t color, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); hb_raster_image_t *surf = c->current_surface (); if (unlikely (!surf)) return; if (is_foreground) { /* Use foreground color, modulating alpha */ color = HB_COLOR (hb_color_get_blue (c->foreground), hb_color_get_green (c->foreground), hb_color_get_red (c->foreground), hb_raster_div255 (hb_color_get_alpha (c->foreground) * hb_color_get_alpha (color))); } uint32_t premul = color_to_premul_pixel (color); uint8_t premul_a = (uint8_t) (premul >> 24); const hb_raster_clip_t &clip = c->current_clip (); unsigned stride = surf->extents.stride; if (clip.min_x >= clip.max_x || clip.min_y >= clip.max_y) return; if (premul_a == 0) return; if (likely (!clip.is_rect)) { for (unsigned y = clip.min_y; y < clip.max_y; y++) { hb_packed_t *__restrict row = (hb_packed_t *) (surf->buffer.arrayZ + y * stride); const uint8_t *__restrict clip_row = clip.alpha.arrayZ + y * clip.stride; for (unsigned x = clip.min_x; x < clip.max_x; x++) { uint8_t clip_alpha = clip_row[x]; if (clip_alpha == 0) continue; if (clip_alpha == 255) { if (premul_a == 255) row[x] = hb_packed_t (premul); else row[x] = hb_packed_t (hb_raster_src_over (premul, (uint32_t) row[x])); } else { uint32_t src = hb_raster_alpha_mul (premul, clip_alpha); row[x] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[x])); } } } } else { for (unsigned y = clip.min_y; y < clip.max_y; y++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + y * stride); for (unsigned x = clip.min_x; x < clip.max_x; x++) row[x] = hb_packed_t (hb_raster_src_over (premul, (uint32_t) row[x])); } } } static hb_bool_t hb_raster_paint_image (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, hb_blob_t *blob, unsigned width, unsigned height, hb_tag_t format, float slant HB_UNUSED, hb_glyph_extents_t *extents, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); /* Handle SVG format */ if (format == HB_PAINT_IMAGE_FORMAT_SVG) return hb_raster_svg_render (c, blob, c->svg_glyph, c->svg_font, c->svg_palette, c->foreground); /* Only handle raw BGRA32 otherwise */ if (format != HB_TAG ('B','G','R','A')) return false; if (width == 0 || height == 0) return false; if (width > (unsigned) INT_MAX || height > (unsigned) INT_MAX) return false; hb_raster_image_t *surf = c->current_surface (); if (unlikely (!surf)) return false; if (!extents) return false; unsigned data_len; const uint8_t *data = (const uint8_t *) hb_blob_get_data (blob, &data_len); size_t pixel_count = (size_t) width * (size_t) height; if (width && pixel_count / width != height) return false; if (pixel_count > (size_t) -1 / 4u) return false; size_t required_size = pixel_count * 4u; if (!data || (size_t) data_len < required_size) return false; const hb_raster_clip_t &clip = c->current_clip (); hb_transform_t<> t = c->current_effective_transform (); /* Compute inverse transform for sampling */ float det = t.xx * t.yy - t.xy * t.yx; if (fabsf (det) < 1e-10f) return false; float inv_det = 1.f / det; float inv_xx = t.yy * inv_det; float inv_xy = -t.xy * inv_det; float inv_yx = -t.yx * inv_det; float inv_yy = t.xx * inv_det; float inv_x0 = (t.xy * t.y0 - t.yy * t.x0) * inv_det; float inv_y0 = (t.yx * t.x0 - t.xx * t.y0) * inv_det; unsigned surf_stride = surf->extents.stride; const hb_packed_t *src_data = (const hb_packed_t *) data; int ox = surf->extents.x_origin; int oy = surf->extents.y_origin; /* Image source rectangle in glyph space */ float img_x = extents->x_bearing; float img_y = extents->y_bearing + extents->height; /* bottom-left in glyph space */ float img_sx = (float) extents->width / width; float img_sy = (float) -extents->height / height; /* flip Y */ if (clip.is_rect) { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * surf_stride); float gx = inv_xx * (float) ((int) clip.min_x + ox) + inv_xy * (float) ((int) py + oy) + inv_x0; float gy = inv_yx * (float) ((int) clip.min_x + ox) + inv_yy * (float) ((int) py + oy) + inv_y0; for (unsigned px = clip.min_x; px < clip.max_x; px++) { /* Map glyph space to image texel */ int ix = (int) floorf ((gx - img_x) / img_sx); int iy = (int) floorf ((gy - img_y) / img_sy); if (ix < 0 || ix >= (int) width || iy < 0 || iy >= (int) height) { gx += inv_xx; gy += inv_yx; continue; } uint32_t src_px = ((uint32_t) src_data[iy * width + ix]); row[px] = hb_packed_t (hb_raster_src_over (src_px, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } else { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * surf_stride); const uint8_t *clip_row = clip.alpha.arrayZ + py * clip.stride; float gx = inv_xx * (float) ((int) clip.min_x + ox) + inv_xy * (float) ((int) py + oy) + inv_x0; float gy = inv_yx * (float) ((int) clip.min_x + ox) + inv_yy * (float) ((int) py + oy) + inv_y0; for (unsigned px = clip.min_x; px < clip.max_x; px++) { uint8_t clip_alpha = clip_row[px]; if (clip_alpha == 0) { gx += inv_xx; gy += inv_yx; continue; } /* Map glyph space to image texel */ int ix = (int) floorf ((gx - img_x) / img_sx); int iy = (int) floorf ((gy - img_y) / img_sy); if (ix < 0 || ix >= (int) width || iy < 0 || iy >= (int) height) { gx += inv_xx; gy += inv_yx; continue; } uint32_t src_px = ((uint32_t) src_data[iy * width + ix]); src_px = hb_raster_alpha_mul (src_px, clip_alpha); row[px] = hb_packed_t (hb_raster_src_over (src_px, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } return true; } /* * Gradient helpers */ #define PREALLOCATED_COLOR_STOPS 16 #define GRADIENT_LUT_SIZE 256 #define GRADIENT_LUT_MIN_PIXELS (64u * 64u) static int cmp_color_stop (const void *p1, const void *p2) { const hb_color_stop_t *c1 = (const hb_color_stop_t *) p1; const hb_color_stop_t *c2 = (const hb_color_stop_t *) p2; if (c1->offset < c2->offset) return -1; if (c1->offset > c2->offset) return 1; return 0; } static bool get_color_stops (hb_raster_paint_t *c, hb_color_line_t *color_line, unsigned *count, hb_color_stop_t **stops) { unsigned len = hb_color_line_get_color_stops (color_line, 0, nullptr, nullptr); if (len > *count) { if (unlikely (!c->scratch_color_stops.resize (len))) return false; *stops = c->scratch_color_stops.arrayZ; } hb_color_line_get_color_stops (color_line, 0, &len, *stops); for (unsigned i = 0; i < len; i++) if ((*stops)[i].is_foreground) (*stops)[i].color = HB_COLOR (hb_color_get_blue (c->foreground), hb_color_get_green (c->foreground), hb_color_get_red (c->foreground), hb_raster_div255 (hb_color_get_alpha (c->foreground) * hb_color_get_alpha ((*stops)[i].color))); *count = len; return true; } static void normalize_color_line (hb_color_stop_t *stops, unsigned len, float *omin, float *omax) { hb_qsort (stops, len, sizeof (hb_color_stop_t), cmp_color_stop); float mn = stops[0].offset, mx = stops[0].offset; for (unsigned i = 1; i < len; i++) { mn = hb_min (mn, stops[i].offset); mx = hb_max (mx, stops[i].offset); } if (mn != mx) for (unsigned i = 0; i < len; i++) stops[i].offset = (stops[i].offset - mn) / (mx - mn); *omin = mn; *omax = mx; } /* Evaluate color at normalized position t, interpolating in premultiplied space. */ static uint32_t evaluate_color_line (const hb_color_stop_t *stops, unsigned len, float t, hb_paint_extend_t extend) { /* Apply extend mode */ if (extend == HB_PAINT_EXTEND_PAD) { t = hb_clamp (t, 0.f, 1.f); } else if (extend == HB_PAINT_EXTEND_REPEAT) { t = t - floorf (t); } else /* REFLECT */ { if (t < 0) t = -t; int period = (int) floorf (t); float frac = t - (float) period; t = (period & 1) ? 1.f - frac : frac; } /* Find bounding stops */ if (t <= stops[0].offset) return color_to_premul_pixel (stops[0].color); if (t >= stops[len - 1].offset) return color_to_premul_pixel (stops[len - 1].color); unsigned i; for (i = 0; i < len - 1; i++) if (t < stops[i + 1].offset) break; float range = stops[i + 1].offset - stops[i].offset; float k = range > 0.f ? (t - stops[i].offset) / range : 0.f; /* Interpolate in premultiplied [0,255] space */ hb_color_t c0 = stops[i].color; hb_color_t c1 = stops[i + 1].color; float a0 = hb_color_get_alpha (c0) / 255.f; float r0 = hb_color_get_red (c0) / 255.f * a0; float g0 = hb_color_get_green (c0) / 255.f * a0; float b0 = hb_color_get_blue (c0) / 255.f * a0; float a1 = hb_color_get_alpha (c1) / 255.f; float r1 = hb_color_get_red (c1) / 255.f * a1; float g1 = hb_color_get_green (c1) / 255.f * a1; float b1 = hb_color_get_blue (c1) / 255.f * a1; float a = a0 + k * (a1 - a0); float r = r0 + k * (r1 - r0); float g = g0 + k * (g1 - g0); float b = b0 + k * (b1 - b0); uint8_t pa = (uint8_t) (a * 255.f + 0.5f); uint8_t pr = (uint8_t) (r * 255.f + 0.5f); uint8_t pg = (uint8_t) (g * 255.f + 0.5f); uint8_t pb = (uint8_t) (b * 255.f + 0.5f); return (uint32_t) pb | ((uint32_t) pg << 8) | ((uint32_t) pr << 16) | ((uint32_t) pa << 24); } static HB_ALWAYS_INLINE float normalize_gradient_t (float t, hb_paint_extend_t extend) { if (extend == HB_PAINT_EXTEND_PAD) return hb_clamp (t, 0.f, 1.f); if (extend == HB_PAINT_EXTEND_REPEAT) { t = t - floorf (t); return t < 0.f ? t + 1.f : t; } /* REFLECT */ if (t < 0.f) t = -t; int period = (int) floorf (t); float frac = t - (float) period; return (period & 1) ? 1.f - frac : frac; } static void build_gradient_lut (const hb_color_stop_t *stops, unsigned len, uint32_t *lut) { for (unsigned i = 0; i < GRADIENT_LUT_SIZE; i++) { float t = (float) i / (GRADIENT_LUT_SIZE - 1); lut[i] = evaluate_color_line (stops, len, t, HB_PAINT_EXTEND_PAD); } } static HB_ALWAYS_INLINE uint32_t lookup_gradient_lut (const uint32_t *lut, float t, hb_paint_extend_t extend) { float u = normalize_gradient_t (t, extend); unsigned idx = (unsigned) (u * (GRADIENT_LUT_SIZE - 1) + 0.5f); return lut[idx]; } static void reduce_anchors (float x0, float y0, float x1, float y1, float x2, float y2, float *xx0, float *yy0, float *xx1, float *yy1) { float q2x = x2 - x0, q2y = y2 - y0; float q1x = x1 - x0, q1y = y1 - y0; float s = q2x * q2x + q2y * q2y; if (s < 0.000001f) { *xx0 = x0; *yy0 = y0; *xx1 = x1; *yy1 = y1; return; } float k = (q2x * q1x + q2y * q1y) / s; *xx0 = x0; *yy0 = y0; *xx1 = x1 - k * q2x; *yy1 = y1 - k * q2y; } /* * Gradient paint callbacks */ static void hb_raster_paint_linear_gradient (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, hb_color_line_t *color_line, float x0, float y0, float x1, float y1, float x2, float y2, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); hb_raster_image_t *surf = c->current_surface (); if (unlikely (!surf)) return; unsigned len = PREALLOCATED_COLOR_STOPS; hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS]; hb_color_stop_t *stops = stops_; if (unlikely (!get_color_stops (c, color_line, &len, &stops))) return; float mn, mx; normalize_color_line (stops, len, &mn, &mx); hb_paint_extend_t extend = hb_color_line_get_extend (color_line); const hb_raster_clip_t &clip = c->current_clip (); unsigned clip_w = clip.max_x > clip.min_x ? clip.max_x - clip.min_x : 0; unsigned clip_h = clip.max_y > clip.min_y ? clip.max_y - clip.min_y : 0; bool use_lut = (uint64_t) clip_w * clip_h >= GRADIENT_LUT_MIN_PIXELS; uint32_t lut[GRADIENT_LUT_SIZE]; if (use_lut) build_gradient_lut (stops, len, lut); /* Reduce 3-point anchor to 2-point gradient axis */ float lx0, ly0, lx1, ly1; reduce_anchors (x0, y0, x1, y1, x2, y2, &lx0, &ly0, &lx1, &ly1); /* Apply normalization to endpoints */ float gx0 = lx0 + mn * (lx1 - lx0); float gy0 = ly0 + mn * (ly1 - ly0); float gx1 = lx0 + mx * (lx1 - lx0); float gy1 = ly0 + mx * (ly1 - ly0); /* Inverse transform: pixel → glyph space */ hb_transform_t<> t = c->current_effective_transform (); float det = t.xx * t.yy - t.xy * t.yx; if (fabsf (det) < 1e-10f) goto done; { float inv_det = 1.f / det; float inv_xx = t.yy * inv_det; float inv_xy = -t.xy * inv_det; float inv_yx = -t.yx * inv_det; float inv_yy = t.xx * inv_det; float inv_x0 = (t.xy * t.y0 - t.yy * t.x0) * inv_det; float inv_y0 = (t.yx * t.x0 - t.xx * t.y0) * inv_det; /* Gradient direction vector and denominator for projection */ float dx = gx1 - gx0, dy = gy1 - gy0; float denom = dx * dx + dy * dy; if (denom < 1e-10f) goto done; float inv_denom = 1.f / denom; unsigned stride = surf->extents.stride; int ox = surf->extents.x_origin; int oy = surf->extents.y_origin; if (clip.is_rect) { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * stride); float gx = inv_xx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_xy * ((float) ((int) py + oy) + 0.5f) + inv_x0; float gy = inv_yx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_yy * ((float) ((int) py + oy) + 0.5f) + inv_y0; if (use_lut) { for (unsigned px = clip.min_x; px < clip.max_x; px++) { float proj_t = ((gx - gx0) * dx + (gy - gy0) * dy) * inv_denom; uint32_t src = lookup_gradient_lut (lut, proj_t, extend); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } else { for (unsigned px = clip.min_x; px < clip.max_x; px++) { float proj_t = ((gx - gx0) * dx + (gy - gy0) * dy) * inv_denom; uint32_t src = evaluate_color_line (stops, len, proj_t, extend); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } } else { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * stride); const uint8_t *clip_row = clip.alpha.arrayZ + py * clip.stride; float gx = inv_xx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_xy * ((float) ((int) py + oy) + 0.5f) + inv_x0; float gy = inv_yx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_yy * ((float) ((int) py + oy) + 0.5f) + inv_y0; if (use_lut) { for (unsigned px = clip.min_x; px < clip.max_x; px++) { uint8_t clip_alpha = clip_row[px]; if (clip_alpha == 0) { gx += inv_xx; gy += inv_yx; continue; } float proj_t = ((gx - gx0) * dx + (gy - gy0) * dy) * inv_denom; uint32_t src = lookup_gradient_lut (lut, proj_t, extend); src = hb_raster_alpha_mul (src, clip_alpha); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } else { for (unsigned px = clip.min_x; px < clip.max_x; px++) { uint8_t clip_alpha = clip_row[px]; if (clip_alpha == 0) { gx += inv_xx; gy += inv_yx; continue; } float proj_t = ((gx - gx0) * dx + (gy - gy0) * dy) * inv_denom; uint32_t src = evaluate_color_line (stops, len, proj_t, extend); src = hb_raster_alpha_mul (src, clip_alpha); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } } } done: (void) stops_; } static void hb_raster_paint_radial_gradient (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, hb_color_line_t *color_line, float x0, float y0, float r0, float x1, float y1, float r1, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); hb_raster_image_t *surf = c->current_surface (); if (unlikely (!surf)) return; unsigned len = PREALLOCATED_COLOR_STOPS; hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS]; hb_color_stop_t *stops = stops_; if (unlikely (!get_color_stops (c, color_line, &len, &stops))) return; float mn, mx; normalize_color_line (stops, len, &mn, &mx); hb_paint_extend_t extend = hb_color_line_get_extend (color_line); const hb_raster_clip_t &clip = c->current_clip (); unsigned clip_w = clip.max_x > clip.min_x ? clip.max_x - clip.min_x : 0; unsigned clip_h = clip.max_y > clip.min_y ? clip.max_y - clip.min_y : 0; bool use_lut = (uint64_t) clip_w * clip_h >= GRADIENT_LUT_MIN_PIXELS; uint32_t lut[GRADIENT_LUT_SIZE]; if (use_lut) build_gradient_lut (stops, len, lut); /* Apply normalization to circle parameters */ float cx0 = x0 + mn * (x1 - x0); float cy0 = y0 + mn * (y1 - y0); float cr0 = r0 + mn * (r1 - r0); float cx1 = x0 + mx * (x1 - x0); float cy1 = y0 + mx * (y1 - y0); float cr1 = r0 + mx * (r1 - r0); /* Inverse transform */ hb_transform_t<> t = c->current_effective_transform (); float det = t.xx * t.yy - t.xy * t.yx; if (fabsf (det) < 1e-10f) goto done; { float inv_det = 1.f / det; float inv_xx = t.yy * inv_det; float inv_xy = -t.xy * inv_det; float inv_yx = -t.yx * inv_det; float inv_yy = t.xx * inv_det; float inv_x0 = (t.xy * t.y0 - t.yy * t.x0) * inv_det; float inv_y0 = (t.yx * t.x0 - t.xx * t.y0) * inv_det; /* Precompute quadratic coefficients for radial gradient: * |p - c0 - t*(c1-c0)|^2 = (r0 + t*(r1-r0))^2 * * Expanding gives At^2 + Bt + C = 0 where: * cdx = c1.x - c0.x, cdy = c1.y - c0.y, dr = r1 - r0 * A = cdx^2 + cdy^2 - dr^2 * B = -2*(px-c0.x)*cdx - 2*(py-c0.y)*cdy - 2*r0*dr * C = (px-c0.x)^2 + (py-c0.y)^2 - r0^2 */ float cdx = cx1 - cx0, cdy = cy1 - cy0; float dr = cr1 - cr0; float A = cdx * cdx + cdy * cdy - dr * dr; unsigned stride = surf->extents.stride; int ox = surf->extents.x_origin; int oy = surf->extents.y_origin; if (clip.is_rect) { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * stride); float gx = inv_xx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_xy * ((float) ((int) py + oy) + 0.5f) + inv_x0; float gy = inv_yx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_yy * ((float) ((int) py + oy) + 0.5f) + inv_y0; if (use_lut) { for (unsigned px = clip.min_x; px < clip.max_x; px++) { float dpx = gx - cx0, dpy = gy - cy0; float B = -2.f * (dpx * cdx + dpy * cdy + cr0 * dr); float C = dpx * dpx + dpy * dpy - cr0 * cr0; float grad_t; if (fabsf (A) > 1e-10f) { float disc = B * B - 4.f * A * C; if (disc < 0.f) { gx += inv_xx; gy += inv_yx; continue; } float sq = sqrtf (disc); /* Pick the larger root (t closer to 1 = outer circle) */ float t1 = (-B + sq) / (2.f * A); float t2 = (-B - sq) / (2.f * A); /* Choose the root that gives a positive radius */ if (cr0 + t1 * dr >= 0.f) grad_t = t1; else grad_t = t2; } else { /* Linear case: Bt + C = 0 */ if (fabsf (B) < 1e-10f) { gx += inv_xx; gy += inv_yx; continue; } grad_t = -C / B; } uint32_t src = lookup_gradient_lut (lut, grad_t, extend); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } else { for (unsigned px = clip.min_x; px < clip.max_x; px++) { float dpx = gx - cx0, dpy = gy - cy0; float B = -2.f * (dpx * cdx + dpy * cdy + cr0 * dr); float C = dpx * dpx + dpy * dpy - cr0 * cr0; float grad_t; if (fabsf (A) > 1e-10f) { float disc = B * B - 4.f * A * C; if (disc < 0.f) { gx += inv_xx; gy += inv_yx; continue; } float sq = sqrtf (disc); float t1 = (-B + sq) / (2.f * A); float t2 = (-B - sq) / (2.f * A); grad_t = (cr0 + t1 * dr >= 0.f) ? t1 : t2; } else { if (fabsf (B) < 1e-10f) { gx += inv_xx; gy += inv_yx; continue; } grad_t = -C / B; } uint32_t src = evaluate_color_line (stops, len, grad_t, extend); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } } else { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * stride); const uint8_t *clip_row = clip.alpha.arrayZ + py * clip.stride; float gx = inv_xx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_xy * ((float) ((int) py + oy) + 0.5f) + inv_x0; float gy = inv_yx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_yy * ((float) ((int) py + oy) + 0.5f) + inv_y0; if (use_lut) { for (unsigned px = clip.min_x; px < clip.max_x; px++) { uint8_t clip_alpha = clip_row[px]; if (clip_alpha == 0) { gx += inv_xx; gy += inv_yx; continue; } float dpx = gx - cx0, dpy = gy - cy0; float B = -2.f * (dpx * cdx + dpy * cdy + cr0 * dr); float C = dpx * dpx + dpy * dpy - cr0 * cr0; float grad_t; if (fabsf (A) > 1e-10f) { float disc = B * B - 4.f * A * C; if (disc < 0.f) { gx += inv_xx; gy += inv_yx; continue; } float sq = sqrtf (disc); float t1 = (-B + sq) / (2.f * A); float t2 = (-B - sq) / (2.f * A); grad_t = (cr0 + t1 * dr >= 0.f) ? t1 : t2; } else { if (fabsf (B) < 1e-10f) { gx += inv_xx; gy += inv_yx; continue; } grad_t = -C / B; } uint32_t src = lookup_gradient_lut (lut, grad_t, extend); src = hb_raster_alpha_mul (src, clip_alpha); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } else { for (unsigned px = clip.min_x; px < clip.max_x; px++) { uint8_t clip_alpha = clip_row[px]; if (clip_alpha == 0) { gx += inv_xx; gy += inv_yx; continue; } float dpx = gx - cx0, dpy = gy - cy0; float B = -2.f * (dpx * cdx + dpy * cdy + cr0 * dr); float C = dpx * dpx + dpy * dpy - cr0 * cr0; float grad_t; if (fabsf (A) > 1e-10f) { float disc = B * B - 4.f * A * C; if (disc < 0.f) { gx += inv_xx; gy += inv_yx; continue; } float sq = sqrtf (disc); float t1 = (-B + sq) / (2.f * A); float t2 = (-B - sq) / (2.f * A); grad_t = (cr0 + t1 * dr >= 0.f) ? t1 : t2; } else { if (fabsf (B) < 1e-10f) { gx += inv_xx; gy += inv_yx; continue; } grad_t = -C / B; } uint32_t src = evaluate_color_line (stops, len, grad_t, extend); src = hb_raster_alpha_mul (src, clip_alpha); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } } } done: (void) stops_; } static void hb_raster_paint_sweep_gradient (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, hb_color_line_t *color_line, float cx, float cy, float start_angle, float end_angle, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; ensure_initialized (c); hb_raster_image_t *surf = c->current_surface (); if (unlikely (!surf)) return; unsigned len = PREALLOCATED_COLOR_STOPS; hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS]; hb_color_stop_t *stops = stops_; if (unlikely (!get_color_stops (c, color_line, &len, &stops))) return; float mn, mx; normalize_color_line (stops, len, &mn, &mx); hb_paint_extend_t extend = hb_color_line_get_extend (color_line); const hb_raster_clip_t &clip = c->current_clip (); unsigned clip_w = clip.max_x > clip.min_x ? clip.max_x - clip.min_x : 0; unsigned clip_h = clip.max_y > clip.min_y ? clip.max_y - clip.min_y : 0; bool use_lut = (uint64_t) clip_w * clip_h >= GRADIENT_LUT_MIN_PIXELS; uint32_t lut[GRADIENT_LUT_SIZE]; if (use_lut) build_gradient_lut (stops, len, lut); /* Apply normalization to angle range */ float a0 = start_angle + mn * (end_angle - start_angle); float a1 = start_angle + mx * (end_angle - start_angle); float angle_range = a1 - a0; /* Inverse transform */ hb_transform_t<> t = c->current_effective_transform (); float det = t.xx * t.yy - t.xy * t.yx; if (fabsf (det) < 1e-10f || fabsf (angle_range) < 1e-10f) goto done; { float inv_det = 1.f / det; float inv_xx = t.yy * inv_det; float inv_xy = -t.xy * inv_det; float inv_yx = -t.yx * inv_det; float inv_yy = t.xx * inv_det; float inv_x0 = (t.xy * t.y0 - t.yy * t.x0) * inv_det; float inv_y0 = (t.yx * t.x0 - t.xx * t.y0) * inv_det; float inv_angle_range = 1.f / angle_range; unsigned stride = surf->extents.stride; int ox = surf->extents.x_origin; int oy = surf->extents.y_origin; if (clip.is_rect) { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * stride); float gx = inv_xx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_xy * ((float) ((int) py + oy) + 0.5f) + inv_x0; float gy = inv_yx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_yy * ((float) ((int) py + oy) + 0.5f) + inv_y0; if (use_lut) { for (unsigned px = clip.min_x; px < clip.max_x; px++) { float angle = atan2f (gy - cy, gx - cx); if (angle < 0) angle += (float) HB_2_PI; float grad_t = (angle - a0) * inv_angle_range; uint32_t src = lookup_gradient_lut (lut, grad_t, extend); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } else { for (unsigned px = clip.min_x; px < clip.max_x; px++) { float angle = atan2f (gy - cy, gx - cx); if (angle < 0) angle += (float) HB_2_PI; float grad_t = (angle - a0) * inv_angle_range; uint32_t src = evaluate_color_line (stops, len, grad_t, extend); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } } else { for (unsigned py = clip.min_y; py < clip.max_y; py++) { hb_packed_t *row = (hb_packed_t *) (surf->buffer.arrayZ + py * stride); const uint8_t *clip_row = clip.alpha.arrayZ + py * clip.stride; float gx = inv_xx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_xy * ((float) ((int) py + oy) + 0.5f) + inv_x0; float gy = inv_yx * ((float) ((int) clip.min_x + ox) + 0.5f) + inv_yy * ((float) ((int) py + oy) + 0.5f) + inv_y0; if (use_lut) { for (unsigned px = clip.min_x; px < clip.max_x; px++) { uint8_t clip_alpha = clip_row[px]; if (clip_alpha == 0) { gx += inv_xx; gy += inv_yx; continue; } float angle = atan2f (gy - cy, gx - cx); if (angle < 0) angle += (float) HB_2_PI; float grad_t = (angle - a0) * inv_angle_range; uint32_t src = lookup_gradient_lut (lut, grad_t, extend); src = hb_raster_alpha_mul (src, clip_alpha); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } else { for (unsigned px = clip.min_x; px < clip.max_x; px++) { uint8_t clip_alpha = clip_row[px]; if (clip_alpha == 0) { gx += inv_xx; gy += inv_yx; continue; } float angle = atan2f (gy - cy, gx - cx); if (angle < 0) angle += (float) HB_2_PI; float grad_t = (angle - a0) * inv_angle_range; uint32_t src = evaluate_color_line (stops, len, grad_t, extend); src = hb_raster_alpha_mul (src, clip_alpha); row[px] = hb_packed_t (hb_raster_src_over (src, (uint32_t) row[px])); gx += inv_xx; gy += inv_yx; } } } } } done: (void) stops_; } static hb_bool_t hb_raster_paint_custom_palette_color (hb_paint_funcs_t *funcs HB_UNUSED, void *paint_data, unsigned int color_index, hb_color_t *color, void *user_data HB_UNUSED) { hb_raster_paint_t *c = (hb_raster_paint_t *) paint_data; if (likely (c->custom_palette && hb_map_has (c->custom_palette, color_index))) { *color = hb_map_get (c->custom_palette, color_index); return true; } return false; } /* * Lazy-loader singleton for paint funcs */ static inline void free_static_raster_paint_funcs (); static struct hb_raster_paint_funcs_lazy_loader_t : hb_paint_funcs_lazy_loader_t { static hb_paint_funcs_t *create () { hb_paint_funcs_t *funcs = hb_paint_funcs_create (); hb_paint_funcs_set_push_transform_func (funcs, hb_raster_paint_push_transform, nullptr, nullptr); hb_paint_funcs_set_pop_transform_func (funcs, hb_raster_paint_pop_transform, nullptr, nullptr); hb_paint_funcs_set_color_glyph_func (funcs, hb_raster_paint_color_glyph, nullptr, nullptr); hb_paint_funcs_set_push_clip_glyph_func (funcs, hb_raster_paint_push_clip_glyph, nullptr, nullptr); hb_paint_funcs_set_push_clip_rectangle_func (funcs, hb_raster_paint_push_clip_rectangle, nullptr, nullptr); hb_paint_funcs_set_pop_clip_func (funcs, hb_raster_paint_pop_clip, nullptr, nullptr); hb_paint_funcs_set_push_group_func (funcs, hb_raster_paint_push_group, nullptr, nullptr); hb_paint_funcs_set_pop_group_func (funcs, hb_raster_paint_pop_group, nullptr, nullptr); hb_paint_funcs_set_color_func (funcs, hb_raster_paint_color, nullptr, nullptr); hb_paint_funcs_set_image_func (funcs, hb_raster_paint_image, nullptr, nullptr); hb_paint_funcs_set_linear_gradient_func (funcs, hb_raster_paint_linear_gradient, nullptr, nullptr); hb_paint_funcs_set_radial_gradient_func (funcs, hb_raster_paint_radial_gradient, nullptr, nullptr); hb_paint_funcs_set_sweep_gradient_func (funcs, hb_raster_paint_sweep_gradient, nullptr, nullptr); hb_paint_funcs_set_custom_palette_color_func (funcs, hb_raster_paint_custom_palette_color, nullptr, nullptr); hb_paint_funcs_make_immutable (funcs); hb_atexit (free_static_raster_paint_funcs); return funcs; } } static_raster_paint_funcs; static inline void free_static_raster_paint_funcs () { static_raster_paint_funcs.free_instance (); } /* * Public API */ /** * hb_raster_paint_create_or_fail: * * Creates a new color-glyph paint context. * * Return value: (transfer full): * A newly allocated #hb_raster_paint_t, or `NULL` on allocation failure. * * Since: 13.0.0 **/ hb_raster_paint_t * hb_raster_paint_create_or_fail (void) { hb_raster_paint_t *paint = hb_object_create (); if (unlikely (!paint)) return nullptr; paint->clip_rdr = hb_raster_draw_create_or_fail (); if (unlikely (!paint->clip_rdr)) { hb_free (paint); return nullptr; } return paint; } /** * hb_raster_paint_reference: (skip) * @paint: a paint context * * Increases the reference count on @paint by one. * * Return value: (transfer full): * The referenced #hb_raster_paint_t. * * Since: 13.0.0 **/ hb_raster_paint_t * hb_raster_paint_reference (hb_raster_paint_t *paint) { return hb_object_reference (paint); } /** * hb_raster_paint_destroy: (skip) * @paint: a paint context * * Decreases the reference count on @paint by one. When the * reference count reaches zero, the paint context is freed. * * Since: 13.0.0 **/ void hb_raster_paint_destroy (hb_raster_paint_t *paint) { if (!hb_object_destroy (paint)) return; hb_map_destroy (paint->custom_palette); hb_raster_draw_destroy (paint->clip_rdr); for (auto *s : paint->surface_stack) hb_raster_image_destroy (s); for (auto *s : paint->surface_cache) hb_raster_image_destroy (s); hb_free (paint); } /** * hb_raster_paint_set_user_data: (skip) * @paint: a paint context * @key: the user-data key * @data: a pointer to the user data * @destroy: (nullable): a callback to call when @data is not needed anymore * @replace: whether to replace an existing data with the same key * * Attaches a user-data key/data pair to the specified paint context. * * Return value: `true` if success, `false` otherwise * * Since: 13.0.0 **/ hb_bool_t hb_raster_paint_set_user_data (hb_raster_paint_t *paint, hb_user_data_key_t *key, void *data, hb_destroy_func_t destroy, hb_bool_t replace) { return hb_object_set_user_data (paint, key, data, destroy, replace); } /** * hb_raster_paint_get_user_data: (skip) * @paint: a paint context * @key: the user-data key * * Fetches the user-data associated with the specified key, * attached to the specified paint context. * * Return value: (transfer none): * A pointer to the user data * * Since: 13.0.0 **/ void * hb_raster_paint_get_user_data (hb_raster_paint_t *paint, hb_user_data_key_t *key) { return hb_object_get_user_data (paint, key); } /** * hb_raster_paint_set_transform: * @paint: a paint context * @xx: xx component of the transform matrix * @yx: yx component of the transform matrix * @xy: xy component of the transform matrix * @yy: yy component of the transform matrix * @dx: x translation * @dy: y translation * * Sets the base 2×3 affine transform that maps from glyph-space * coordinates to pixel-space coordinates. * * Since: 13.0.0 **/ void hb_raster_paint_set_transform (hb_raster_paint_t *paint, float xx, float yx, float xy, float yy, float dx, float dy) { paint->base_transform = {xx, yx, xy, yy, dx, dy}; } /** * hb_raster_paint_get_transform: * @paint: a paint context * @xx: (out) (nullable): xx component of the transform matrix * @yx: (out) (nullable): yx component of the transform matrix * @xy: (out) (nullable): xy component of the transform matrix * @yy: (out) (nullable): yy component of the transform matrix * @dx: (out) (nullable): x translation * @dy: (out) (nullable): y translation * * Gets the current base 2x3 affine transform. * * Since: 13.0.0 **/ void hb_raster_paint_get_transform (hb_raster_paint_t *paint, float *xx, float *yx, float *xy, float *yy, float *dx, float *dy) { if (xx) *xx = paint->base_transform.xx; if (yx) *yx = paint->base_transform.yx; if (xy) *xy = paint->base_transform.xy; if (yy) *yy = paint->base_transform.yy; if (dx) *dx = paint->base_transform.x0; if (dy) *dy = paint->base_transform.y0; } /** * hb_raster_paint_set_scale_factor: * @paint: a paint context * @x_scale_factor: x-axis minification factor * @y_scale_factor: y-axis minification factor * * Sets post-transform minification factors applied during painting. * Factors larger than 1 shrink the output in pixels. The default is 1. * * Since: 13.0.0 **/ void hb_raster_paint_set_scale_factor (hb_raster_paint_t *paint, float x_scale_factor, float y_scale_factor) { paint->x_scale_factor = x_scale_factor > 0.f ? x_scale_factor : 1.f; paint->y_scale_factor = y_scale_factor > 0.f ? y_scale_factor : 1.f; } /** * hb_raster_paint_get_scale_factor: * @paint: a paint context * @x_scale_factor: (out) (nullable): x-axis minification factor * @y_scale_factor: (out) (nullable): y-axis minification factor * * Fetches the current post-transform minification factors. * * Since: 13.0.0 **/ void hb_raster_paint_get_scale_factor (hb_raster_paint_t *paint, float *x_scale_factor, float *y_scale_factor) { if (x_scale_factor) *x_scale_factor = paint->x_scale_factor; if (y_scale_factor) *y_scale_factor = paint->y_scale_factor; } /** * hb_raster_paint_set_extents: * @paint: a paint context * @extents: the desired output extents * * Sets the output image extents (pixel rectangle). * * Call this before hb_font_paint_glyph() for each render. * A common pattern is: * ``` * hb_glyph_extents_t gext; * if (hb_font_get_glyph_extents (font, gid, &gext)) * hb_raster_paint_set_glyph_extents (paint, &gext); * ``` * * Since: 13.0.0 **/ void hb_raster_paint_set_extents (hb_raster_paint_t *paint, const hb_raster_extents_t *extents) { paint->fixed_extents = *extents; paint->has_extents = true; if (paint->fixed_extents.stride == 0) paint->fixed_extents.stride = paint->fixed_extents.width * 4; } /** * hb_raster_paint_get_extents: * @paint: a paint context * @extents: (out) (nullable): where to write current extents * * Gets currently configured output extents. * * Return value: `true` if extents are set, `false` otherwise. * * Since: 13.0.0 **/ hb_bool_t hb_raster_paint_get_extents (hb_raster_paint_t *paint, hb_raster_extents_t *extents) { if (!paint->has_extents) return false; if (extents) *extents = paint->fixed_extents; return true; } /** * hb_raster_paint_set_glyph_extents: * @paint: a paint context * @glyph_extents: glyph extents from hb_font_get_glyph_extents() * * Transforms @glyph_extents with the paint context's base transform and * sets the resulting output image extents. * * This is equivalent to computing a transformed bounding box in pixel * space and calling hb_raster_paint_set_extents(). * * Return value: `true` if transformed extents are non-empty and set; * `false` otherwise. * * Since: 13.0.0 **/ hb_bool_t hb_raster_paint_set_glyph_extents (hb_raster_paint_t *paint, const hb_glyph_extents_t *glyph_extents) { float x0 = (float) glyph_extents->x_bearing; float y0 = (float) glyph_extents->y_bearing; float x1 = (float) glyph_extents->x_bearing + glyph_extents->width; float y1 = (float) glyph_extents->y_bearing + glyph_extents->height; float xmin = hb_min (x0, x1); float xmax = hb_max (x0, x1); float ymin = hb_min (y0, y1); float ymax = hb_max (y0, y1); float px[4] = {xmin, xmin, xmax, xmax}; float py[4] = {ymin, ymax, ymin, ymax}; hb_transform_t<> t = paint->base_transform; paint->apply_scale_factor (t); float tx, ty; t.transform_point (px[0], py[0]); tx = px[0]; ty = py[0]; float tx_min = tx, tx_max = tx; float ty_min = ty, ty_max = ty; for (unsigned i = 1; i < 4; i++) { t.transform_point (px[i], py[i]); tx_min = hb_min (tx_min, px[i]); tx_max = hb_max (tx_max, px[i]); ty_min = hb_min (ty_min, py[i]); ty_max = hb_max (ty_max, py[i]); } int ex0 = (int) floorf (tx_min); int ey0 = (int) floorf (ty_min); int ex1 = (int) ceilf (tx_max); int ey1 = (int) ceilf (ty_max); if (ex1 <= ex0 || ey1 <= ey0) { paint->fixed_extents = {}; paint->has_extents = false; return false; } paint->fixed_extents = { ex0, ey0, (unsigned) (ex1 - ex0), (unsigned) (ey1 - ey0), 0 }; paint->has_extents = true; if (paint->fixed_extents.stride == 0) paint->fixed_extents.stride = paint->fixed_extents.width * 4; return true; } /** * hb_raster_paint_set_foreground: * @paint: a paint context * @foreground: the foreground color * * Sets the foreground color used when paint callbacks request it * (e.g. `is_foreground` in color stops or solid fills). * * Since: 13.0.0 **/ void hb_raster_paint_set_foreground (hb_raster_paint_t *paint, hb_color_t foreground) { paint->foreground = foreground; } /** * hb_raster_paint_clear_custom_palette_colors: * @paint: a paint context. * * Clears all custom palette color overrides previously set on @paint. * * After this call, palette lookups use the selected font palette without * custom override entries. * * Since: 13.0.0 **/ void hb_raster_paint_clear_custom_palette_colors (hb_raster_paint_t *paint) { if (paint->custom_palette) hb_map_clear (paint->custom_palette); } /** * hb_raster_paint_set_custom_palette_color: * @paint: a paint context. * @color_index: color index to override. * @color: replacement color. * * Overrides one font palette color entry for subsequent paint operations. * Overrides are keyed by @color_index and persist on @paint until cleared * (or replaced for the same index). * * These overrides are consulted by paint operations that resolve CPAL * entries. * * Return value: `true` if the override was set; `false` on allocation failure. * * Since: 13.0.0 **/ hb_bool_t hb_raster_paint_set_custom_palette_color (hb_raster_paint_t *paint, unsigned int color_index, hb_color_t color) { if (unlikely (!paint->custom_palette)) { paint->custom_palette = hb_map_create (); if (unlikely (!paint->custom_palette)) return false; } hb_map_set (paint->custom_palette, color_index, color); return hb_map_allocation_successful (paint->custom_palette); } /** * hb_raster_paint_get_funcs: * * Fetches the singleton #hb_paint_funcs_t that renders color glyphs * into an #hb_raster_paint_t. Pass the #hb_raster_paint_t as the * @paint_data argument when calling hb_font_paint_glyph(). * * Return value: (transfer none): * The rasterizer paint functions * * Since: 13.0.0 **/ hb_paint_funcs_t * hb_raster_paint_get_funcs (void) { return static_raster_paint_funcs.get_unconst (); } /** * hb_raster_paint_glyph: * @paint: a paint context * @font: font to paint from * @glyph: glyph ID to paint * @pen_x: glyph origin x in font coordinates (pre-transform) * @pen_y: glyph origin y in font coordinates (pre-transform) * @palette: palette index * @foreground: foreground color * * Convenience wrapper to paint one color glyph at (@pen_x, @pen_y) using * the paint context's current transform. The pen coordinates are applied * before minification and transformed by the current affine transform. * * Return value: `true` if painting succeeded, `false` otherwise. * * Since: 13.0.0 **/ hb_bool_t hb_raster_paint_glyph (hb_raster_paint_t *paint, hb_font_t *font, hb_codepoint_t glyph, float pen_x, float pen_y, unsigned palette, hb_color_t foreground) { float xx = paint->base_transform.xx; float yx = paint->base_transform.yx; float xy = paint->base_transform.xy; float yy = paint->base_transform.yy; float dx = paint->base_transform.x0; float dy = paint->base_transform.y0; float tx = dx + xx * pen_x + xy * pen_y; float ty = dy + yx * pen_x + yy * pen_y; if (!paint->has_extents) { hb_glyph_extents_t ge; if (hb_font_get_glyph_extents (font, glyph, &ge)) { hb_raster_paint_set_transform (paint, xx, yx, xy, yy, tx, ty); hb_raster_paint_set_glyph_extents (paint, &ge); } } hb_raster_paint_set_transform (paint, xx, yx, xy, yy, tx, ty); paint->svg_glyph = glyph; paint->svg_font = font; paint->svg_palette = palette; hb_bool_t ret = hb_font_paint_glyph_or_fail (font, glyph, hb_raster_paint_get_funcs (), paint, palette, foreground); paint->svg_glyph = 0; paint->svg_font = nullptr; paint->svg_palette = 0; hb_raster_paint_set_transform (paint, xx, yx, xy, yy, dx, dy); return ret; } /** * hb_raster_paint_render: * @paint: a paint context * * Extracts the rendered image after hb_font_paint_glyph() has * completed. The paint context's surface stack is consumed and * the result returned as a new #hb_raster_image_t. Output format is * always @HB_RASTER_FORMAT_BGRA32. * * Call hb_font_paint_glyph() before calling this function. * hb_raster_paint_set_extents() or hb_raster_paint_set_glyph_extents() * must be called before painting; otherwise this function returns `NULL`. * Internal drawing state is cleared here so the same object can * be reused without client-side clearing. * * Return value: (transfer full): * A rendered #hb_raster_image_t. Returns `NULL` if extents were not set * or if allocation/configuration fails. If extents were set but nothing * was painted, returns an empty image. * * Since: 13.0.0 **/ hb_raster_image_t * hb_raster_paint_render (hb_raster_paint_t *paint) { hb_raster_image_t *result = nullptr; if (unlikely (!paint->has_extents)) goto fail; if (paint->surface_stack.length) { result = paint->surface_stack[0]; /* Release any remaining group surfaces (shouldn't happen with * well-formed paint calls, but be safe). */ for (unsigned i = 1; i < paint->surface_stack.length; i++) paint->release_surface (paint->surface_stack[i]); paint->surface_stack.clear (); } else { result = paint->acquire_surface (); if (unlikely (!result)) goto fail; } /* Clean up stacks and reset auto-extents for next glyph. */ paint->transform_stack.clear (); paint->release_all_clips (); hb_raster_draw_reset (paint->clip_rdr); paint->has_extents = false; paint->fixed_extents = {}; return result; fail: paint->transform_stack.clear (); paint->release_all_clips (); for (auto *s : paint->surface_stack) paint->release_surface (s); paint->surface_stack.clear (); hb_raster_draw_reset (paint->clip_rdr); paint->has_extents = false; paint->fixed_extents = {}; return nullptr; } /** * hb_raster_paint_reset: * @paint: a paint context * * Resets the paint context to its initial state, clearing all * configuration while preserving internal image caches. * * Since: 13.0.0 **/ void hb_raster_paint_reset (hb_raster_paint_t *paint) { paint->base_transform = {1, 0, 0, 1, 0, 0}; paint->x_scale_factor = 1.f; paint->y_scale_factor = 1.f; paint->fixed_extents = {}; paint->has_extents = false; paint->foreground = HB_COLOR (0, 0, 0, 255); hb_raster_paint_clear_custom_palette_colors (paint); paint->transform_stack.clear (); paint->release_all_clips (); for (auto *s : paint->surface_stack) paint->release_surface (s); paint->surface_stack.clear (); } /** * hb_raster_paint_recycle_image: * @paint: a paint context * @image: a raster image to recycle * * Recycles @image for reuse by subsequent render calls. * The caller transfers ownership of @image to @paint. * * Since: 13.0.0 **/ void hb_raster_paint_recycle_image (hb_raster_paint_t *paint, hb_raster_image_t *image) { paint->release_surface (image); }