kc3-lang/harfbuzz/src/hb-paint.hh

Branch - branch -main

• Show log

  Commit

• Hash : 47089fe7
  Author :
  Date : 2025-05-28T17:10:22
  

  Big misc changes
  
  - Make geometry types into templates taking float or double.
  - Changes to paint() transform elimination.
  - Add font->has_nonzero_coords and use it across.
  - Extensions to avar processing for otherwise invalid mappings.
  

Download

• src/hb-paint.hh

• /*
   * Copyright © 2022 Matthias Clasen
   *
   *  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_PAINT_HH
  #define HB_PAINT_HH
  
  #include "hb.hh"
  #include "hb-face.hh"
  #include "hb-font.hh"
  #include "hb-geometry.hh"
  
  #define HB_PAINT_FUNCS_IMPLEMENT_CALLBACKS \
    HB_PAINT_FUNC_IMPLEMENT (push_transform) \
    HB_PAINT_FUNC_IMPLEMENT (pop_transform) \
    HB_PAINT_FUNC_IMPLEMENT (color_glyph) \
    HB_PAINT_FUNC_IMPLEMENT (push_clip_glyph) \
    HB_PAINT_FUNC_IMPLEMENT (push_clip_rectangle) \
    HB_PAINT_FUNC_IMPLEMENT (pop_clip) \
    HB_PAINT_FUNC_IMPLEMENT (color) \
    HB_PAINT_FUNC_IMPLEMENT (image) \
    HB_PAINT_FUNC_IMPLEMENT (linear_gradient) \
    HB_PAINT_FUNC_IMPLEMENT (radial_gradient) \
    HB_PAINT_FUNC_IMPLEMENT (sweep_gradient) \
    HB_PAINT_FUNC_IMPLEMENT (push_group) \
    HB_PAINT_FUNC_IMPLEMENT (pop_group) \
    HB_PAINT_FUNC_IMPLEMENT (custom_palette_color) \
    /* ^--- Add new callbacks here */
  
  struct hb_paint_funcs_t
  {
    hb_object_header_t header;
  
    struct {
  #define HB_PAINT_FUNC_IMPLEMENT(name) hb_paint_##name##_func_t name;
      HB_PAINT_FUNCS_IMPLEMENT_CALLBACKS
  #undef HB_PAINT_FUNC_IMPLEMENT
    } func;
  
    struct {
  #define HB_PAINT_FUNC_IMPLEMENT(name) void *name;
      HB_PAINT_FUNCS_IMPLEMENT_CALLBACKS
  #undef HB_PAINT_FUNC_IMPLEMENT
    } *user_data;
  
    struct {
  #define HB_PAINT_FUNC_IMPLEMENT(name) hb_destroy_func_t name;
      HB_PAINT_FUNCS_IMPLEMENT_CALLBACKS
  #undef HB_PAINT_FUNC_IMPLEMENT
    } *destroy;
  
    void push_transform (void *paint_data,
                         float xx, float yx,
                         float xy, float yy,
                         float dx, float dy)
    {
      // Handle -0.f to avoid -0.f == 0.f in the transform matrix.
      if (dx == -0.f) dx = 0.f;
      if (dy == -0.f) dy = 0.f;
      func.push_transform (this, paint_data,
                           xx, yx, xy, yy, dx, dy,
                           !user_data ? nullptr : user_data->push_transform); }
    void pop_transform (void *paint_data)
    { func.pop_transform (this, paint_data,
                          !user_data ? nullptr : user_data->pop_transform); }
    bool color_glyph (void *paint_data,
                      hb_codepoint_t glyph,
                      hb_font_t *font)
    { return func.color_glyph (this, paint_data,
                               glyph,
                               font,
                               !user_data ? nullptr : user_data->push_clip_glyph); }
    void push_clip_glyph (void *paint_data,
                          hb_codepoint_t glyph,
                          hb_font_t *font)
    { func.push_clip_glyph (this, paint_data,
                            glyph,
                            font,
                            !user_data ? nullptr : user_data->push_clip_glyph); }
    void push_clip_rectangle (void *paint_data,
                             float xmin, float ymin, float xmax, float ymax)
    { func.push_clip_rectangle (this, paint_data,
                                xmin, ymin, xmax, ymax,
                                !user_data ? nullptr : user_data->push_clip_rectangle); }
    void pop_clip (void *paint_data)
    { func.pop_clip (this, paint_data,
                     !user_data ? nullptr : user_data->pop_clip); }
    void color (void *paint_data,
                hb_bool_t is_foreground,
                hb_color_t color)
    { func.color (this, paint_data,
                  is_foreground, color,
                  !user_data ? nullptr : user_data->color); }
    bool image (void *paint_data,
                hb_blob_t *image,
                unsigned width, unsigned height,
                hb_tag_t format,
                float slant,
                hb_glyph_extents_t *extents)
    { return func.image (this, paint_data,
                         image, width, height, format, slant, extents,
                         !user_data ? nullptr : user_data->image); }
    void linear_gradient (void *paint_data,
                          hb_color_line_t *color_line,
                          float x0, float y0,
                          float x1, float y1,
                          float x2, float y2)
    { func.linear_gradient (this, paint_data,
                            color_line, x0, y0, x1, y1, x2, y2,
                            !user_data ? nullptr : user_data->linear_gradient); }
    void radial_gradient (void *paint_data,
                          hb_color_line_t *color_line,
                          float x0, float y0, float r0,
                          float x1, float y1, float r1)
    { func.radial_gradient (this, paint_data,
                            color_line, x0, y0, r0, x1, y1, r1,
                            !user_data ? nullptr : user_data->radial_gradient); }
    void sweep_gradient (void *paint_data,
                         hb_color_line_t *color_line,
                         float x0, float y0,
                         float start_angle,
                         float end_angle)
    { func.sweep_gradient (this, paint_data,
                           color_line, x0, y0, start_angle, end_angle,
                           !user_data ? nullptr : user_data->sweep_gradient); }
    void push_group (void *paint_data)
    { func.push_group (this, paint_data,
                       !user_data ? nullptr : user_data->push_group); }
    void pop_group (void *paint_data,
                    hb_paint_composite_mode_t mode)
    { func.pop_group (this, paint_data,
                      mode,
                      !user_data ? nullptr : user_data->pop_group); }
    bool custom_palette_color (void *paint_data,
                               unsigned int color_index,
                               hb_color_t *color)
    { return func.custom_palette_color (this, paint_data,
                                        color_index,
                                        color,
                                        !user_data ? nullptr : user_data->custom_palette_color); }
  
  
    /* Internal specializations. */
  
    void push_font_transform (void *paint_data,
                              const hb_font_t *font)
    {
      float upem = font->face->get_upem ();
      int xscale = font->x_scale, yscale = font->y_scale;
  
      push_transform (paint_data,
  		    xscale/upem, 0,
  		    0, yscale/upem,
  		    0, 0);
    }
  
    void push_inverse_font_transform (void *paint_data,
                                      const hb_font_t *font)
    {
      float upem = font->face->get_upem ();
      int xscale = font->x_scale ? font->x_scale : upem;
      int yscale = font->y_scale ? font->y_scale : upem;
  
      push_transform (paint_data,
  		    upem/xscale, 0,
  		    0, upem/yscale,
  		    0, 0);
    }
  
    void push_transform (void *paint_data, hb_transform_t<float> t)
    {
      push_transform (paint_data, t.xx, t.yx, t.xy, t.yy, t.x0, t.y0);
    }
  
    void push_translate (void *paint_data,
                         float dx, float dy)
    {
      push_transform (paint_data,
  		    hb_transform_t<float>::translation (dx, dy));
    }
  
    void push_scale (void *paint_data,
                     float sx, float sy)
    {
      push_transform (paint_data,
  		    hb_transform_t<float>::scaling (sx, sy));
    }
    void push_scale_around_center (void *paint_data,
  				 float sx, float sy,
  				 float cx, float cy)
    {
      push_transform (paint_data,
  		    hb_transform_t<float>::scaling_around_center (sx, sy, cx, cy));
    }
  
    void push_rotate (void *paint_data,
                      float a)
    {
      push_transform (paint_data,
  		    hb_transform_t<float>::rotation (a * HB_PI));
    }
  
    void push_rotate_around_center (void *paint_data,
  				  float a,
  				  float cx, float cy)
    {
      push_transform (paint_data,
  		    hb_transform_t<float>::rotation_around_center (a * HB_PI, cx, cy));
    }
  
    void push_skew (void *paint_data,
                    float sx, float sy)
    {
      push_transform (paint_data,
  		    hb_transform_t<float>::skewing (-sx * HB_PI, sy * HB_PI));
    }
    void push_skew_around_center (void *paint_data,
  				float sx, float sy,
  				float cx, float cy)
    {
      push_transform (paint_data,
  		    hb_transform_t<float>::skewing_around_center (-sx * HB_PI, sy * HB_PI, cx, cy));
    }
  };
  DECLARE_NULL_INSTANCE (hb_paint_funcs_t);
  
  
  #endif /* HB_PAINT_HH */
  

Download