include/c/sk_types.h

   1 /*
   2  * Copyright 2014 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 // EXPERIMENTAL EXPERIMENTAL EXPERIMENTAL EXPERIMENTAL
   9 // DO NOT USE -- FOR INTERNAL TESTING ONLY
  10
  11 #ifndef sk_types_DEFINED
  12 #define sk_types_DEFINED
  13
  14 #include <stdint.h>
  15 #include <stddef.h>
  16
  17 #ifdef __cplusplus
  18     #define SK_C_PLUS_PLUS_BEGIN_GUARD    extern "C" {
  19     #define SK_C_PLUS_PLUS_END_GUARD      }
  20 #else
  21     #include <stdbool.h>
  22     #define SK_C_PLUS_PLUS_BEGIN_GUARD
  23     #define SK_C_PLUS_PLUS_END_GUARD
  24 #endif
  25
  26 #if !defined(SK_API)
  27     #if defined(SKIA_DLL)
  28         #if defined(_MSC_VER)
  29             #if SKIA_IMPLEMENTATION
  30                 #define SK_API __declspec(dllexport)
  31             #else
  32                 #define SK_API __declspec(dllimport)
  33             #endif
  34         #else
  35             #define SK_API __attribute__((visibility("default")))
  36         #endif
  37     #else
  38         #define SK_API
  39     #endif
  40 #endif
  41
  42 ///////////////////////////////////////////////////////////////////////////////////////
  43
  44 SK_C_PLUS_PLUS_BEGIN_GUARD
  45
  46 typedef uint32_t sk_color_t;
  47
  48 /* This macro assumes all arguments are >=0 and <=255. */
  49 #define sk_color_set_argb(a, r, g, b)   (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
  50 #define sk_color_get_a(c)               (((c) >> 24) & 0xFF)
  51 #define sk_color_get_r(c)               (((c) >> 16) & 0xFF)
  52 #define sk_color_get_g(c)               (((c) >>  8) & 0xFF)
  53 #define sk_color_get_b(c)               (((c) >>  0) & 0xFF)
  54
  55 typedef enum {
  56     UNKNOWN_SK_COLORTYPE = 0,
  57     ALPHA_8_SK_COLORTYPE,
  58     RGB_565_SK_COLORTYPE,
  59     ARGB_4444_SK_COLORTYPE,
  60     RGBA_8888_SK_COLORTYPE,
  61     BGRA_8888_SK_COLORTYPE,
  62     Index_8_SK_COLORTYPE,
  63     Gray_8_SK_COLORTYPE,
  64     RGBA_F16_SK_COLORTYPE,
  65 } sk_colortype_t;
  66
  67 typedef enum {
  68     UNKNOWN_SK_ALPHATYPE,
  69     OPAQUE_SK_ALPHATYPE,
  70     PREMUL_SK_ALPHATYPE,
  71     UNPREMUL_SK_ALPHATYPE,
  72 } sk_alphatype_t;
  73
  74 typedef enum {
  75     UNKNOWN_SK_PIXELGEOMETRY,
  76     RGB_H_SK_PIXELGEOMETRY,
  77     BGR_H_SK_PIXELGEOMETRY,
  78     RGB_V_SK_PIXELGEOMETRY,
  79     BGR_V_SK_PIXELGEOMETRY,
  80 } sk_pixelgeometry_t;
  81
  82 typedef struct {
  83     int32_t         width;
  84     int32_t         height;
  85     sk_colortype_t  colorType;
  86     sk_alphatype_t  alphaType;
  87 } sk_imageinfo_t;
  88
  89 typedef enum {
  90     USE_DEVICE_INDEPENDENT_FONTS_GR_SURFACE_PROPS_FLAGS = 1 << 0,
  91 } sk_surfaceprops_flags_t;
  92
  93 typedef struct {
  94     sk_pixelgeometry_t pixelGeometry;
  95     sk_surfaceprops_flags_t flags;
  96 } sk_surfaceprops_t;
  97
  98 typedef struct {
  99     float   x;
 100     float   y;
 101 } sk_point_t;
 102
 103 typedef sk_point_t sk_vector_t;
 104
 105 typedef struct {
 106     int32_t left;
 107     int32_t top;
 108     int32_t right;
 109     int32_t bottom;
 110 } sk_irect_t;
 111
 112 typedef struct {
 113     float   left;
 114     float   top;
 115     float   right;
 116     float   bottom;
 117 } sk_rect_t;
 118
 119 typedef struct {
 120     float   mat[9];
 121 } sk_matrix_t;
 122
 123 /**
 124     A sk_canvas_t encapsulates all of the state about drawing into a
 125     destination This includes a reference to the destination itself,
 126     and a stack of matrix/clip values.
 127 */
 128 typedef struct sk_canvas_t sk_canvas_t;
 129 /**
 130     A sk_data_ holds an immutable data buffer.
 131 */
 132 typedef struct sk_data_t sk_data_t;
 133 /**
 134     A sk_image_t is an abstraction for drawing a rectagle of pixels.
 135     The content of the image is always immutable, though the actual
 136     storage may change, if for example that image can be re-created via
 137     encoded data or other means.
 138 */
 139 typedef struct sk_image_t sk_image_t;
 140 /**
 141     A sk_maskfilter_t is an object that perform transformations on an
 142     alpha-channel mask before drawing it; it may be installed into a
 143     sk_paint_t.  Each time a primitive is drawn, it is first
 144     scan-converted into a alpha mask, which os handed to the
 145     maskfilter, which may create a new mask is to render into the
 146     destination.
 147  */
 148 typedef struct sk_maskfilter_t sk_maskfilter_t;
 149 /**
 150     A sk_paint_t holds the style and color information about how to
 151     draw geometries, text and bitmaps.
 152 */
 153 typedef struct sk_paint_t sk_paint_t;
 154 /**
 155     A sk_path_t encapsulates compound (multiple contour) geometric
 156     paths consisting of straight line segments, quadratic curves, and
 157     cubic curves.
 158 */
 159 typedef struct sk_path_t sk_path_t;
 160 /**
 161     A sk_picture_t holds recorded canvas drawing commands to be played
 162     back at a later time.
 163 */
 164 typedef struct sk_picture_t sk_picture_t;
 165 /**
 166     A sk_picture_recorder_t holds a sk_canvas_t that records commands
 167     to create a sk_picture_t.
 168 */
 169 typedef struct sk_picture_recorder_t sk_picture_recorder_t;
 170 /**
 171     A sk_shader_t specifies the source color(s) for what is being drawn. If a
 172     paint has no shader, then the paint's color is used. If the paint
 173     has a shader, then the shader's color(s) are use instead, but they
 174     are modulated by the paint's alpha.
 175 */
 176 typedef struct sk_shader_t sk_shader_t;
 177 /**
 178     A sk_surface_t holds the destination for drawing to a canvas. For
 179     raster drawing, the destination is an array of pixels in memory.
 180     For GPU drawing, the destination is a texture or a framebuffer.
 181 */
 182 typedef struct sk_surface_t sk_surface_t;
 183 /**
 184     The sk_region encapsulates the geometric region used to specify
 185     clipping areas for drawing.
 186 */
 187 typedef struct sk_region_t sk_region_t;
 188
 189 typedef enum {
 190     CLEAR_SK_BLENDMODE,
 191     SRC_SK_BLENDMODE,
 192     DST_SK_BLENDMODE,
 193     SRCOVER_SK_BLENDMODE,
 194     DSTOVER_SK_BLENDMODE,
 195     SRCIN_SK_BLENDMODE,
 196     DSTIN_SK_BLENDMODE,
 197     SRCOUT_SK_BLENDMODE,
 198     DSTOUT_SK_BLENDMODE,
 199     SRCATOP_SK_BLENDMODE,
 200     DSTATOP_SK_BLENDMODE,
 201     XOR_SK_BLENDMODE,
 202     PLUS_SK_BLENDMODE,
 203     MODULATE_SK_BLENDMODE,
 204     SCREEN_SK_BLENDMODE,
 205     OVERLAY_SK_BLENDMODE,
 206     DARKEN_SK_BLENDMODE,
 207     LIGHTEN_SK_BLENDMODE,
 208     COLORDODGE_SK_BLENDMODE,
 209     COLORBURN_SK_BLENDMODE,
 210     HARDLIGHT_SK_BLENDMODE,
 211     SOFTLIGHT_SK_BLENDMODE,
 212     DIFFERENCE_SK_BLENDMODE,
 213     EXCLUSION_SK_BLENDMODE,
 214     MULTIPLY_SK_BLENDMODE,
 215     HUE_SK_BLENDMODE,
 216     SATURATION_SK_BLENDMODE,
 217     COLOR_SK_BLENDMODE,
 218     LUMINOSITY_SK_BLENDMODE,
 219 } sk_blendmode_t;
 220
 221 //////////////////////////////////////////////////////////////////////////////////////////
 222
 223 typedef struct {
 224     float   x;
 225     float   y;
 226     float   z;
 227 } sk_point3_t;
 228
 229 typedef struct {
 230     float   x;
 231     float   y;
 232 } sk_ipoint_t;
 233
 234 typedef struct {
 235     float   w;
 236     float   h;
 237 } sk_size_t;
 238
 239 typedef struct {
 240     float   w;
 241     float   h;
 242 } sk_isize_t;
 243
 244 typedef struct {
 245     uint32_t fFlags;            // Bit field to identify which values are unknown
 246     float    fTop;              // The greatest distance above the baseline for any glyph (will be <= 0)
 247     float    fAscent;           // The recommended distance above the baseline (will be <= 0)
 248     float    fDescent;          // The recommended distance below the baseline (will be >= 0)
 249     float    fBottom;           // The greatest distance below the baseline for any glyph (will be >= 0)
 250     float    fLeading;          // The recommended distance to add between lines of text (will be >= 0)
 251     float    fAvgCharWidth;     // the average character width (>= 0)
 252     float    fMaxCharWidth;     // the max character width (>= 0)
 253     float    fXMin;             // The minimum bounding box x value for all glyphs
 254     float    fXMax;             // The maximum bounding box x value for all glyphs
 255     float    fXHeight;          // The height of an 'x' in px, or 0 if no 'x' in face
 256     float    fCapHeight;        // The cap height (> 0), or 0 if cannot be determined.
 257     float    fUnderlineThickness; // underline thickness, or 0 if cannot be determined
 258     float    fUnderlinePosition; // underline position, or 0 if cannot be determined
 259 } sk_fontmetrics_t;
 260
 261 // Flags for fFlags member of sk_fontmetrics_t
 262 #define FONTMETRICS_FLAGS_UNDERLINE_THICKNESS_IS_VALID (1U << 0)
 263 #define FONTMETRICS_FLAGS_UNDERLINE_POSITION_IS_VALID (1U << 1)
 264
 265 /**
 266     A lightweight managed string.
 267 */
 268 typedef struct sk_string_t sk_string_t;
 269 /**
 270
 271     A sk_bitmap_t is an abstraction that specifies a raster bitmap.
 272 */
 273 typedef struct sk_bitmap_t sk_bitmap_t;
 274 typedef struct sk_colorfilter_t sk_colorfilter_t;
 275 typedef struct sk_imagefilter_t sk_imagefilter_t;
 276 typedef struct sk_imagefilter_croprect_t sk_imagefilter_croprect_t;
 277 /**
 278    A sk_typeface_t pecifies the typeface and intrinsic style of a font.
 279     This is used in the paint, along with optionally algorithmic settings like
 280     textSize, textSkewX, textScaleX, kFakeBoldText_Mask, to specify
 281     how text appears when drawn (and measured).
 282
 283     Typeface objects are immutable, and so they can be shared between threads.
 284 */
 285 typedef struct sk_typeface_t sk_typeface_t;
 286 typedef uint32_t sk_font_table_tag_t;
 287 /**
 288  *  Abstraction layer directly on top of an image codec.
 289  */
 290 typedef struct sk_codec_t sk_codec_t;
 291 typedef struct sk_colorspace_t sk_colorspace_t;
 292 /**
 293    Various stream types
 294 */
 295 typedef struct sk_stream_t sk_stream_t;
 296 typedef struct sk_stream_filestream_t sk_stream_filestream_t;
 297 typedef struct sk_stream_asset_t sk_stream_asset_t;
 298 typedef struct sk_stream_memorystream_t sk_stream_memorystream_t;
 299 typedef struct sk_stream_streamrewindable_t sk_stream_streamrewindable_t;
 300 typedef struct sk_wstream_t sk_wstream_t;
 301 typedef struct sk_wstream_filestream_t sk_wstream_filestream_t;
 302 typedef struct sk_wstream_dynamicmemorystream_t sk_wstream_dynamicmemorystream_t;
 303 /**
 304    High-level API for creating a document-based canvas.
 305 */
 306 typedef struct sk_document_t sk_document_t;
 307
 308 typedef enum {
 309     UTF8_ENCODING,
 310     UTF16_ENCODING,
 311     UTF32_ENCODING
 312 } sk_encoding_t;
 313
 314 typedef enum {
 315     POINTS_SK_POINT_MODE,
 316     LINES_SK_POINT_MODE,
 317     POLYGON_SK_POINT_MODE
 318 } sk_point_mode_t;
 319
 320 typedef enum {
 321     LEFT_SK_TEXT_ALIGN,
 322     CENTER_SK_TEXT_ALIGN,
 323     RIGHT_SK_TEXT_ALIGN
 324 } sk_text_align_t;
 325
 326 typedef enum {
 327     UTF8_SK_TEXT_ENCODING,
 328     UTF16_SK_TEXT_ENCODING,
 329     UTF32_SK_TEXT_ENCODING,
 330     GLYPH_ID_SK_TEXT_ENCODING
 331 } sk_text_encoding_t;
 332
 333 typedef enum {
 334     WINDING_SK_PATH_FILLTYPE,
 335     EVENODD_SK_PATH_FILLTYPE,
 336     INVERSE_WINDING_SK_PATH_FILLTYPE,
 337     INVERSE_EVENODD_SK_PATH_FILLTYPE,
 338 } sk_path_filltype_t;
 339
 340 typedef enum {
 341     NORMAL_TYPEFACE_STYLE      = 0,
 342     BOLD_TYPEFACE_STYLE        = 0x01,
 343     ITALIC_TYPEFACE_STYLE      = 0x02,
 344     BOLD_ITALIC_TYPEFACE_STYLE = 0x03
 345 } sk_typeface_style_t;
 346
 347 typedef enum {
 348     UPRIGHT_SK_FONT_STYLE_SLANT = 0,
 349     ITALIC_SK_FONT_STYLE_SLANT  = 1,
 350     OBLIQUE_SK_FONT_STYLE_SLANT = 2,
 351 } sk_font_style_slant_t;
 352
 353 typedef enum {
 354     NONE_SK_FILTER_QUALITY,
 355     LOW_SK_FILTER_QUALITY,
 356     MEDIUM_SK_FILTER_QUALITY,
 357     HIGH_SK_FILTER_QUALITY
 358 } sk_filter_quality_t;
 359
 360 typedef enum {
 361     HAS_LEFT_SK_CROP_RECT_FLAG   = 0x01,
 362     HAS_TOP_SK_CROP_RECT_FLAG    = 0x02,
 363     HAS_WIDTH_SK_CROP_RECT_FLAG  = 0x04,
 364     HAS_HEIGHT_SK_CROP_RECT_FLAG = 0x08,
 365     HAS_ALL_SK_CROP_RECT_FLAG    = 0x0F,
 366 } sk_crop_rect_flags_t;
 367
 368 typedef enum {
 369     DRAW_SHADOW_AND_FOREGROUND_SK_DROP_SHADOW_IMAGE_FILTER_SHADOW_MODE,
 370     DRAW_SHADOW_ONLY_SK_DROP_SHADOW_IMAGE_FILTER_SHADOW_MODE,
 371 } sk_drop_shadow_image_filter_shadow_mode_t;
 372
 373 typedef enum {
 374     UNKNOWN_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 375     R_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 376     G_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 377     B_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 378     A_SK_DISPLACEMENT_MAP_EFFECT_CHANNEL_SELECTOR_TYPE,
 379 } sk_displacement_map_effect_channel_selector_type_t;
 380
 381 typedef enum {
 382     UNKNOWN_SK_IMAGE_ENCODER_TYPE,
 383     BMP_SK_IMAGE_ENCODER_TYPE,
 384     GIF_SK_IMAGE_ENCODER_TYPE,
 385     ICO_SK_IMAGE_ENCODER_TYPE,
 386     JPEG_SK_IMAGE_ENCODER_TYPE,
 387     PNG_SK_IMAGE_ENCODER_TYPE,
 388     WBMP_SK_IMAGE_ENCODER_TYPE,
 389     WEBP_SK_IMAGE_ENCODER_TYPE,
 390     KTX_SK_IMAGE_ENCODER_TYPE,
 391 } sk_image_encoder_t;
 392
 393 typedef enum {
 394     CLAMP_SK_MATRIX_CONVOLUTION_TILEMODE,
 395     REPEAT_SK_MATRIX_CONVOLUTION_TILEMODE,
 396     CLAMP_TO_BLACK_SK_MATRIX_CONVOLUTION_TILEMODE,
 397 } sk_matrix_convolution_tilemode_t;
 398
 399 /**
 400     The logical operations that can be performed when combining two regions.
 401 */
 402 typedef enum {
 403     DIFFERENCE_SK_REGION_OP,          //!< subtract the op region from the first region
 404     INTERSECT_SK_REGION_OP,           //!< intersect the two regions
 405     UNION_SK_REGION_OP,               //!< union (inclusive-or) the two regions
 406     XOR_SK_REGION_OP,                 //!< exclusive-or the two regions
 407     REVERSE_DIFFERENCE_SK_REGION_OP,  //!< subtract the first region from the op region
 408     REPLACE_SK_REGION_OP,             //!< replace the dst region with the op region
 409 } sk_region_op_t;
 410
 411 typedef enum {
 412     DIFFERENCE_SK_CLIPOP,
 413     INTERSECT_SK_CLIPOP,
 414 } sk_clipop_t;
 415
 416 /**
 417  *  Enum describing format of encoded data.
 418  */
 419 typedef enum {
 420     UNKNOWN_SK_ENCODED_FORMAT,
 421     BMP_SK_ENCODED_FORMAT,
 422     GIF_SK_ENCODED_FORMAT,
 423     ICO_SK_ENCODED_FORMAT,
 424     JPEG_SK_ENCODED_FORMAT,
 425     PNG_SK_ENCODED_FORMAT,
 426     WBMP_SK_ENCODED_FORMAT,
 427     WEBP_SK_ENCODED_FORMAT,
 428     PKM_SK_ENCODED_FORMAT,
 429     KTX_SK_ENCODED_FORMAT,
 430     ASTC_SK_ENCODED_FORMAT,
 431     DNG_SK_ENCODED_FORMAT
 432 } sk_encoded_format_t;
 433
 434 typedef enum {
 435     TOP_LEFT_SK_CODEC_ORIGIN     = 1, // Default
 436     TOP_RIGHT_SK_CODEC_ORIGIN    = 2, // Reflected across y-axis
 437     BOTTOM_RIGHT_SK_CODEC_ORIGIN = 3, // Rotated 180
 438     BOTTOM_LEFT_SK_CODEC_ORIGIN  = 4, // Reflected across x-axis
 439     LEFT_TOP_SK_CODEC_ORIGIN     = 5, // Reflected across x-axis, Rotated 90 CCW
 440     RIGHT_TOP_SK_CODEC_ORIGIN    = 6, // Rotated 90 CW
 441     RIGHT_BOTTOM_SK_CODEC_ORIGIN = 7, // Reflected across x-axis, Rotated 90 CW
 442     LEFT_BOTTOM_SK_CODEC_ORIGIN  = 8, // Rotated 90 CCW
 443 } sk_codec_origin_t;
 444
 445 typedef enum {
 446     SUCCESS_SK_CODEC_RESULT,
 447     INCOMPLETE_INPUT_SK_CODEC_RESULT,
 448     INVALID_CONVERSION_SK_CODEC_RESULT,
 449     INVALID_SCALE_SK_CODEC_RESULT,
 450     INVALID_PARAMETERS_SK_CODEC_RESULT,
 451     INVALID_INPUT_SK_CODEC_RESULT,
 452     COULD_NOT_REWIND_SK_CODEC_RESULT,
 453     UNIMPLEMENTED_SK_CODEC_RESULT,
 454 } sk_codec_result_t;
 455
 456 typedef enum {
 457     YES_SK_CODEC_ZERO_INITIALIZED,
 458     NO_SK_CODEC_ZERO_INITIALIZED,
 459 } sk_codec_zero_initialized_t;
 460
 461 typedef struct {
 462     sk_codec_zero_initialized_t fZeroInitialized;
 463     sk_irect_t* fSubset;
 464     size_t fFrameIndex;
 465     bool fHasPriorFrame;
 466 } sk_codec_options_t;
 467
 468 // The verbs that can be foudn on a path
 469 typedef enum {
 470     MOVE_SK_PATH_VERB,
 471     LINE_SK_PATH_VERB,
 472     QUAD_SK_PATH_VERB,
 473     CONIC_SK_PATH_VERB,
 474     CUBIC_SK_PATH_VERB,
 475     CLOSE_SK_PATH_VERB,
 476     DONE_SK_PATH_VERB
 477 } sk_path_verb_t;
 478
 479 typedef struct sk_path_iterator_t sk_path_iterator_t;
 480 typedef struct sk_path_rawiterator_t sk_path_rawiterator_t;
 481
 482 typedef enum {
 483     APPEND_SK_PATH_ADD_MODE,
 484     EXTEND_SK_PATH_ADD_MODE,
 485 } sk_path_add_mode_t;
 486
 487 typedef enum {
 488     TRANSLATE_SK_PATH_EFFECT_1D_STYLE,
 489     ROTATE_SK_PATH_EFFECT_1D_STYLE,
 490     MORPH_SK_PATH_EFFECT_1D_STYLE,
 491 } sk_path_effect_1d_style_t;
 492
 493 typedef struct sk_path_effect_t sk_path_effect_t;
 494
 495 typedef enum {
 496     BUTT_SK_STROKE_CAP,
 497     ROUND_SK_STROKE_CAP,
 498     SQUARE_SK_STROKE_CAP
 499 } sk_stroke_cap_t;
 500
 501 typedef enum {
 502     MITER_SK_STROKE_JOIN,
 503     ROUND_SK_STROKE_JOIN,
 504     BEVEL_SK_STROKE_JOIN
 505 } sk_stroke_join_t;
 506
 507 typedef enum {
 508     CLAMP_SK_SHADER_TILEMODE,
 509     REPEAT_SK_SHADER_TILEMODE,
 510     MIRROR_SK_SHADER_TILEMODE,
 511 } sk_shader_tilemode_t;
 512
 513 typedef enum {
 514     NORMAL_SK_BLUR_STYLE,   //!< fuzzy inside and outside
 515     SOLID_SK_BLUR_STYLE,    //!< solid inside, fuzzy outside
 516     OUTER_SK_BLUR_STYLE,    //!< nothing inside, fuzzy outside
 517     INNER_SK_BLUR_STYLE,    //!< fuzzy inside, nothing outside
 518 } sk_blurstyle_t;
 519
 520 typedef enum {
 521     CW_SK_PATH_DIRECTION,
 522     CCW_SK_PATH_DIRECTION,
 523 } sk_path_direction_t;
 524
 525 typedef enum {
 526     SMALL_SK_PATH_ARC_SIZE,
 527     LARGE_SK_PATH_ARC_SIZE,
 528 } sk_path_arc_size_t;
 529
 530 typedef enum {
 531     FILL_SK_PAINT_STYLE,
 532     STROKE_SK_PAINT_STYLE,
 533     STROKE_AND_FILL_SK_PAINT_STYLE,
 534 } sk_paint_style_t;
 535
 536 typedef enum {
 537     NO_HINTING_SK_PAINT_HINTING,
 538     SLIGHT_HINTING_SK_PAINT_HINTING,
 539     NORMAL_HINTING_SK_PAINT_HINTING,
 540     FULL_HINTING_SK_PAINT_HINTING,
 541 } sk_paint_hinting_t;
 542
 543 typedef struct sk_colortable_t sk_colortable_t;
 544
 545 typedef struct sk_pixelref_factory_t sk_pixelref_factory_t;
 546
 547 typedef enum {
 548     TOP_LEFT_GR_SURFACE_ORIGIN = 1,
 549     BOTTOM_LEFT_GR_SURFACE_ORIGIN,
 550 } gr_surfaceorigin_t;
 551
 552 typedef enum {
 553     UNKNOWN_GR_PIXEL_CONFIG,
 554     ALPHA_8_GR_PIXEL_CONFIG,
 555     INDEX_8_GR_PIXEL_CONFIG,
 556     RGB_565_GR_PIXEL_CONFIG,
 557     RGBA_4444_GR_PIXEL_CONFIG,
 558     RGBA_8888_GR_PIXEL_CONFIG,
 559     BGRA_8888_GR_PIXEL_CONFIG,
 560     SRGBA_8888_GR_PIXEL_CONFIG,
 561     SBGRA_8888_GR_PIXEL_CONFIG,
 562     RGBA_8888_SINT_GR_PIXEL_CONFIG,
 563     ETC1_GR_PIXEL_CONFIG,
 564     LATC_GR_PIXEL_CONFIG,
 565     R11_EAC_GR_PIXEL_CONFIG,
 566     ASTC_12X12_GR_PIXEL_CONFIG,
 567     RGBA_FLOAT_GR_PIXEL_CONFIG,
 568     ALPHA_HALF_GR_PIXEL_CONFIG,
 569     RGBA_HALF_GR_PIXEL_CONFIG,
 570 } gr_pixelconfig_t;
 571
 572 typedef enum {
 573     NONE_GR_CONTEXT_FLUSHBITS = 0,
 574     DISCARD_GR_CONTEXT_FLUSHBITS = 0x2,
 575 } gr_context_flushbits_t;
 576
 577 typedef intptr_t gr_backendobject_t;
 578
 579 typedef struct {
 580     int fWidth;
 581     int fHeight;
 582     gr_pixelconfig_t fConfig;
 583     gr_surfaceorigin_t fOrigin;
 584     int fSampleCnt;
 585     int fStencilBits;
 586     gr_backendobject_t fRenderTargetHandle;
 587 } gr_backend_rendertarget_desc_t;
 588
 589 typedef enum {
 590     NONE_GR_BACKEND_TEXTURE_FLAGS = 0,
 591     RENDER_TARGET_GR_BACKEND_TEXTURE_FLAGS = 1,
 592 } gr_backendtexture_flags_t;
 593
 594 typedef struct {
 595     gr_backendtexture_flags_t fFlags;
 596     gr_surfaceorigin_t fOrigin;
 597     int fWidth;
 598     int fHeight;
 599     gr_pixelconfig_t fConfig;
 600     int fSampleCnt;
 601     gr_backendobject_t fTextureHandle;
 602 } gr_backend_texture_desc_t;
 603
 604 typedef struct gr_context_t gr_context_t;
 605
 606 typedef struct {
 607     bool fSuppressPrints;
 608     int  fMaxTextureSizeOverride;
 609     int  fMaxTileSizeOverride;
 610     bool fSuppressDualSourceBlending;
 611     int  fBufferMapThreshold;
 612     bool fUseDrawInsteadOfPartialRenderTargetWrite;
 613     bool fImmediateMode;
 614     bool fClipBatchToBounds;
 615     bool fDrawBatchBounds;
 616     int fMaxBatchLookback;
 617     int fMaxBatchLookahead;
 618     bool fUseShaderSwizzling;
 619     bool fDoManualMipmapping;
 620 } gr_context_options_t;
 621
 622 typedef enum {
 623     OPENGL_GR_BACKEND,
 624     VULKAN_GR_BACKEND,
 625 } gr_backend_t;
 626
 627 typedef intptr_t gr_backendcontext_t;
 628
 629 typedef struct gr_glinterface_t gr_glinterface_t;
 630
 631 typedef void (*gr_gl_func_ptr)();
 632 typedef gr_gl_func_ptr (*gr_gl_get_proc)(void* ctx, const char* name);
 633
 634 typedef enum {
 635     DIFFERENCE_SK_PATHOP,
 636     INTERSECT_SK_PATHOP,
 637     UNION_SK_PATHOP,
 638     XOR_SK_PATHOP,
 639     REVERSE_DIFFERENCE_SK_PATHOP,
 640 } sk_pathop_t;
 641
 642 typedef struct sk_opbuilder_t sk_opbuilder_t;
 643
 644 typedef enum {
 645     UNKNOWN_SK_PATH_CONVEXITY,
 646     CONVEX_SK_PATH_CONVEXITY,
 647     CONCAVE_SK_PATH_CONVEXITY,
 648 } sk_path_convexity_t;
 649
 650 typedef enum {
 651     DEFAULT_SK_LATTICE_FLAGS,
 652     TRANSPARENT_SK_LATTICE_FLAGS = 1 << 0,
 653 } sk_lattice_flags_t;
 654
 655 typedef struct {
 656     const int* fXDivs;
 657     const int* fYDivs;
 658     const sk_lattice_flags_t* fFlags;
 659     int fXCount;
 660     int fYCount;
 661     const sk_irect_t* fBounds;
 662 } sk_lattice_t;
 663
 664 typedef struct sk_pathmeasure_t sk_pathmeasure_t;
 665
 666 typedef enum {
 667     GET_POSITION_SK_PATHMEASURE_MATRIXFLAGS = 0x01,
 668     GET_TANGENT_SK_PATHMEASURE_MATRIXFLAGS = 0x02,
 669     GET_POS_AND_TAN_SK_PATHMEASURE_MATRIXFLAGS = GET_POSITION_SK_PATHMEASURE_MATRIXFLAGS | GET_TANGENT_SK_PATHMEASURE_MATRIXFLAGS,
 670 } sk_pathmeasure_matrixflags_t;
 671
 672 typedef void (*sk_bitmap_release_proc)(void* addr, void* context);
 673
 674 SK_C_PLUS_PLUS_END_GUARD
 675
 676 #endif