devel/usr/include/VG/openvg.h

   1 /*******************************************************************************
   2 *
   3 * Copyright (c) 2008 The Khronos Group Inc.
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a
   6 * copy of this software and /or associated documentation files
   7 * (the "Materials "), to deal in the Materials without restriction,
   8 * including without limitation the rights to use, copy, modify, merge,
   9 * publish, distribute, sublicense, and/or sell copies of the Materials,
  10 * and to permit persons to whom the Materials are furnished to do so,
  11 * subject to the following conditions:
  12 *
  13 * The above copyright notice and this permission notice shall be included
  14 * in all copies or substantial portions of the Materials.
  15 *
  16 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  19 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
  22 * THE USE OR OTHER DEALINGS IN THE MATERIALS.
  23 *
  24 *******************************************************************************/
  25
  26 #ifndef _OPENVG_H
  27 #define _OPENVG_H
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 #       ifdef _VG_EXPORTS
  34 #               define VG_API_CALL
  35 #       else
  36 #               define VG_API_CALL extern
  37 #       endif
  38 #       define VG_APIENTRY
  39 /*
  40 #include <khronos_types.h>
  41 */
  42
  43 #define OPENVG_VERSION_1_0 1
  44 #define OPENVG_VERSION_1_1 2
  45
  46 /*
  47 typedef khronos_float    VGfloat;
  48 typedef khronos_int8_t   VGbyte;
  49 typedef khronos_uint8_t  VGubyte;
  50 typedef khronos_int16_t  VGshort;
  51 typedef khronos_int32_t  VGint;
  52 typedef khronos_uint32_t VGuint;
  53 typedef khronos_uint32_t VGbitfield;
  54 */
  55
  56 typedef float            VGfloat;
  57 typedef signed char      VGbyte;
  58 typedef unsigned char    VGubyte;
  59 typedef short            VGshort;
  60 typedef int              VGint;
  61 typedef unsigned int     VGuint;
  62 typedef unsigned int     VGbitfield;
  63
  64 typedef enum {
  65   VG_FALSE = 0,
  66   VG_TRUE  = 1
  67 } VGboolean;
  68
  69 #define VG_MAXSHORT ((VGshort)((~((unsigned)0)) >> 1))
  70 #define VG_MAXINT ((VGint)((~((unsigned)0)) >> 1))
  71
  72 typedef VGuint VGHandle;
  73
  74 #define VG_INVALID_HANDLE ((VGHandle)0)
  75
  76 typedef enum {
  77   VG_NO_ERROR                                 = 0,
  78   VG_BAD_HANDLE_ERROR                         = 0x1000,
  79   VG_ILLEGAL_ARGUMENT_ERROR                   = 0x1001,
  80   VG_OUT_OF_MEMORY_ERROR                      = 0x1002,
  81   VG_PATH_CAPABILITY_ERROR                    = 0x1003,
  82   VG_UNSUPPORTED_IMAGE_FORMAT_ERROR           = 0x1004,
  83   VG_UNSUPPORTED_PATH_FORMAT_ERROR            = 0x1005,
  84   VG_IMAGE_IN_USE_ERROR                       = 0x1006,
  85   VG_NO_CONTEXT_ERROR                         = 0x1007
  86 } VGErrorCode;
  87
  88 typedef enum {
  89   /* Mode settings */
  90   VG_MATRIX_MODE                              = 0x1100,
  91   VG_FILL_RULE                                = 0x1101,
  92   VG_IMAGE_QUALITY                            = 0x1102,
  93   VG_RENDERING_QUALITY                        = 0x1103,
  94   VG_BLEND_MODE                               = 0x1104,
  95   VG_IMAGE_MODE                               = 0x1105,
  96
  97   /* Scissoring rectangles */
  98   VG_SCISSOR_RECTS                            = 0x1106,
  99
 100   /* Color Transformation */
 101   VG_COLOR_TRANSFORM                          = 0x1170,
 102   VG_COLOR_TRANSFORM_VALUES                   = 0x1171,
 103
 104   /* Stroke parameters */
 105   VG_STROKE_LINE_WIDTH                        = 0x1110,
 106   VG_STROKE_CAP_STYLE                         = 0x1111,
 107   VG_STROKE_JOIN_STYLE                        = 0x1112,
 108   VG_STROKE_MITER_LIMIT                       = 0x1113,
 109   VG_STROKE_DASH_PATTERN                      = 0x1114,
 110   VG_STROKE_DASH_PHASE                        = 0x1115,
 111   VG_STROKE_DASH_PHASE_RESET                  = 0x1116,
 112
 113   /* Edge fill color for VG_TILE_FILL tiling mode */
 114   VG_TILE_FILL_COLOR                          = 0x1120,
 115
 116   /* Color for vgClear */
 117   VG_CLEAR_COLOR                              = 0x1121,
 118
 119   /* Glyph origin */
 120   VG_GLYPH_ORIGIN                             = 0x1122,
 121
 122   /* Enable/disable alpha masking and scissoring */
 123   VG_MASKING                                  = 0x1130,
 124   VG_SCISSORING                               = 0x1131,
 125
 126   /* Pixel layout information */
 127   VG_PIXEL_LAYOUT                             = 0x1140,
 128   VG_SCREEN_LAYOUT                            = 0x1141,
 129
 130   /* Source format selection for image filters */
 131   VG_FILTER_FORMAT_LINEAR                     = 0x1150,
 132   VG_FILTER_FORMAT_PREMULTIPLIED              = 0x1151,
 133
 134   /* Destination write enable mask for image filters */
 135   VG_FILTER_CHANNEL_MASK                      = 0x1152,
 136
 137   /* Implementation limits (read-only) */
 138   VG_MAX_SCISSOR_RECTS                        = 0x1160,
 139   VG_MAX_DASH_COUNT                           = 0x1161,
 140   VG_MAX_KERNEL_SIZE                          = 0x1162,
 141   VG_MAX_SEPARABLE_KERNEL_SIZE                = 0x1163,
 142   VG_MAX_COLOR_RAMP_STOPS                     = 0x1164,
 143   VG_MAX_IMAGE_WIDTH                          = 0x1165,
 144   VG_MAX_IMAGE_HEIGHT                         = 0x1166,
 145   VG_MAX_IMAGE_PIXELS                         = 0x1167,
 146   VG_MAX_IMAGE_BYTES                          = 0x1168,
 147   VG_MAX_FLOAT                                = 0x1169,
 148   VG_MAX_GAUSSIAN_STD_DEVIATION               = 0x116A
 149 } VGParamType;
 150
 151 typedef enum {
 152   VG_RENDERING_QUALITY_NONANTIALIASED         = 0x1200,
 153   VG_RENDERING_QUALITY_FASTER                 = 0x1201,
 154   VG_RENDERING_QUALITY_BETTER                 = 0x1202  /* Default */
 155 } VGRenderingQuality;
 156
 157 typedef enum {
 158   VG_PIXEL_LAYOUT_UNKNOWN                     = 0x1300,
 159   VG_PIXEL_LAYOUT_RGB_VERTICAL                = 0x1301,
 160   VG_PIXEL_LAYOUT_BGR_VERTICAL                = 0x1302,
 161   VG_PIXEL_LAYOUT_RGB_HORIZONTAL              = 0x1303,
 162   VG_PIXEL_LAYOUT_BGR_HORIZONTAL              = 0x1304
 163 } VGPixelLayout;
 164
 165 typedef enum {
 166   VG_MATRIX_PATH_USER_TO_SURFACE              = 0x1400,
 167   VG_MATRIX_IMAGE_USER_TO_SURFACE             = 0x1401,
 168   VG_MATRIX_FILL_PAINT_TO_USER                = 0x1402,
 169   VG_MATRIX_STROKE_PAINT_TO_USER              = 0x1403,
 170   VG_MATRIX_GLYPH_USER_TO_SURFACE             = 0x1404
 171 } VGMatrixMode;
 172
 173 typedef enum {
 174   VG_CLEAR_MASK                               = 0x1500,
 175   VG_FILL_MASK                                = 0x1501,
 176   VG_SET_MASK                                 = 0x1502,
 177   VG_UNION_MASK                               = 0x1503,
 178   VG_INTERSECT_MASK                           = 0x1504,
 179   VG_SUBTRACT_MASK                            = 0x1505
 180 } VGMaskOperation;
 181
 182 #define VG_PATH_FORMAT_STANDARD 0
 183
 184 typedef enum {
 185   VG_PATH_DATATYPE_S_8                        =  0,
 186   VG_PATH_DATATYPE_S_16                       =  1,
 187   VG_PATH_DATATYPE_S_32                       =  2,
 188   VG_PATH_DATATYPE_F                          =  3
 189 } VGPathDatatype;
 190
 191 typedef enum {
 192   VG_ABSOLUTE                                 = 0,
 193   VG_RELATIVE                                 = 1
 194 } VGPathAbsRel;
 195
 196 typedef enum {
 197   VG_CLOSE_PATH                               = ( 0 << 1),
 198   VG_MOVE_TO                                  = ( 1 << 1),
 199   VG_LINE_TO                                  = ( 2 << 1),
 200   VG_HLINE_TO                                 = ( 3 << 1),
 201   VG_VLINE_TO                                 = ( 4 << 1),
 202   VG_QUAD_TO                                  = ( 5 << 1),
 203   VG_CUBIC_TO                                 = ( 6 << 1),
 204   VG_SQUAD_TO                                 = ( 7 << 1),
 205   VG_SCUBIC_TO                                = ( 8 << 1),
 206   VG_SCCWARC_TO                               = ( 9 << 1),
 207   VG_SCWARC_TO                                = (10 << 1),
 208   VG_LCCWARC_TO                               = (11 << 1),
 209   VG_LCWARC_TO                                = (12 << 1)
 210 } VGPathSegment;
 211
 212 typedef enum {
 213   VG_MOVE_TO_ABS                              = VG_MOVE_TO    | VG_ABSOLUTE,
 214   VG_MOVE_TO_REL                              = VG_MOVE_TO    | VG_RELATIVE,
 215   VG_LINE_TO_ABS                              = VG_LINE_TO    | VG_ABSOLUTE,
 216   VG_LINE_TO_REL                              = VG_LINE_TO    | VG_RELATIVE,
 217   VG_HLINE_TO_ABS                             = VG_HLINE_TO   | VG_ABSOLUTE,
 218   VG_HLINE_TO_REL                             = VG_HLINE_TO   | VG_RELATIVE,
 219   VG_VLINE_TO_ABS                             = VG_VLINE_TO   | VG_ABSOLUTE,
 220   VG_VLINE_TO_REL                             = VG_VLINE_TO   | VG_RELATIVE,
 221   VG_QUAD_TO_ABS                              = VG_QUAD_TO    | VG_ABSOLUTE,
 222   VG_QUAD_TO_REL                              = VG_QUAD_TO    | VG_RELATIVE,
 223   VG_CUBIC_TO_ABS                             = VG_CUBIC_TO   | VG_ABSOLUTE,
 224   VG_CUBIC_TO_REL                             = VG_CUBIC_TO   | VG_RELATIVE,
 225   VG_SQUAD_TO_ABS                             = VG_SQUAD_TO   | VG_ABSOLUTE,
 226   VG_SQUAD_TO_REL                             = VG_SQUAD_TO   | VG_RELATIVE,
 227   VG_SCUBIC_TO_ABS                            = VG_SCUBIC_TO  | VG_ABSOLUTE,
 228   VG_SCUBIC_TO_REL                            = VG_SCUBIC_TO  | VG_RELATIVE,
 229   VG_SCCWARC_TO_ABS                           = VG_SCCWARC_TO | VG_ABSOLUTE,
 230   VG_SCCWARC_TO_REL                           = VG_SCCWARC_TO | VG_RELATIVE,
 231   VG_SCWARC_TO_ABS                            = VG_SCWARC_TO  | VG_ABSOLUTE,
 232   VG_SCWARC_TO_REL                            = VG_SCWARC_TO  | VG_RELATIVE,
 233   VG_LCCWARC_TO_ABS                           = VG_LCCWARC_TO | VG_ABSOLUTE,
 234   VG_LCCWARC_TO_REL                           = VG_LCCWARC_TO | VG_RELATIVE,
 235   VG_LCWARC_TO_ABS                            = VG_LCWARC_TO  | VG_ABSOLUTE,
 236   VG_LCWARC_TO_REL                            = VG_LCWARC_TO  | VG_RELATIVE
 237 } VGPathCommand;
 238
 239 typedef VGHandle VGPath;
 240
 241 typedef enum {
 242   VG_PATH_CAPABILITY_APPEND_FROM              = (1 <<  0),
 243   VG_PATH_CAPABILITY_APPEND_TO                = (1 <<  1),
 244   VG_PATH_CAPABILITY_MODIFY                   = (1 <<  2),
 245   VG_PATH_CAPABILITY_TRANSFORM_FROM           = (1 <<  3),
 246   VG_PATH_CAPABILITY_TRANSFORM_TO             = (1 <<  4),
 247   VG_PATH_CAPABILITY_INTERPOLATE_FROM         = (1 <<  5),
 248   VG_PATH_CAPABILITY_INTERPOLATE_TO           = (1 <<  6),
 249   VG_PATH_CAPABILITY_PATH_LENGTH              = (1 <<  7),
 250   VG_PATH_CAPABILITY_POINT_ALONG_PATH         = (1 <<  8),
 251   VG_PATH_CAPABILITY_TANGENT_ALONG_PATH       = (1 <<  9),
 252   VG_PATH_CAPABILITY_PATH_BOUNDS              = (1 << 10),
 253   VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS  = (1 << 11),
 254   VG_PATH_CAPABILITY_ALL                      = (1 << 12) - 1
 255 } VGPathCapabilities;
 256
 257 typedef enum {
 258   VG_PATH_FORMAT                              = 0x1600,
 259   VG_PATH_DATATYPE                            = 0x1601,
 260   VG_PATH_SCALE                               = 0x1602,
 261   VG_PATH_BIAS                                = 0x1603,
 262   VG_PATH_NUM_SEGMENTS                        = 0x1604,
 263   VG_PATH_NUM_COORDS                          = 0x1605
 264 } VGPathParamType;
 265
 266 typedef enum {
 267   VG_CAP_BUTT                                 = 0x1700,
 268   VG_CAP_ROUND                                = 0x1701,
 269   VG_CAP_SQUARE                               = 0x1702
 270 } VGCapStyle;
 271
 272 typedef enum {
 273   VG_JOIN_MITER                               = 0x1800,
 274   VG_JOIN_ROUND                               = 0x1801,
 275   VG_JOIN_BEVEL                               = 0x1802
 276 } VGJoinStyle;
 277
 278 typedef enum {
 279   VG_EVEN_ODD                                 = 0x1900,
 280   VG_NON_ZERO                                 = 0x1901
 281 } VGFillRule;
 282
 283 typedef enum {
 284   VG_STROKE_PATH                              = (1 << 0),
 285   VG_FILL_PATH                                = (1 << 1)
 286 } VGPaintMode;
 287
 288 typedef VGHandle VGPaint;
 289
 290 typedef enum {
 291   /* Color paint parameters */
 292   VG_PAINT_TYPE                               = 0x1A00,
 293   VG_PAINT_COLOR                              = 0x1A01,
 294   VG_PAINT_COLOR_RAMP_SPREAD_MODE             = 0x1A02,
 295   VG_PAINT_COLOR_RAMP_PREMULTIPLIED           = 0x1A07,
 296   VG_PAINT_COLOR_RAMP_STOPS                   = 0x1A03,
 297
 298   /* Linear gradient paint parameters */
 299   VG_PAINT_LINEAR_GRADIENT                    = 0x1A04,
 300
 301   /* Radial gradient paint parameters */
 302   VG_PAINT_RADIAL_GRADIENT                    = 0x1A05,
 303
 304   /* Pattern paint parameters */
 305   VG_PAINT_PATTERN_TILING_MODE                = 0x1A06
 306 } VGPaintParamType;
 307
 308 typedef enum {
 309   VG_PAINT_TYPE_COLOR                         = 0x1B00,
 310   VG_PAINT_TYPE_LINEAR_GRADIENT               = 0x1B01,
 311   VG_PAINT_TYPE_RADIAL_GRADIENT               = 0x1B02,
 312   VG_PAINT_TYPE_PATTERN                       = 0x1B03
 313 } VGPaintType;
 314
 315 typedef enum {
 316   VG_COLOR_RAMP_SPREAD_PAD                    = 0x1C00,
 317   VG_COLOR_RAMP_SPREAD_REPEAT                 = 0x1C01,
 318   VG_COLOR_RAMP_SPREAD_REFLECT                = 0x1C02
 319 } VGColorRampSpreadMode;
 320
 321 typedef enum {
 322   VG_TILE_FILL                                = 0x1D00,
 323   VG_TILE_PAD                                 = 0x1D01,
 324   VG_TILE_REPEAT                              = 0x1D02,
 325   VG_TILE_REFLECT                             = 0x1D03
 326 } VGTilingMode;
 327
 328 typedef enum {
 329   /* RGB{A,X} channel ordering */
 330   VG_sRGBX_8888                               =  0,
 331   VG_sRGBA_8888                               =  1,
 332   VG_sRGBA_8888_PRE                           =  2,
 333   VG_sRGB_565                                 =  3,
 334   VG_sRGBA_5551                               =  4,
 335   VG_sRGBA_4444                               =  5,
 336   VG_sL_8                                     =  6,
 337   VG_lRGBX_8888                               =  7,
 338   VG_lRGBA_8888                               =  8,
 339   VG_lRGBA_8888_PRE                           =  9,
 340   VG_lL_8                                     = 10,
 341   VG_A_8                                      = 11,
 342   VG_BW_1                                     = 12,
 343   VG_A_1                                      = 13,
 344   VG_A_4                                      = 14,
 345
 346   /* {A,X}RGB channel ordering */
 347   VG_sXRGB_8888                               =  0 | (1 << 6),
 348   VG_sARGB_8888                               =  1 | (1 << 6),
 349   VG_sARGB_8888_PRE                           =  2 | (1 << 6),
 350   VG_sARGB_1555                               =  4 | (1 << 6),
 351   VG_sARGB_4444                               =  5 | (1 << 6),
 352   VG_lXRGB_8888                               =  7 | (1 << 6),
 353   VG_lARGB_8888                               =  8 | (1 << 6),
 354   VG_lARGB_8888_PRE                           =  9 | (1 << 6),
 355
 356   /* BGR{A,X} channel ordering */
 357   VG_sBGRX_8888                               =  0 | (1 << 7),
 358   VG_sBGRA_8888                               =  1 | (1 << 7),
 359   VG_sBGRA_8888_PRE                           =  2 | (1 << 7),
 360   VG_sBGR_565                                 =  3 | (1 << 7),
 361   VG_sBGRA_5551                               =  4 | (1 << 7),
 362   VG_sBGRA_4444                               =  5 | (1 << 7),
 363   VG_lBGRX_8888                               =  7 | (1 << 7),
 364   VG_lBGRA_8888                               =  8 | (1 << 7),
 365   VG_lBGRA_8888_PRE                           =  9 | (1 << 7),
 366
 367   /* {A,X}BGR channel ordering */
 368   VG_sXBGR_8888                               =  0 | (1 << 6) | (1 << 7),
 369   VG_sABGR_8888                               =  1 | (1 << 6) | (1 << 7),
 370   VG_sABGR_8888_PRE                           =  2 | (1 << 6) | (1 << 7),
 371   VG_sABGR_1555                               =  4 | (1 << 6) | (1 << 7),
 372   VG_sABGR_4444                               =  5 | (1 << 6) | (1 << 7),
 373   VG_lXBGR_8888                               =  7 | (1 << 6) | (1 << 7),
 374   VG_lABGR_8888                               =  8 | (1 << 6) | (1 << 7),
 375   VG_lABGR_8888_PRE                           =  9 | (1 << 6) | (1 << 7)
 376 } VGImageFormat;
 377
 378 typedef VGHandle VGImage;
 379
 380 typedef enum {
 381   VG_IMAGE_QUALITY_NONANTIALIASED             = (1 << 0),
 382   VG_IMAGE_QUALITY_FASTER                     = (1 << 1),
 383   VG_IMAGE_QUALITY_BETTER                     = (1 << 2)
 384 } VGImageQuality;
 385
 386 typedef enum {
 387   VG_IMAGE_FORMAT                             = 0x1E00,
 388   VG_IMAGE_WIDTH                              = 0x1E01,
 389   VG_IMAGE_HEIGHT                             = 0x1E02
 390 } VGImageParamType;
 391
 392 typedef enum {
 393   VG_DRAW_IMAGE_NORMAL                        = 0x1F00,
 394   VG_DRAW_IMAGE_MULTIPLY                      = 0x1F01,
 395   VG_DRAW_IMAGE_STENCIL                       = 0x1F02
 396 } VGImageMode;
 397
 398 typedef enum {
 399   VG_RED                                      = (1 << 3),
 400   VG_GREEN                                    = (1 << 2),
 401   VG_BLUE                                     = (1 << 1),
 402   VG_ALPHA                                    = (1 << 0)
 403 } VGImageChannel;
 404
 405 typedef enum {
 406   VG_BLEND_SRC                                = 0x2000,
 407   VG_BLEND_SRC_OVER                           = 0x2001,
 408   VG_BLEND_DST_OVER                           = 0x2002,
 409   VG_BLEND_SRC_IN                             = 0x2003,
 410   VG_BLEND_DST_IN                             = 0x2004,
 411   VG_BLEND_MULTIPLY                           = 0x2005,
 412   VG_BLEND_SCREEN                             = 0x2006,
 413   VG_BLEND_DARKEN                             = 0x2007,
 414   VG_BLEND_LIGHTEN                            = 0x2008,
 415   VG_BLEND_ADDITIVE                           = 0x2009
 416 } VGBlendMode;
 417
 418 typedef enum {
 419   VG_IMAGE_FORMAT_QUERY                       = 0x2100,
 420   VG_PATH_DATATYPE_QUERY                      = 0x2101
 421 } VGHardwareQueryType;
 422
 423 typedef enum {
 424   VG_HARDWARE_ACCELERATED                     = 0x2200,
 425   VG_HARDWARE_UNACCELERATED                   = 0x2201
 426 } VGHardwareQueryResult;
 427
 428 typedef enum {
 429   VG_VENDOR                                   = 0x2300,
 430   VG_RENDERER                                 = 0x2301,
 431   VG_VERSION                                  = 0x2302,
 432   VG_EXTENSIONS                               = 0x2303
 433 } VGStringID;
 434
 435 typedef enum {
 436   VG_FONT_NUM_GLYPHS                          = 0x2F00
 437 } VGFontParamType;
 438
 439
 440 /* Function Prototypes */
 441
 442 #ifndef VG_API_CALL
 443 #define VG_API_CALL extern
 444 #endif
 445 #ifndef VG_APIENTRY
 446 #define VG_APIENTRY IMG_CALLCONV
 447 #endif
 448
 449 VG_API_CALL VGErrorCode VG_APIENTRY vgGetError(void);
 450
 451 VG_API_CALL void VG_APIENTRY vgFlush(void);
 452 VG_API_CALL void VG_APIENTRY vgFinish(void);
 453
 454 /* Getters and Setters */
 455 VG_API_CALL void VG_APIENTRY vgSetf (VGParamType type, VGfloat value);
 456 VG_API_CALL void VG_APIENTRY vgSeti (VGParamType type, VGint value);
 457 VG_API_CALL void VG_APIENTRY vgSetfv(VGParamType type, VGint count,
 458                          const VGfloat * values);
 459 VG_API_CALL void VG_APIENTRY vgSetiv(VGParamType type, VGint count,
 460                          const VGint * values);
 461
 462 VG_API_CALL VGfloat VG_APIENTRY vgGetf(VGParamType type);
 463 VG_API_CALL VGint   VG_APIENTRY vgGeti(VGParamType type);
 464 VG_API_CALL VGint   VG_APIENTRY vgGetVectorSize(VGParamType type);
 465 VG_API_CALL void    VG_APIENTRY vgGetfv(VGParamType type, VGint count, VGfloat * values);
 466 VG_API_CALL void    VG_APIENTRY vgGetiv(VGParamType type, VGint count, VGint * values);
 467
 468 VG_API_CALL void VG_APIENTRY vgSetParameterf(VGHandle object,
 469                                  VGint paramType,
 470                                  VGfloat value);
 471 VG_API_CALL void VG_APIENTRY vgSetParameteri(VGHandle object,
 472                                  VGint paramType,
 473                                  VGint value);
 474 VG_API_CALL void VG_APIENTRY vgSetParameterfv(VGHandle object,
 475                                   VGint paramType,
 476                                   VGint count, const VGfloat * values);
 477 VG_API_CALL void VG_APIENTRY vgSetParameteriv(VGHandle object,
 478                                   VGint paramType,
 479                                   VGint count, const VGint * values);
 480
 481 VG_API_CALL VGfloat VG_APIENTRY vgGetParameterf(VGHandle object,
 482                                     VGint paramType);
 483 VG_API_CALL VGint VG_APIENTRY vgGetParameteri(VGHandle object,
 484                                   VGint paramType);
 485 VG_API_CALL VGint VG_APIENTRY vgGetParameterVectorSize(VGHandle object,
 486                                            VGint paramType);
 487 VG_API_CALL void VG_APIENTRY vgGetParameterfv(VGHandle object,
 488                                   VGint paramType,
 489                                   VGint count, VGfloat * values);
 490 VG_API_CALL void VG_APIENTRY vgGetParameteriv(VGHandle object,
 491                                   VGint paramType,
 492                                   VGint count, VGint * values);
 493
 494 /* Matrix Manipulation */
 495 VG_API_CALL void VG_APIENTRY vgLoadIdentity(void);
 496 VG_API_CALL void VG_APIENTRY vgLoadMatrix(const VGfloat * m);
 497 VG_API_CALL void VG_APIENTRY vgGetMatrix(VGfloat * m);
 498 VG_API_CALL void VG_APIENTRY vgMultMatrix(const VGfloat * m);
 499 VG_API_CALL void VG_APIENTRY vgTranslate(VGfloat tx, VGfloat ty);
 500 VG_API_CALL void VG_APIENTRY vgScale(VGfloat sx, VGfloat sy);
 501 VG_API_CALL void VG_APIENTRY vgShear(VGfloat shx, VGfloat shy);
 502 VG_API_CALL void VG_APIENTRY vgRotate(VGfloat angle);
 503
 504 /* Masking and Clearing */
 505 typedef VGHandle VGMaskLayer;
 506
 507 VG_API_CALL void VG_APIENTRY vgMask(VGHandle mask, VGMaskOperation operation,
 508                                                                         VGint x, VGint y,
 509                                                                         VGint width, VGint height);
 510 VG_API_CALL void VG_APIENTRY vgRenderToMask(VGPath path,
 511                                                                                         VGbitfield paintModes,
 512                                                                                         VGMaskOperation operation);
 513 VG_API_CALL VGMaskLayer VG_APIENTRY vgCreateMaskLayer(VGint width, VGint height);
 514 VG_API_CALL void VG_APIENTRY vgDestroyMaskLayer(VGMaskLayer maskLayer);
 515 VG_API_CALL void VG_APIENTRY vgFillMaskLayer(VGMaskLayer maskLayer,
 516                                                                                          VGint x, VGint y,
 517                                                                                          VGint width, VGint height,
 518                                                                                          VGfloat value);
 519 VG_API_CALL void VG_APIENTRY vgCopyMask(VGMaskLayer maskLayer,
 520                                                                                 VGint dx, VGint dy,
 521                                                                                 VGint sx, VGint sy,
 522                                                                                 VGint width, VGint height);
 523 VG_API_CALL void VG_APIENTRY vgClear(VGint x, VGint y, VGint width, VGint height);
 524
 525 /* Paths */
 526 VG_API_CALL VGPath VG_APIENTRY vgCreatePath(VGint pathFormat,
 527                                 VGPathDatatype datatype,
 528                                 VGfloat scale, VGfloat bias,
 529                                 VGint segmentCapacityHint,
 530                                 VGint coordCapacityHint,
 531                                 VGbitfield capabilities);
 532 VG_API_CALL void VG_APIENTRY vgClearPath(VGPath path, VGbitfield capabilities);
 533 VG_API_CALL void VG_APIENTRY vgDestroyPath(VGPath path);
 534 VG_API_CALL void VG_APIENTRY vgRemovePathCapabilities(VGPath path,
 535                                           VGbitfield capabilities);
 536 VG_API_CALL VGbitfield VG_APIENTRY vgGetPathCapabilities(VGPath path);
 537 VG_API_CALL void VG_APIENTRY vgAppendPath(VGPath dstPath, VGPath srcPath);
 538 VG_API_CALL void VG_APIENTRY vgAppendPathData(VGPath dstPath,
 539                                   VGint numSegments,
 540                                   const VGubyte * pathSegments,
 541                                   const void * pathData);
 542 VG_API_CALL void VG_APIENTRY vgModifyPathCoords(VGPath dstPath, VGint startIndex,
 543                                     VGint numSegments,
 544                                     const void * pathData);
 545 VG_API_CALL void VG_APIENTRY vgTransformPath(VGPath dstPath, VGPath srcPath);
 546 VG_API_CALL VGboolean VG_APIENTRY vgInterpolatePath(VGPath dstPath,
 547                                         VGPath startPath,
 548                                         VGPath endPath,
 549                                         VGfloat amount);
 550 VG_API_CALL VGfloat VG_APIENTRY vgPathLength(VGPath path,
 551                                  VGint startSegment, VGint numSegments);
 552 VG_API_CALL void VG_APIENTRY vgPointAlongPath(VGPath path,
 553                                   VGint startSegment, VGint numSegments,
 554                                   VGfloat distance,
 555                                   VGfloat * x, VGfloat * y,
 556                                   VGfloat * tangentX, VGfloat * tangentY);
 557 VG_API_CALL void VG_APIENTRY vgPathBounds(VGPath path,
 558                               VGfloat * minX, VGfloat * minY,
 559                               VGfloat * width, VGfloat * height);
 560 VG_API_CALL void VG_APIENTRY vgPathTransformedBounds(VGPath path,
 561                                          VGfloat * minX, VGfloat * minY,
 562                                          VGfloat * width, VGfloat * height);
 563 VG_API_CALL void VG_APIENTRY vgDrawPath(VGPath path, VGbitfield paintModes);
 564
 565 /* Paint */
 566 VG_API_CALL VGPaint VG_APIENTRY vgCreatePaint(void);
 567 VG_API_CALL void VG_APIENTRY vgDestroyPaint(VGPaint paint);
 568 VG_API_CALL void VG_APIENTRY vgSetPaint(VGPaint paint, VGbitfield paintModes);
 569 VG_API_CALL VGPaint VG_APIENTRY vgGetPaint(VGPaintMode paintMode);
 570 VG_API_CALL void VG_APIENTRY vgSetColor(VGPaint paint, VGuint rgba);
 571 VG_API_CALL VGuint VG_APIENTRY vgGetColor(VGPaint paint);
 572 VG_API_CALL void VG_APIENTRY vgPaintPattern(VGPaint paint, VGImage pattern);
 573
 574 /* Images */
 575 VG_API_CALL VGImage VG_APIENTRY vgCreateImage(VGImageFormat format,
 576                                   VGint width, VGint height,
 577                                   VGbitfield allowedQuality);
 578 VG_API_CALL void VG_APIENTRY vgDestroyImage(VGImage image);
 579 VG_API_CALL void VG_APIENTRY vgClearImage(VGImage image,
 580                               VGint x, VGint y, VGint width, VGint height);
 581 VG_API_CALL void VG_APIENTRY vgImageSubData(VGImage image,
 582                                 const void * data, VGint dataStride,
 583                                 VGImageFormat dataFormat,
 584                                 VGint x, VGint y, VGint width, VGint height);
 585 VG_API_CALL void VG_APIENTRY vgGetImageSubData(VGImage image,
 586                                    void * data, VGint dataStride,
 587                                    VGImageFormat dataFormat,
 588                                    VGint x, VGint y,
 589                                    VGint width, VGint height);
 590 VG_API_CALL VGImage VG_APIENTRY vgChildImage(VGImage parent,
 591                                  VGint x, VGint y, VGint width, VGint height);
 592 VG_API_CALL VGImage VG_APIENTRY vgGetParent(VGImage image);
 593 VG_API_CALL void VG_APIENTRY vgCopyImage(VGImage dst, VGint dx, VGint dy,
 594                              VGImage src, VGint sx, VGint sy,
 595                              VGint width, VGint height,
 596                              VGboolean dither);
 597 VG_API_CALL void VG_APIENTRY vgDrawImage(VGImage image);
 598 VG_API_CALL void VG_APIENTRY vgSetPixels(VGint dx, VGint dy,
 599                              VGImage src, VGint sx, VGint sy,
 600                              VGint width, VGint height);
 601 VG_API_CALL void VG_APIENTRY vgWritePixels(const void * data, VGint dataStride,
 602                                VGImageFormat dataFormat,
 603                                VGint dx, VGint dy,
 604                                VGint width, VGint height);
 605 VG_API_CALL void VG_APIENTRY vgGetPixels(VGImage dst, VGint dx, VGint dy,
 606                              VGint sx, VGint sy,
 607                              VGint width, VGint height);
 608 VG_API_CALL void VG_APIENTRY vgReadPixels(void * data, VGint dataStride,
 609                               VGImageFormat dataFormat,
 610                               VGint sx, VGint sy,
 611                               VGint width, VGint height);
 612 VG_API_CALL void VG_APIENTRY vgCopyPixels(VGint dx, VGint dy,
 613                               VGint sx, VGint sy,
 614                               VGint width, VGint height);
 615
 616 /* Text */
 617 typedef VGHandle VGFont;
 618
 619 VG_API_CALL VGFont VG_APIENTRY vgCreateFont(VGint glyphCapacityHint);
 620 VG_API_CALL void VG_APIENTRY vgDestroyFont(VGFont font);
 621 VG_API_CALL void VG_APIENTRY vgSetGlyphToPath(VGFont font,
 622                                               VGuint glyphIndex,
 623                                               VGPath path,
 624                                               VGboolean isHinted,
 625                                               const VGfloat glyphOrigin [2],
 626                                               const VGfloat escapement[2]);
 627 VG_API_CALL void VG_APIENTRY vgSetGlyphToImage(VGFont font,
 628                                                VGuint glyphIndex,
 629                                                VGImage image,
 630                                                const VGfloat glyphOrigin [2],
 631                                                const VGfloat escapement[2]);
 632 VG_API_CALL void VG_APIENTRY vgClearGlyph(VGFont font, VGuint glyphIndex);
 633 VG_API_CALL void VG_APIENTRY vgDrawGlyph(VGFont font,
 634                                          VGuint glyphIndex,
 635                                          VGbitfield paintModes,
 636                                          VGboolean allowAutoHinting);
 637 VG_API_CALL void VG_APIENTRY vgDrawGlyphs(VGFont font,
 638                                           VGint glyphCount,
 639                                           const VGuint *glyphIndices,
 640                                           const VGfloat *adjustments_x,
 641                                           const VGfloat *adjustments_y,
 642                                           VGbitfield paintModes,
 643                                           VGboolean allowAutoHinting);
 644
 645 /* Image Filters */
 646 VG_API_CALL void VG_APIENTRY vgColorMatrix(VGImage dst, VGImage src,
 647                                const VGfloat * matrix);
 648 VG_API_CALL void VG_APIENTRY vgConvolve(VGImage dst, VGImage src,
 649                             VGint kernelWidth, VGint kernelHeight,
 650                             VGint shiftX, VGint shiftY,
 651                             const VGshort * kernel,
 652                             VGfloat scale,
 653                             VGfloat bias,
 654                             VGTilingMode tilingMode);
 655 VG_API_CALL void VG_APIENTRY vgSeparableConvolve(VGImage dst, VGImage src,
 656                                      VGint kernelWidth,
 657                                      VGint kernelHeight,
 658                                      VGint shiftX, VGint shiftY,
 659                                      const VGshort * kernelX,
 660                                      const VGshort * kernelY,
 661                                      VGfloat scale,
 662                                      VGfloat bias,
 663                                      VGTilingMode tilingMode);
 664 VG_API_CALL void VG_APIENTRY vgGaussianBlur(VGImage dst, VGImage src,
 665                                 VGfloat stdDeviationX,
 666                                 VGfloat stdDeviationY,
 667                                 VGTilingMode tilingMode);
 668 VG_API_CALL void VG_APIENTRY vgLookup(VGImage dst, VGImage src,
 669                           const VGubyte * redLUT,
 670                           const VGubyte * greenLUT,
 671                           const VGubyte * blueLUT,
 672                           const VGubyte * alphaLUT,
 673                           VGboolean outputLinear,
 674                           VGboolean outputPremultiplied);
 675 VG_API_CALL void VG_APIENTRY vgLookupSingle(VGImage dst, VGImage src,
 676                                 const VGuint * lookupTable,
 677                                 VGImageChannel sourceChannel,
 678                                 VGboolean outputLinear,
 679                                 VGboolean outputPremultiplied);
 680
 681 /* Hardware Queries */
 682 VG_API_CALL VGHardwareQueryResult VG_APIENTRY vgHardwareQuery(VGHardwareQueryType key,
 683                                                   VGint setting);
 684
 685 /* Renderer and Extension Information */
 686 VG_API_CALL const VGubyte * VG_APIENTRY vgGetString(VGStringID name);
 687
 688 #ifdef __cplusplus
 689 } /* extern "C" */
 690 #endif
 691
 692 #endif /* _OPENVG_H */