601 lines
19 KiB
C++
601 lines
19 KiB
C++
/*
|
|
* Copyright © 2022 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.
|
|
*/
|
|
|
|
#ifndef HB_FT_COLR_HH
|
|
#define HB_FT_COLR_HH
|
|
|
|
#include "hb.hh"
|
|
|
|
#include "hb-paint-extents.hh"
|
|
|
|
#include FT_COLOR_H
|
|
|
|
|
|
static hb_paint_composite_mode_t
|
|
_hb_ft_paint_composite_mode (FT_Composite_Mode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case FT_COLR_COMPOSITE_CLEAR: return HB_PAINT_COMPOSITE_MODE_CLEAR;
|
|
case FT_COLR_COMPOSITE_SRC: return HB_PAINT_COMPOSITE_MODE_SRC;
|
|
case FT_COLR_COMPOSITE_DEST: return HB_PAINT_COMPOSITE_MODE_DEST;
|
|
case FT_COLR_COMPOSITE_SRC_OVER: return HB_PAINT_COMPOSITE_MODE_SRC_OVER;
|
|
case FT_COLR_COMPOSITE_DEST_OVER: return HB_PAINT_COMPOSITE_MODE_DEST_OVER;
|
|
case FT_COLR_COMPOSITE_SRC_IN: return HB_PAINT_COMPOSITE_MODE_SRC_IN;
|
|
case FT_COLR_COMPOSITE_DEST_IN: return HB_PAINT_COMPOSITE_MODE_DEST_IN;
|
|
case FT_COLR_COMPOSITE_SRC_OUT: return HB_PAINT_COMPOSITE_MODE_SRC_OUT;
|
|
case FT_COLR_COMPOSITE_DEST_OUT: return HB_PAINT_COMPOSITE_MODE_DEST_OUT;
|
|
case FT_COLR_COMPOSITE_SRC_ATOP: return HB_PAINT_COMPOSITE_MODE_SRC_ATOP;
|
|
case FT_COLR_COMPOSITE_DEST_ATOP: return HB_PAINT_COMPOSITE_MODE_DEST_ATOP;
|
|
case FT_COLR_COMPOSITE_XOR: return HB_PAINT_COMPOSITE_MODE_XOR;
|
|
case FT_COLR_COMPOSITE_PLUS: return HB_PAINT_COMPOSITE_MODE_PLUS;
|
|
case FT_COLR_COMPOSITE_SCREEN: return HB_PAINT_COMPOSITE_MODE_SCREEN;
|
|
case FT_COLR_COMPOSITE_OVERLAY: return HB_PAINT_COMPOSITE_MODE_OVERLAY;
|
|
case FT_COLR_COMPOSITE_DARKEN: return HB_PAINT_COMPOSITE_MODE_DARKEN;
|
|
case FT_COLR_COMPOSITE_LIGHTEN: return HB_PAINT_COMPOSITE_MODE_LIGHTEN;
|
|
case FT_COLR_COMPOSITE_COLOR_DODGE: return HB_PAINT_COMPOSITE_MODE_COLOR_DODGE;
|
|
case FT_COLR_COMPOSITE_COLOR_BURN: return HB_PAINT_COMPOSITE_MODE_COLOR_BURN;
|
|
case FT_COLR_COMPOSITE_HARD_LIGHT: return HB_PAINT_COMPOSITE_MODE_HARD_LIGHT;
|
|
case FT_COLR_COMPOSITE_SOFT_LIGHT: return HB_PAINT_COMPOSITE_MODE_SOFT_LIGHT;
|
|
case FT_COLR_COMPOSITE_DIFFERENCE: return HB_PAINT_COMPOSITE_MODE_DIFFERENCE;
|
|
case FT_COLR_COMPOSITE_EXCLUSION: return HB_PAINT_COMPOSITE_MODE_EXCLUSION;
|
|
case FT_COLR_COMPOSITE_MULTIPLY: return HB_PAINT_COMPOSITE_MODE_MULTIPLY;
|
|
case FT_COLR_COMPOSITE_HSL_HUE: return HB_PAINT_COMPOSITE_MODE_HSL_HUE;
|
|
case FT_COLR_COMPOSITE_HSL_SATURATION: return HB_PAINT_COMPOSITE_MODE_HSL_SATURATION;
|
|
case FT_COLR_COMPOSITE_HSL_COLOR: return HB_PAINT_COMPOSITE_MODE_HSL_COLOR;
|
|
case FT_COLR_COMPOSITE_HSL_LUMINOSITY: return HB_PAINT_COMPOSITE_MODE_HSL_LUMINOSITY;
|
|
|
|
case FT_COLR_COMPOSITE_MAX: HB_FALLTHROUGH;
|
|
default: return HB_PAINT_COMPOSITE_MODE_CLEAR;
|
|
}
|
|
}
|
|
|
|
typedef struct hb_ft_paint_context_t hb_ft_paint_context_t;
|
|
|
|
static void
|
|
_hb_ft_paint (hb_ft_paint_context_t *c,
|
|
FT_OpaquePaint opaque_paint);
|
|
|
|
struct hb_ft_paint_context_t
|
|
{
|
|
hb_ft_paint_context_t (const hb_ft_font_t *ft_font,
|
|
hb_font_t *font,
|
|
hb_paint_funcs_t *paint_funcs, void *paint_data,
|
|
FT_Color *palette,
|
|
unsigned palette_index,
|
|
hb_color_t foreground) :
|
|
ft_font (ft_font), font(font),
|
|
funcs (paint_funcs), data (paint_data),
|
|
palette (palette), palette_index (palette_index), foreground (foreground) {}
|
|
|
|
void recurse (FT_OpaquePaint paint)
|
|
{
|
|
if (unlikely (depth_left <= 0 || edge_count <= 0)) return;
|
|
depth_left--;
|
|
edge_count--;
|
|
_hb_ft_paint (this, paint);
|
|
depth_left++;
|
|
}
|
|
|
|
const hb_ft_font_t *ft_font;
|
|
hb_font_t *font;
|
|
hb_paint_funcs_t *funcs;
|
|
void *data;
|
|
FT_Color *palette;
|
|
unsigned palette_index;
|
|
hb_color_t foreground;
|
|
hb_map_t current_glyphs;
|
|
hb_map_t current_layers;
|
|
int depth_left = HB_MAX_NESTING_LEVEL;
|
|
int edge_count = HB_COLRV1_MAX_EDGE_COUNT;
|
|
};
|
|
|
|
static unsigned
|
|
_hb_ft_color_line_get_color_stops (hb_color_line_t *color_line,
|
|
void *color_line_data,
|
|
unsigned int start,
|
|
unsigned int *count,
|
|
hb_color_stop_t *color_stops,
|
|
void *user_data)
|
|
{
|
|
FT_ColorLine *cl = (FT_ColorLine *) color_line_data;
|
|
hb_ft_paint_context_t *c = (hb_ft_paint_context_t *) user_data;
|
|
|
|
if (count)
|
|
{
|
|
FT_ColorStop stop;
|
|
unsigned wrote = 0;
|
|
FT_ColorStopIterator iter = cl->color_stop_iterator;
|
|
|
|
if (start >= cl->color_stop_iterator.num_color_stops)
|
|
{
|
|
*count = 0;
|
|
return cl->color_stop_iterator.num_color_stops;
|
|
}
|
|
|
|
while (cl->color_stop_iterator.current_color_stop < start)
|
|
FT_Get_Colorline_Stops(c->ft_font->ft_face,
|
|
&stop,
|
|
&cl->color_stop_iterator);
|
|
|
|
while (count && *count &&
|
|
FT_Get_Colorline_Stops(c->ft_font->ft_face,
|
|
&stop,
|
|
&cl->color_stop_iterator))
|
|
{
|
|
// https://github.com/harfbuzz/harfbuzz/issues/4013
|
|
if (sizeof stop.stop_offset == 2)
|
|
color_stops->offset = stop.stop_offset / 16384.f;
|
|
else
|
|
color_stops->offset = stop.stop_offset / 65536.f;
|
|
|
|
color_stops->is_foreground = stop.color.palette_index == 0xFFFF;
|
|
if (color_stops->is_foreground)
|
|
color_stops->color = HB_COLOR (hb_color_get_blue (c->foreground),
|
|
hb_color_get_green (c->foreground),
|
|
hb_color_get_red (c->foreground),
|
|
(hb_color_get_alpha (c->foreground) * stop.color.alpha) >> 14);
|
|
else
|
|
{
|
|
hb_color_t color;
|
|
if (c->funcs->custom_palette_color (c->data, stop.color.palette_index, &color))
|
|
{
|
|
color_stops->color = HB_COLOR (hb_color_get_blue (color),
|
|
hb_color_get_green (color),
|
|
hb_color_get_red (color),
|
|
(hb_color_get_alpha (color) * stop.color.alpha) >> 14);
|
|
}
|
|
else
|
|
{
|
|
FT_Color ft_color = c->palette[stop.color.palette_index];
|
|
color_stops->color = HB_COLOR (ft_color.blue,
|
|
ft_color.green,
|
|
ft_color.red,
|
|
(ft_color.alpha * stop.color.alpha) >> 14);
|
|
}
|
|
}
|
|
|
|
color_stops++;
|
|
wrote++;
|
|
}
|
|
|
|
*count = wrote;
|
|
|
|
// reset the iterator for next time
|
|
cl->color_stop_iterator = iter;
|
|
}
|
|
|
|
return cl->color_stop_iterator.num_color_stops;
|
|
}
|
|
|
|
static hb_paint_extend_t
|
|
_hb_ft_color_line_get_extend (hb_color_line_t *color_line,
|
|
void *color_line_data,
|
|
void *user_data)
|
|
{
|
|
FT_ColorLine *c = (FT_ColorLine *) color_line_data;
|
|
switch (c->extend)
|
|
{
|
|
default:
|
|
case FT_COLR_PAINT_EXTEND_PAD: return HB_PAINT_EXTEND_PAD;
|
|
case FT_COLR_PAINT_EXTEND_REPEAT: return HB_PAINT_EXTEND_REPEAT;
|
|
case FT_COLR_PAINT_EXTEND_REFLECT: return HB_PAINT_EXTEND_REFLECT;
|
|
}
|
|
}
|
|
|
|
void
|
|
_hb_ft_paint (hb_ft_paint_context_t *c,
|
|
FT_OpaquePaint opaque_paint)
|
|
{
|
|
FT_Face ft_face = c->ft_font->ft_face;
|
|
FT_COLR_Paint paint;
|
|
if (!FT_Get_Paint (ft_face, opaque_paint, &paint))
|
|
return;
|
|
|
|
switch (paint.format)
|
|
{
|
|
case FT_COLR_PAINTFORMAT_COLR_LAYERS:
|
|
{
|
|
FT_OpaquePaint other_paint = {0};
|
|
while (FT_Get_Paint_Layers (ft_face,
|
|
&paint.u.colr_layers.layer_iterator,
|
|
&other_paint))
|
|
{
|
|
unsigned i = paint.u.colr_layers.layer_iterator.layer;
|
|
|
|
if (unlikely (c->current_layers.has (i)))
|
|
continue;
|
|
|
|
c->current_layers.add (i);
|
|
|
|
c->funcs->push_group (c->data);
|
|
c->recurse (other_paint);
|
|
c->funcs->pop_group (c->data, HB_PAINT_COMPOSITE_MODE_SRC_OVER);
|
|
|
|
c->current_layers.del (i);
|
|
}
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_SOLID:
|
|
{
|
|
bool is_foreground = paint.u.solid.color.palette_index == 0xFFFF;
|
|
hb_color_t color;
|
|
if (is_foreground)
|
|
color = HB_COLOR (hb_color_get_blue (c->foreground),
|
|
hb_color_get_green (c->foreground),
|
|
hb_color_get_red (c->foreground),
|
|
(hb_color_get_alpha (c->foreground) * paint.u.solid.color.alpha) >> 14);
|
|
else
|
|
{
|
|
if (c->funcs->custom_palette_color (c->data, paint.u.solid.color.palette_index, &color))
|
|
{
|
|
color = HB_COLOR (hb_color_get_blue (color),
|
|
hb_color_get_green (color),
|
|
hb_color_get_red (color),
|
|
(hb_color_get_alpha (color) * paint.u.solid.color.alpha) >> 14);
|
|
}
|
|
else
|
|
{
|
|
FT_Color ft_color = c->palette[paint.u.solid.color.palette_index];
|
|
color = HB_COLOR (ft_color.blue,
|
|
ft_color.green,
|
|
ft_color.red,
|
|
(ft_color.alpha * paint.u.solid.color.alpha) >> 14);
|
|
}
|
|
}
|
|
c->funcs->color (c->data, is_foreground, color);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_LINEAR_GRADIENT:
|
|
{
|
|
hb_color_line_t cl = {
|
|
&paint.u.linear_gradient.colorline,
|
|
_hb_ft_color_line_get_color_stops, c,
|
|
_hb_ft_color_line_get_extend, nullptr
|
|
};
|
|
|
|
c->funcs->linear_gradient (c->data, &cl,
|
|
paint.u.linear_gradient.p0.x / 65536.f,
|
|
paint.u.linear_gradient.p0.y / 65536.f,
|
|
paint.u.linear_gradient.p1.x / 65536.f,
|
|
paint.u.linear_gradient.p1.y / 65536.f,
|
|
paint.u.linear_gradient.p2.x / 65536.f,
|
|
paint.u.linear_gradient.p2.y / 65536.f);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_RADIAL_GRADIENT:
|
|
{
|
|
hb_color_line_t cl = {
|
|
&paint.u.linear_gradient.colorline,
|
|
_hb_ft_color_line_get_color_stops, c,
|
|
_hb_ft_color_line_get_extend, nullptr
|
|
};
|
|
|
|
c->funcs->radial_gradient (c->data, &cl,
|
|
paint.u.radial_gradient.c0.x / 65536.f,
|
|
paint.u.radial_gradient.c0.y / 65536.f,
|
|
paint.u.radial_gradient.r0 / 65536.f,
|
|
paint.u.radial_gradient.c1.x / 65536.f,
|
|
paint.u.radial_gradient.c1.y / 65536.f,
|
|
paint.u.radial_gradient.r1 / 65536.f);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_SWEEP_GRADIENT:
|
|
{
|
|
hb_color_line_t cl = {
|
|
&paint.u.linear_gradient.colorline,
|
|
_hb_ft_color_line_get_color_stops, c,
|
|
_hb_ft_color_line_get_extend, nullptr
|
|
};
|
|
|
|
c->funcs->sweep_gradient (c->data, &cl,
|
|
paint.u.sweep_gradient.center.x / 65536.f,
|
|
paint.u.sweep_gradient.center.y / 65536.f,
|
|
(paint.u.sweep_gradient.start_angle / 65536.f + 1) * HB_PI,
|
|
(paint.u.sweep_gradient.end_angle / 65536.f + 1) * HB_PI);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_GLYPH:
|
|
{
|
|
c->funcs->push_inverse_root_transform (c->data, c->font);
|
|
c->ft_font->lock.unlock ();
|
|
c->funcs->push_clip_glyph (c->data, paint.u.glyph.glyphID, c->font);
|
|
c->ft_font->lock.lock ();
|
|
c->funcs->push_root_transform (c->data, c->font);
|
|
c->recurse (paint.u.glyph.paint);
|
|
c->funcs->pop_transform (c->data);
|
|
c->funcs->pop_clip (c->data);
|
|
c->funcs->pop_transform (c->data);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_COLR_GLYPH:
|
|
{
|
|
hb_codepoint_t gid = paint.u.colr_glyph.glyphID;
|
|
|
|
if (unlikely (c->current_glyphs.has (gid)))
|
|
return;
|
|
|
|
c->current_glyphs.add (gid);
|
|
|
|
c->funcs->push_inverse_root_transform (c->data, c->font);
|
|
c->ft_font->lock.unlock ();
|
|
if (c->funcs->color_glyph (c->data, gid, c->font))
|
|
{
|
|
c->ft_font->lock.lock ();
|
|
c->funcs->pop_transform (c->data);
|
|
c->current_glyphs.del (gid);
|
|
return;
|
|
}
|
|
c->ft_font->lock.lock ();
|
|
c->funcs->pop_transform (c->data);
|
|
|
|
FT_OpaquePaint other_paint = {0};
|
|
if (FT_Get_Color_Glyph_Paint (ft_face, gid,
|
|
FT_COLOR_NO_ROOT_TRANSFORM,
|
|
&other_paint))
|
|
{
|
|
bool has_clip_box;
|
|
FT_ClipBox clip_box;
|
|
has_clip_box = FT_Get_Color_Glyph_ClipBox (ft_face, paint.u.colr_glyph.glyphID, &clip_box);
|
|
|
|
if (has_clip_box)
|
|
{
|
|
/* The FreeType ClipBox is in scaled coordinates, whereas we need
|
|
* unscaled clipbox here. Oh well...
|
|
*/
|
|
|
|
float upem = c->font->face->get_upem ();
|
|
float xscale = upem / (c->font->x_scale ? c->font->x_scale : upem);
|
|
float yscale = upem / (c->font->y_scale ? c->font->y_scale : upem);
|
|
|
|
c->funcs->push_clip_rectangle (c->data,
|
|
clip_box.bottom_left.x * xscale,
|
|
clip_box.bottom_left.y * yscale,
|
|
clip_box.top_right.x * xscale,
|
|
clip_box.top_right.y * yscale);
|
|
}
|
|
|
|
c->recurse (other_paint);
|
|
|
|
if (has_clip_box)
|
|
c->funcs->pop_clip (c->data);
|
|
|
|
c->current_glyphs.del (gid);
|
|
}
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_TRANSFORM:
|
|
{
|
|
c->funcs->push_transform (c->data,
|
|
paint.u.transform.affine.xx / 65536.f,
|
|
paint.u.transform.affine.yx / 65536.f,
|
|
paint.u.transform.affine.xy / 65536.f,
|
|
paint.u.transform.affine.yy / 65536.f,
|
|
paint.u.transform.affine.dx / 65536.f,
|
|
paint.u.transform.affine.dy / 65536.f);
|
|
c->recurse (paint.u.transform.paint);
|
|
c->funcs->pop_transform (c->data);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_TRANSLATE:
|
|
{
|
|
float dx = paint.u.translate.dx / 65536.f;
|
|
float dy = paint.u.translate.dy / 65536.f;
|
|
|
|
bool p1 = c->funcs->push_translate (c->data, dx, dy);
|
|
c->recurse (paint.u.translate.paint);
|
|
if (p1) c->funcs->pop_transform (c->data);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_SCALE:
|
|
{
|
|
float dx = paint.u.scale.center_x / 65536.f;
|
|
float dy = paint.u.scale.center_y / 65536.f;
|
|
float sx = paint.u.scale.scale_x / 65536.f;
|
|
float sy = paint.u.scale.scale_y / 65536.f;
|
|
|
|
bool p1 = c->funcs->push_translate (c->data, +dx, +dy);
|
|
bool p2 = c->funcs->push_scale (c->data, sx, sy);
|
|
bool p3 = c->funcs->push_translate (c->data, -dx, -dy);
|
|
c->recurse (paint.u.scale.paint);
|
|
if (p3) c->funcs->pop_transform (c->data);
|
|
if (p2) c->funcs->pop_transform (c->data);
|
|
if (p1) c->funcs->pop_transform (c->data);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_ROTATE:
|
|
{
|
|
float dx = paint.u.rotate.center_x / 65536.f;
|
|
float dy = paint.u.rotate.center_y / 65536.f;
|
|
float a = paint.u.rotate.angle / 65536.f;
|
|
|
|
bool p1 = c->funcs->push_translate (c->data, +dx, +dy);
|
|
bool p2 = c->funcs->push_rotate (c->data, a);
|
|
bool p3 = c->funcs->push_translate (c->data, -dx, -dy);
|
|
c->recurse (paint.u.rotate.paint);
|
|
if (p3) c->funcs->pop_transform (c->data);
|
|
if (p2) c->funcs->pop_transform (c->data);
|
|
if (p1) c->funcs->pop_transform (c->data);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_SKEW:
|
|
{
|
|
float dx = paint.u.skew.center_x / 65536.f;
|
|
float dy = paint.u.skew.center_y / 65536.f;
|
|
float sx = paint.u.skew.x_skew_angle / 65536.f;
|
|
float sy = paint.u.skew.y_skew_angle / 65536.f;
|
|
|
|
bool p1 = c->funcs->push_translate (c->data, +dx, +dy);
|
|
bool p2 = c->funcs->push_skew (c->data, sx, sy);
|
|
bool p3 = c->funcs->push_translate (c->data, -dx, -dy);
|
|
c->recurse (paint.u.skew.paint);
|
|
if (p3) c->funcs->pop_transform (c->data);
|
|
if (p2) c->funcs->pop_transform (c->data);
|
|
if (p1) c->funcs->pop_transform (c->data);
|
|
}
|
|
break;
|
|
case FT_COLR_PAINTFORMAT_COMPOSITE:
|
|
{
|
|
c->recurse (paint.u.composite.backdrop_paint);
|
|
c->funcs->push_group (c->data);
|
|
c->recurse (paint.u.composite.source_paint);
|
|
c->funcs->pop_group (c->data, _hb_ft_paint_composite_mode (paint.u.composite.composite_mode));
|
|
}
|
|
break;
|
|
|
|
case FT_COLR_PAINT_FORMAT_MAX: break;
|
|
default: HB_FALLTHROUGH;
|
|
case FT_COLR_PAINTFORMAT_UNSUPPORTED: break;
|
|
}
|
|
}
|
|
|
|
|
|
static bool
|
|
hb_ft_paint_glyph_colr (hb_font_t *font,
|
|
void *font_data,
|
|
hb_codepoint_t gid,
|
|
hb_paint_funcs_t *paint_funcs, void *paint_data,
|
|
unsigned int palette_index,
|
|
hb_color_t foreground,
|
|
void *user_data)
|
|
{
|
|
const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font_data;
|
|
FT_Face ft_face = ft_font->ft_face;
|
|
|
|
/* Face is locked. */
|
|
|
|
FT_Error error;
|
|
FT_Color* palette;
|
|
FT_LayerIterator iterator;
|
|
|
|
FT_Bool have_layers;
|
|
FT_UInt layer_glyph_index;
|
|
FT_UInt layer_color_index;
|
|
|
|
error = FT_Palette_Select(ft_face, palette_index, &palette);
|
|
if (error)
|
|
palette = NULL;
|
|
|
|
/* COLRv1 */
|
|
FT_OpaquePaint paint = {0};
|
|
if (FT_Get_Color_Glyph_Paint (ft_face, gid,
|
|
FT_COLOR_NO_ROOT_TRANSFORM,
|
|
&paint))
|
|
{
|
|
hb_ft_paint_context_t c (ft_font, font,
|
|
paint_funcs, paint_data,
|
|
palette, palette_index, foreground);
|
|
c.current_glyphs.add (gid);
|
|
|
|
bool is_bounded = true;
|
|
FT_ClipBox clip_box;
|
|
if (FT_Get_Color_Glyph_ClipBox (ft_face, gid, &clip_box))
|
|
{
|
|
c.funcs->push_clip_rectangle (c.data,
|
|
clip_box.bottom_left.x +
|
|
roundf (hb_min (font->slant_xy * clip_box.bottom_left.y,
|
|
font->slant_xy * clip_box.top_left.y)),
|
|
clip_box.bottom_left.y,
|
|
clip_box.top_right.x +
|
|
roundf (hb_max (font->slant_xy * clip_box.bottom_right.y,
|
|
font->slant_xy * clip_box.top_right.y)),
|
|
clip_box.top_right.y);
|
|
}
|
|
else
|
|
{
|
|
|
|
auto *extents_funcs = hb_paint_extents_get_funcs ();
|
|
hb_paint_extents_context_t extents_data;
|
|
hb_ft_paint_context_t ce (ft_font, font,
|
|
extents_funcs, &extents_data,
|
|
palette, palette_index, foreground);
|
|
ce.current_glyphs.add (gid);
|
|
ce.funcs->push_root_transform (ce.data, font);
|
|
ce.recurse (paint);
|
|
ce.funcs->pop_transform (ce.data);
|
|
hb_extents_t extents = extents_data.get_extents ();
|
|
is_bounded = extents_data.is_bounded ();
|
|
|
|
c.funcs->push_clip_rectangle (c.data,
|
|
extents.xmin,
|
|
extents.ymin,
|
|
extents.xmax,
|
|
extents.ymax);
|
|
}
|
|
|
|
c.funcs->push_root_transform (c.data, font);
|
|
|
|
if (is_bounded)
|
|
c.recurse (paint);
|
|
|
|
c.funcs->pop_transform (c.data);
|
|
c.funcs->pop_clip (c.data);
|
|
|
|
return true;
|
|
}
|
|
|
|
/* COLRv0 */
|
|
iterator.p = NULL;
|
|
have_layers = FT_Get_Color_Glyph_Layer(ft_face,
|
|
gid,
|
|
&layer_glyph_index,
|
|
&layer_color_index,
|
|
&iterator);
|
|
|
|
if (palette && have_layers)
|
|
{
|
|
do
|
|
{
|
|
hb_bool_t is_foreground = true;
|
|
hb_color_t color = foreground;
|
|
|
|
if ( layer_color_index != 0xFFFF )
|
|
{
|
|
FT_Color layer_color = palette[layer_color_index];
|
|
color = HB_COLOR (layer_color.blue,
|
|
layer_color.green,
|
|
layer_color.red,
|
|
layer_color.alpha);
|
|
is_foreground = false;
|
|
}
|
|
|
|
ft_font->lock.unlock ();
|
|
paint_funcs->push_clip_glyph (paint_data, layer_glyph_index, font);
|
|
ft_font->lock.lock ();
|
|
paint_funcs->color (paint_data, is_foreground, color);
|
|
paint_funcs->pop_clip (paint_data);
|
|
|
|
} while (FT_Get_Color_Glyph_Layer(ft_face,
|
|
gid,
|
|
&layer_glyph_index,
|
|
&layer_color_index,
|
|
&iterator));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
#endif /* HB_FT_COLR_HH */
|