test: epoc32/include/VG/1.0/openvg.h@e1b950c65cb4

     1 /*------------------------------------------------------------------------

     2  *

     3  * OpenVG 1.1 Reference Implementation

     4  * -------------------------------------

     5  *

     6  * Copyright (c) 2008 The Khronos Group Inc.

     7  *

     8  * Permission is hereby granted, free of charge, to any person obtaining a

     9  * copy of this software and /or associated documentation files

    10  * (the "Materials "), to deal in the Materials without restriction,

    11  * including without limitation the rights to use, copy, modify, merge,

    12  * publish, distribute, sublicense, and/or sell copies of the Materials,

    13  * and to permit persons to whom the Materials are furnished to do so,

    14  * subject to the following conditions:

    15  *

    16  * The above copyright notice and this permission notice shall be included

    17  * in all copies or substantial portions of the Materials.

    18  *

    19  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    22  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    25  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    26  *

    27  *//**

    28  * \file

    29  * \brief	OpenVG 1.1 API.

    30  *//*-------------------------------------------------------------------*/

    32 #ifndef __VG_1_1_OPENVG_H

    33 #define __VG_1_1_OPENVG_H

    35 #ifndef __VG_OPENVG_H_

    36 #error Do not include this file directly. Use <VG/openvg.h>.

    37 #endif

    39 /* differences from the actual sample implemtation provided by Khronos:

    40 - this comment

    41 - the Doxygen comment with tag 'publishedAll', and tag 'released'

    42 - changing

    43 	#define VG_API_CALL extern

    44 	to

    45 	#define VG_API_CALL IMPORT_C

    46 - the addition of __SOFTFP to all function prototypes

    47 - the addition of VG_PATH_DATATYPE_INVALID in VGPathDatatype

    48 - the addition of VG_IMAGE_FORMAT_INVALID in VGImageFormat

    49 - the addition of VGeglImageKHR typedef for the VG_KHR_EGL_image extension

    50  */

    52 /**

    53 @publishedAll

    54 @released

    55 */

    57 #ifdef __cplusplus

    58 extern "C" {

    59 #endif

    61 #include <khronos_types.h>

    63 #define OPENVG_VERSION_1_0 1

    64 #define OPENVG_VERSION_1_1 2

    66 typedef khronos_float_t  VGfloat;

    67 typedef khronos_int8_t   VGbyte;

    68 typedef khronos_uint8_t  VGubyte;

    69 typedef khronos_int16_t  VGshort;

    70 typedef khronos_int32_t  VGint;

    71 typedef khronos_uint32_t VGuint;

    72 typedef khronos_uint32_t VGbitfield;

    74 typedef enum {

    75   VG_FALSE = 0,

    76   VG_TRUE  = 1

    77 } VGboolean;

    79 #define VG_MAXSHORT ((VGshort)((~((unsigned)0)) >> 1))

    80 #define VG_MAXINT ((VGint)((~((unsigned)0)) >> 1))

    82 typedef VGuint VGHandle;

    84 #define VG_INVALID_HANDLE ((VGHandle)0)

    86 typedef enum {

    87   VG_NO_ERROR                                 = 0,

    88   VG_BAD_HANDLE_ERROR                         = 0x1000,

    89   VG_ILLEGAL_ARGUMENT_ERROR                   = 0x1001,

    90   VG_OUT_OF_MEMORY_ERROR                      = 0x1002,

    91   VG_PATH_CAPABILITY_ERROR                    = 0x1003,

    92   VG_UNSUPPORTED_IMAGE_FORMAT_ERROR           = 0x1004,

    93   VG_UNSUPPORTED_PATH_FORMAT_ERROR            = 0x1005,

    94   VG_IMAGE_IN_USE_ERROR                       = 0x1006,

    95   VG_NO_CONTEXT_ERROR                         = 0x1007

    96 } VGErrorCode;

    98 typedef enum {

    99   /* Mode settings */

   100   VG_MATRIX_MODE                              = 0x1100,

   101   VG_FILL_RULE                                = 0x1101,

   102   VG_IMAGE_QUALITY                            = 0x1102,

   103   VG_RENDERING_QUALITY                        = 0x1103,

   104   VG_BLEND_MODE                               = 0x1104,

   105   VG_IMAGE_MODE                               = 0x1105,

   107   /* Scissoring rectangles */

   108   VG_SCISSOR_RECTS                            = 0x1106,

   110   /* Color Transformation */

   111   VG_COLOR_TRANSFORM                          = 0x1170,

   112   VG_COLOR_TRANSFORM_VALUES                   = 0x1171,

   114   /* Stroke parameters */

   115   VG_STROKE_LINE_WIDTH                        = 0x1110,

   116   VG_STROKE_CAP_STYLE                         = 0x1111,

   117   VG_STROKE_JOIN_STYLE                        = 0x1112,

   118   VG_STROKE_MITER_LIMIT                       = 0x1113,

   119   VG_STROKE_DASH_PATTERN                      = 0x1114,

   120   VG_STROKE_DASH_PHASE                        = 0x1115,

   121   VG_STROKE_DASH_PHASE_RESET                  = 0x1116,

   123   /* Edge fill color for VG_TILE_FILL tiling mode */

   124   VG_TILE_FILL_COLOR                          = 0x1120,

   126   /* Color for vgClear */

   127   VG_CLEAR_COLOR                              = 0x1121,

   129   /* Glyph origin */

   130   VG_GLYPH_ORIGIN                             = 0x1122,

   132   /* Enable/disable alpha masking and scissoring */

   133   VG_MASKING                                  = 0x1130,

   134   VG_SCISSORING                               = 0x1131,

   136   /* Pixel layout information */

   137   VG_PIXEL_LAYOUT                             = 0x1140,

   138   VG_SCREEN_LAYOUT                            = 0x1141,

   140   /* Source format selection for image filters */

   141   VG_FILTER_FORMAT_LINEAR                     = 0x1150,

   142   VG_FILTER_FORMAT_PREMULTIPLIED              = 0x1151,

   144   /* Destination write enable mask for image filters */

   145   VG_FILTER_CHANNEL_MASK                      = 0x1152,

   147   /* Implementation limits (read-only) */

   148   VG_MAX_SCISSOR_RECTS                        = 0x1160,

   149   VG_MAX_DASH_COUNT                           = 0x1161,

   150   VG_MAX_KERNEL_SIZE                          = 0x1162,

   151   VG_MAX_SEPARABLE_KERNEL_SIZE                = 0x1163,

   152   VG_MAX_COLOR_RAMP_STOPS                     = 0x1164,

   153   VG_MAX_IMAGE_WIDTH                          = 0x1165,

   154   VG_MAX_IMAGE_HEIGHT                         = 0x1166,

   155   VG_MAX_IMAGE_PIXELS                         = 0x1167,

   156   VG_MAX_IMAGE_BYTES                          = 0x1168,

   157   VG_MAX_FLOAT                                = 0x1169,

   158   VG_MAX_GAUSSIAN_STD_DEVIATION               = 0x116A

   159 } VGParamType;

   161 typedef enum {

   162   VG_RENDERING_QUALITY_NONANTIALIASED         = 0x1200,

   163   VG_RENDERING_QUALITY_FASTER                 = 0x1201,

   164   VG_RENDERING_QUALITY_BETTER                 = 0x1202  /* Default */

   165 } VGRenderingQuality;

   167 typedef enum {

   168   VG_PIXEL_LAYOUT_UNKNOWN                     = 0x1300,

   169   VG_PIXEL_LAYOUT_RGB_VERTICAL                = 0x1301,

   170   VG_PIXEL_LAYOUT_BGR_VERTICAL                = 0x1302,

   171   VG_PIXEL_LAYOUT_RGB_HORIZONTAL              = 0x1303,

   172   VG_PIXEL_LAYOUT_BGR_HORIZONTAL              = 0x1304

   173 } VGPixelLayout;

   175 typedef enum {

   176   VG_MATRIX_PATH_USER_TO_SURFACE              = 0x1400,

   177   VG_MATRIX_IMAGE_USER_TO_SURFACE             = 0x1401,

   178   VG_MATRIX_FILL_PAINT_TO_USER                = 0x1402,

   179   VG_MATRIX_STROKE_PAINT_TO_USER              = 0x1403,

   180   VG_MATRIX_GLYPH_USER_TO_SURFACE             = 0x1404

   181 } VGMatrixMode;

   183 typedef enum {

   184   VG_CLEAR_MASK                               = 0x1500,

   185   VG_FILL_MASK                                = 0x1501,

   186   VG_SET_MASK                                 = 0x1502,

   187   VG_UNION_MASK                               = 0x1503,

   188   VG_INTERSECT_MASK                           = 0x1504,

   189   VG_SUBTRACT_MASK                            = 0x1505

   190 } VGMaskOperation;

   192 #define VG_PATH_FORMAT_STANDARD 0

   194 typedef enum {

   195   VG_PATH_DATATYPE_INVALID                    = -1,

   196   VG_PATH_DATATYPE_S_8                        =  0,

   197   VG_PATH_DATATYPE_S_16                       =  1,

   198   VG_PATH_DATATYPE_S_32                       =  2,

   199   VG_PATH_DATATYPE_F                          =  3

   200 } VGPathDatatype;

   202 typedef enum {

   203   VG_ABSOLUTE                                 = 0,

   204   VG_RELATIVE                                 = 1

   205 } VGPathAbsRel;

   207 typedef enum {

   208   VG_CLOSE_PATH                               = ( 0 << 1),

   209   VG_MOVE_TO                                  = ( 1 << 1),

   210   VG_LINE_TO                                  = ( 2 << 1),

   211   VG_HLINE_TO                                 = ( 3 << 1),

   212   VG_VLINE_TO                                 = ( 4 << 1),

   213   VG_QUAD_TO                                  = ( 5 << 1),

   214   VG_CUBIC_TO                                 = ( 6 << 1),

   215   VG_SQUAD_TO                                 = ( 7 << 1),

   216   VG_SCUBIC_TO                                = ( 8 << 1),

   217   VG_SCCWARC_TO                               = ( 9 << 1),

   218   VG_SCWARC_TO                                = (10 << 1),

   219   VG_LCCWARC_TO                               = (11 << 1),

   220   VG_LCWARC_TO                                = (12 << 1)

   221 } VGPathSegment;

   223 typedef enum {

   224   VG_MOVE_TO_ABS                              = VG_MOVE_TO    | VG_ABSOLUTE,

   225   VG_MOVE_TO_REL                              = VG_MOVE_TO    | VG_RELATIVE,

   226   VG_LINE_TO_ABS                              = VG_LINE_TO    | VG_ABSOLUTE,

   227   VG_LINE_TO_REL                              = VG_LINE_TO    | VG_RELATIVE,

   228   VG_HLINE_TO_ABS                             = VG_HLINE_TO   | VG_ABSOLUTE,

   229   VG_HLINE_TO_REL                             = VG_HLINE_TO   | VG_RELATIVE,

   230   VG_VLINE_TO_ABS                             = VG_VLINE_TO   | VG_ABSOLUTE,

   231   VG_VLINE_TO_REL                             = VG_VLINE_TO   | VG_RELATIVE,

   232   VG_QUAD_TO_ABS                              = VG_QUAD_TO    | VG_ABSOLUTE,

   233   VG_QUAD_TO_REL                              = VG_QUAD_TO    | VG_RELATIVE,

   234   VG_CUBIC_TO_ABS                             = VG_CUBIC_TO   | VG_ABSOLUTE,

   235   VG_CUBIC_TO_REL                             = VG_CUBIC_TO   | VG_RELATIVE,

   236   VG_SQUAD_TO_ABS                             = VG_SQUAD_TO   | VG_ABSOLUTE,

   237   VG_SQUAD_TO_REL                             = VG_SQUAD_TO   | VG_RELATIVE,

   238   VG_SCUBIC_TO_ABS                            = VG_SCUBIC_TO  | VG_ABSOLUTE,

   239   VG_SCUBIC_TO_REL                            = VG_SCUBIC_TO  | VG_RELATIVE,

   240   VG_SCCWARC_TO_ABS                           = VG_SCCWARC_TO | VG_ABSOLUTE,

   241   VG_SCCWARC_TO_REL                           = VG_SCCWARC_TO | VG_RELATIVE,

   242   VG_SCWARC_TO_ABS                            = VG_SCWARC_TO  | VG_ABSOLUTE,

   243   VG_SCWARC_TO_REL                            = VG_SCWARC_TO  | VG_RELATIVE,

   244   VG_LCCWARC_TO_ABS                           = VG_LCCWARC_TO | VG_ABSOLUTE,

   245   VG_LCCWARC_TO_REL                           = VG_LCCWARC_TO | VG_RELATIVE,

   246   VG_LCWARC_TO_ABS                            = VG_LCWARC_TO  | VG_ABSOLUTE,

   247   VG_LCWARC_TO_REL                            = VG_LCWARC_TO  | VG_RELATIVE

   248 } VGPathCommand;

   250 typedef VGHandle VGPath;

   252 typedef enum {

   253   VG_PATH_CAPABILITY_APPEND_FROM              = (1 <<  0),

   254   VG_PATH_CAPABILITY_APPEND_TO                = (1 <<  1),

   255   VG_PATH_CAPABILITY_MODIFY                   = (1 <<  2),

   256   VG_PATH_CAPABILITY_TRANSFORM_FROM           = (1 <<  3),

   257   VG_PATH_CAPABILITY_TRANSFORM_TO             = (1 <<  4),

   258   VG_PATH_CAPABILITY_INTERPOLATE_FROM         = (1 <<  5),

   259   VG_PATH_CAPABILITY_INTERPOLATE_TO           = (1 <<  6),

   260   VG_PATH_CAPABILITY_PATH_LENGTH              = (1 <<  7),

   261   VG_PATH_CAPABILITY_POINT_ALONG_PATH         = (1 <<  8),

   262   VG_PATH_CAPABILITY_TANGENT_ALONG_PATH       = (1 <<  9),

   263   VG_PATH_CAPABILITY_PATH_BOUNDS              = (1 << 10),

   264   VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS  = (1 << 11),

   265   VG_PATH_CAPABILITY_ALL                      = (1 << 12) - 1

   266 } VGPathCapabilities;

   268 typedef enum {

   269   VG_PATH_FORMAT                              = 0x1600,

   270   VG_PATH_DATATYPE                            = 0x1601,

   271   VG_PATH_SCALE                               = 0x1602,

   272   VG_PATH_BIAS                                = 0x1603,

   273   VG_PATH_NUM_SEGMENTS                        = 0x1604,

   274   VG_PATH_NUM_COORDS                          = 0x1605

   275 } VGPathParamType;

   277 typedef enum {

   278   VG_CAP_BUTT                                 = 0x1700,

   279   VG_CAP_ROUND                                = 0x1701,

   280   VG_CAP_SQUARE                               = 0x1702

   281 } VGCapStyle;

   283 typedef enum {

   284   VG_JOIN_MITER                               = 0x1800,

   285   VG_JOIN_ROUND                               = 0x1801,

   286   VG_JOIN_BEVEL                               = 0x1802

   287 } VGJoinStyle;

   289 typedef enum {

   290   VG_EVEN_ODD                                 = 0x1900,

   291   VG_NON_ZERO                                 = 0x1901

   292 } VGFillRule;

   294 typedef enum {

   295   VG_STROKE_PATH                              = (1 << 0),

   296   VG_FILL_PATH                                = (1 << 1)

   297 } VGPaintMode;

   299 typedef VGHandle VGPaint;

   301 typedef enum {

   302   /* Color paint parameters */

   303   VG_PAINT_TYPE                               = 0x1A00,

   304   VG_PAINT_COLOR                              = 0x1A01,

   305   VG_PAINT_COLOR_RAMP_SPREAD_MODE             = 0x1A02,

   306   VG_PAINT_COLOR_RAMP_PREMULTIPLIED           = 0x1A07,

   307   VG_PAINT_COLOR_RAMP_STOPS                   = 0x1A03,

   309   /* Linear gradient paint parameters */

   310   VG_PAINT_LINEAR_GRADIENT                    = 0x1A04,

   312   /* Radial gradient paint parameters */

   313   VG_PAINT_RADIAL_GRADIENT                    = 0x1A05,

   315   /* Pattern paint parameters */

   316   VG_PAINT_PATTERN_TILING_MODE                = 0x1A06

   317 } VGPaintParamType;

   319 typedef enum {

   320   VG_PAINT_TYPE_COLOR                         = 0x1B00,

   321   VG_PAINT_TYPE_LINEAR_GRADIENT               = 0x1B01,

   322   VG_PAINT_TYPE_RADIAL_GRADIENT               = 0x1B02,

   323   VG_PAINT_TYPE_PATTERN                       = 0x1B03

   324 } VGPaintType;

   326 typedef enum {

   327   VG_COLOR_RAMP_SPREAD_PAD                    = 0x1C00,

   328   VG_COLOR_RAMP_SPREAD_REPEAT                 = 0x1C01,

   329   VG_COLOR_RAMP_SPREAD_REFLECT                = 0x1C02

   330 } VGColorRampSpreadMode;

   332 typedef enum {

   333   VG_TILE_FILL                                = 0x1D00,

   334   VG_TILE_PAD                                 = 0x1D01,

   335   VG_TILE_REPEAT                              = 0x1D02,

   336   VG_TILE_REFLECT                             = 0x1D03

   337 } VGTilingMode;

   339 typedef enum {

   340   /* RGB{A,X} channel ordering */

   341   VG_IMAGE_FORMAT_INVALID                     = -1,

   342   VG_sRGBX_8888                               =  0,

   343   VG_sRGBA_8888                               =  1,

   344   VG_sRGBA_8888_PRE                           =  2,

   345   VG_sRGB_565                                 =  3,

   346   VG_sRGBA_5551                               =  4,

   347   VG_sRGBA_4444                               =  5,

   348   VG_sL_8                                     =  6,

   349   VG_lRGBX_8888                               =  7,

   350   VG_lRGBA_8888                               =  8,

   351   VG_lRGBA_8888_PRE                           =  9,

   352   VG_lL_8                                     = 10,

   353   VG_A_8                                      = 11,

   354   VG_BW_1                                     = 12,

   355   VG_A_1                                      = 13,

   356   VG_A_4                                      = 14,

   358   /* {A,X}RGB channel ordering */

   359   VG_sXRGB_8888                               =  0 | (1 << 6),

   360   VG_sARGB_8888                               =  1 | (1 << 6),

   361   VG_sARGB_8888_PRE                           =  2 | (1 << 6),

   362   VG_sARGB_1555                               =  4 | (1 << 6),

   363   VG_sARGB_4444                               =  5 | (1 << 6),

   364   VG_lXRGB_8888                               =  7 | (1 << 6),

   365   VG_lARGB_8888                               =  8 | (1 << 6),

   366   VG_lARGB_8888_PRE                           =  9 | (1 << 6),

   368   /* BGR{A,X} channel ordering */

   369   VG_sBGRX_8888                               =  0 | (1 << 7),

   370   VG_sBGRA_8888                               =  1 | (1 << 7),

   371   VG_sBGRA_8888_PRE                           =  2 | (1 << 7),

   372   VG_sBGR_565                                 =  3 | (1 << 7),

   373   VG_sBGRA_5551                               =  4 | (1 << 7),

   374   VG_sBGRA_4444                               =  5 | (1 << 7),

   375   VG_lBGRX_8888                               =  7 | (1 << 7),

   376   VG_lBGRA_8888                               =  8 | (1 << 7),

   377   VG_lBGRA_8888_PRE                           =  9 | (1 << 7),

   379   /* {A,X}BGR channel ordering */

   380   VG_sXBGR_8888                               =  0 | (1 << 6) | (1 << 7),

   381   VG_sABGR_8888                               =  1 | (1 << 6) | (1 << 7),

   382   VG_sABGR_8888_PRE                           =  2 | (1 << 6) | (1 << 7),

   383   VG_sABGR_1555                               =  4 | (1 << 6) | (1 << 7),

   384   VG_sABGR_4444                               =  5 | (1 << 6) | (1 << 7),

   385   VG_lXBGR_8888                               =  7 | (1 << 6) | (1 << 7),

   386   VG_lABGR_8888                               =  8 | (1 << 6) | (1 << 7),

   387   VG_lABGR_8888_PRE                           =  9 | (1 << 6) | (1 << 7)

   388 } VGImageFormat;

   390 typedef VGHandle VGImage;

   391 typedef int VGeglImageKHR;

   393 typedef enum {

   394   VG_IMAGE_QUALITY_NONANTIALIASED             = (1 << 0),

   395   VG_IMAGE_QUALITY_FASTER                     = (1 << 1),

   396   VG_IMAGE_QUALITY_BETTER                     = (1 << 2)

   397 } VGImageQuality;

   399 typedef enum {

   400   VG_IMAGE_FORMAT                             = 0x1E00,

   401   VG_IMAGE_WIDTH                              = 0x1E01,

   402   VG_IMAGE_HEIGHT                             = 0x1E02

   403 } VGImageParamType;

   405 typedef enum {

   406   VG_DRAW_IMAGE_NORMAL                        = 0x1F00,

   407   VG_DRAW_IMAGE_MULTIPLY                      = 0x1F01,

   408   VG_DRAW_IMAGE_STENCIL                       = 0x1F02

   409 } VGImageMode;

   411 typedef enum {

   412   VG_RED                                      = (1 << 3),

   413   VG_GREEN                                    = (1 << 2),

   414   VG_BLUE                                     = (1 << 1),

   415   VG_ALPHA                                    = (1 << 0)

   416 } VGImageChannel;

   418 typedef enum {

   419   VG_BLEND_SRC                                = 0x2000,

   420   VG_BLEND_SRC_OVER                           = 0x2001,

   421   VG_BLEND_DST_OVER                           = 0x2002,

   422   VG_BLEND_SRC_IN                             = 0x2003,

   423   VG_BLEND_DST_IN                             = 0x2004,

   424   VG_BLEND_MULTIPLY                           = 0x2005,

   425   VG_BLEND_SCREEN                             = 0x2006,

   426   VG_BLEND_DARKEN                             = 0x2007,

   427   VG_BLEND_LIGHTEN                            = 0x2008,

   428   VG_BLEND_ADDITIVE                           = 0x2009

   429 } VGBlendMode;

   431 typedef enum {

   432   VG_IMAGE_FORMAT_QUERY                       = 0x2100,

   433   VG_PATH_DATATYPE_QUERY                      = 0x2101

   434 } VGHardwareQueryType;

   436 typedef enum {

   437   VG_HARDWARE_ACCELERATED                     = 0x2200,

   438   VG_HARDWARE_UNACCELERATED                   = 0x2201

   439 } VGHardwareQueryResult;

   441 typedef enum {

   442   VG_VENDOR                                   = 0x2300,

   443   VG_RENDERER                                 = 0x2301,

   444   VG_VERSION                                  = 0x2302,

   445   VG_EXTENSIONS                               = 0x2303

   446 } VGStringID;

   448 typedef enum {

   449   VG_FONT_NUM_GLYPHS                          = 0x2F00

   450 } VGFontParamType;

   453 /* Function Prototypes */

   455 #ifndef VG_API_CALL

   456 #define VG_API_CALL IMPORT_C

   457 #endif

   458 #ifndef VG_APIENTRY

   459 #define VG_APIENTRY /* nothing */

   460 #endif

   461 #ifndef VG_APIEXIT

   462 #define VG_APIEXIT __SOFTFP

   463 #endif

   465 VG_API_CALL VGErrorCode VG_APIENTRY

   466     vgGetError(void) VG_APIEXIT;

   468 VG_API_CALL void VG_APIENTRY

   469     vgFlush(void) VG_APIEXIT;

   470 VG_API_CALL void VG_APIENTRY

   471     vgFinish(void) VG_APIEXIT;

   473 /* Getters and Setters */

   474 VG_API_CALL void VG_APIENTRY

   475    vgSetf (VGParamType type, VGfloat value) VG_APIEXIT;

   476 VG_API_CALL void VG_APIENTRY

   477     vgSeti (VGParamType type, VGint value) VG_APIEXIT;

   478 VG_API_CALL void VG_APIENTRY

   479     vgSetfv(VGParamType type, VGint count,

   480         const VGfloat * values) VG_APIEXIT;

   481 VG_API_CALL void VG_APIENTRY

   482     vgSetiv(VGParamType type, VGint count,

   483         const VGint * values) VG_APIEXIT;

   484 VG_API_CALL VGfloat VG_APIENTRY

   485     vgGetf(VGParamType type) VG_APIEXIT;

   486 VG_API_CALL VGint   VG_APIENTRY

   487     vgGeti(VGParamType type) VG_APIEXIT;

   488 VG_API_CALL VGint   VG_APIENTRY

   489     vgGetVectorSize(VGParamType type) VG_APIEXIT;

   490 VG_API_CALL void    VG_APIENTRY

   491     vgGetfv(VGParamType type, VGint count,

   492         VGfloat * values) VG_APIEXIT;

   493 VG_API_CALL void    VG_APIENTRY

   494     vgGetiv(VGParamType type, VGint count,

   495         VGint * values) VG_APIEXIT;

   496 VG_API_CALL void VG_APIENTRY

   497     vgSetParameterf(VGHandle object,

   498         VGint paramType,

   499         VGfloat value) VG_APIEXIT;

   500 VG_API_CALL void VG_APIENTRY

   501     vgSetParameteri(VGHandle object,

   502         VGint paramType,

   503         VGint value) VG_APIEXIT;

   504 VG_API_CALL void VG_APIENTRY

   505     vgSetParameterfv(VGHandle object,

   506         VGint paramType,

   507         VGint count,

   508         const VGfloat * values) VG_APIEXIT;

   509 VG_API_CALL void VG_APIENTRY

   510     vgSetParameteriv(VGHandle object,

   511         VGint paramType,

   512         VGint count,

   513         const VGint * values) VG_APIEXIT;

   515 VG_API_CALL VGfloat VG_APIENTRY

   516     vgGetParameterf(VGHandle object,

   517         VGint paramType) VG_APIEXIT;

   518 VG_API_CALL VGint VG_APIENTRY

   519     vgGetParameteri(VGHandle object,

   520         VGint paramType) VG_APIEXIT;

   521 VG_API_CALL VGint VG_APIENTRY

   522     vgGetParameterVectorSize(VGHandle object,

   523         VGint paramType) VG_APIEXIT;

   524 VG_API_CALL void VG_APIENTRY

   525     vgGetParameterfv(VGHandle object,

   526         VGint paramType,

   527         VGint count,

   528         VGfloat * values) VG_APIEXIT;

   529 VG_API_CALL void VG_APIENTRY

   530     vgGetParameteriv(VGHandle object,

   531         VGint paramType,

   532         VGint count,

   533         VGint * values) VG_APIEXIT;

   535 /* Matrix Manipulation */

   536 VG_API_CALL void VG_APIENTRY

   537     vgLoadIdentity(void) VG_APIEXIT;

   538 VG_API_CALL void VG_APIENTRY

   539     vgLoadMatrix(const VGfloat * m) VG_APIEXIT;

   540 VG_API_CALL void VG_APIENTRY

   541     vgGetMatrix(VGfloat * m) VG_APIEXIT;

   542 VG_API_CALL void VG_APIENTRY

   543     vgMultMatrix(const VGfloat * m) VG_APIEXIT;

   544 VG_API_CALL void VG_APIENTRY

   545     vgTranslate(VGfloat tx, VGfloat ty) VG_APIEXIT;

   546 VG_API_CALL void VG_APIENTRY

   547     vgScale(VGfloat sx, VGfloat sy) VG_APIEXIT;

   548 VG_API_CALL void VG_APIENTRY

   549     vgShear(VGfloat shx, VGfloat shy) VG_APIEXIT;

   550 VG_API_CALL void VG_APIENTRY

   551     vgRotate(VGfloat angle) VG_APIEXIT;

   553 /* Masking and Clearing */

   554 typedef VGHandle VGMaskLayer;

   556 VG_API_CALL void VG_APIENTRY

   557     vgMask(VGHandle mask, VGMaskOperation operation,

   558         VGint x, VGint y,

   559         VGint width, VGint height) VG_APIEXIT;

   560 VG_API_CALL void VG_APIENTRY

   561     vgRenderToMask(VGPath path,

   562         VGbitfield paintModes,

   563         VGMaskOperation operation) VG_APIEXIT;

   564 VG_API_CALL VGMaskLayer VG_APIENTRY

   565     vgCreateMaskLayer(VGint width, VGint height) VG_APIEXIT;

   566 VG_API_CALL void VG_APIENTRY

   567     vgDestroyMaskLayer(VGMaskLayer maskLayer) VG_APIEXIT;

   568 VG_API_CALL void VG_APIENTRY

   569     vgFillMaskLayer(VGMaskLayer maskLayer,

   570         VGint x, VGint y,

   571         VGint width, VGint height,

   572         VGfloat value) VG_APIEXIT;

   573 VG_API_CALL void VG_APIENTRY

   574     vgCopyMask(VGMaskLayer maskLayer,

   575         VGint sx, VGint sy,

   576         VGint dx, VGint dy,

   577         VGint width, VGint height) VG_APIEXIT;

   578 VG_API_CALL void VG_APIENTRY

   579     vgClear(VGint x, VGint y,

   580         VGint width, VGint height) VG_APIEXIT;

   582 /* Paths */

   583 VG_API_CALL VGPath VG_APIENTRY

   584     vgCreatePath(VGint pathFormat,

   585         VGPathDatatype datatype,

   586         VGfloat scale, VGfloat bias,

   587         VGint segmentCapacityHint,

   588         VGint coordCapacityHint,

   589         VGbitfield capabilities) VG_APIEXIT;

   590 VG_API_CALL void VG_APIENTRY

   591     vgClearPath(VGPath path, VGbitfield capabilities) VG_APIEXIT;

   592 VG_API_CALL void VG_APIENTRY

   593     vgDestroyPath(VGPath path) VG_APIEXIT;

   594 VG_API_CALL void VG_APIENTRY

   595     vgRemovePathCapabilities(VGPath path,

   596         VGbitfield capabilities) VG_APIEXIT;

   597 VG_API_CALL VGbitfield VG_APIENTRY

   598     vgGetPathCapabilities(VGPath path) VG_APIEXIT;

   599 VG_API_CALL void VG_APIENTRY

   600     vgAppendPath(VGPath dstPath, VGPath srcPath) VG_APIEXIT;

   601 VG_API_CALL void VG_APIENTRY

   602     vgAppendPathData(VGPath dstPath,

   603         VGint numSegments,

   604         const VGubyte * pathSegments,

   605         const void * pathData) VG_APIEXIT;

   606 VG_API_CALL void VG_APIENTRY

   607     vgModifyPathCoords(VGPath dstPath,

   608         VGint startIndex,

   609         VGint numSegments,

   610         const void * pathData) VG_APIEXIT;

   611 VG_API_CALL void VG_APIENTRY

   612     vgTransformPath(VGPath dstPath, VGPath srcPath) VG_APIEXIT;

   613 VG_API_CALL VGboolean VG_APIENTRY

   614     vgInterpolatePath(VGPath dstPath,

   615         VGPath startPath,

   616         VGPath endPath,

   617         VGfloat amount) VG_APIEXIT;

   618 VG_API_CALL VGfloat VG_APIENTRY

   619     vgPathLength(VGPath path,

   620         VGint startSegment,

   621         VGint numSegments) VG_APIEXIT;

   622 VG_API_CALL void VG_APIENTRY

   623     vgPointAlongPath(VGPath path,

   624         VGint startSegment,

   625         VGint numSegments,

   626         VGfloat distance,

   627         VGfloat * x, VGfloat * y,

   628         VGfloat * tangentX,

   629         VGfloat * tangentY) VG_APIEXIT;

   630 VG_API_CALL void VG_APIENTRY

   631     vgPathBounds(VGPath path,

   632         VGfloat * minX,

   633         VGfloat * minY,

   634         VGfloat * width,

   635         VGfloat * height) VG_APIEXIT;

   636 VG_API_CALL void VG_APIENTRY

   637     vgPathTransformedBounds(VGPath path,

   638         VGfloat * minX,

   639         VGfloat * minY,

   640         VGfloat * width,

   641         VGfloat * height) VG_APIEXIT;

   642 VG_API_CALL void VG_APIENTRY

   643     vgDrawPath(VGPath path, VGbitfield paintModes) VG_APIEXIT;

   645 /* Paint */

   646 VG_API_CALL VGPaint VG_APIENTRY

   647     vgCreatePaint(void) VG_APIEXIT;

   648 VG_API_CALL void VG_APIENTRY

   649     vgDestroyPaint(VGPaint paint) VG_APIEXIT;

   650 VG_API_CALL void VG_APIENTRY

   651     vgSetPaint(VGPaint paint, VGbitfield paintModes) VG_APIEXIT;

   652 VG_API_CALL VGPaint VG_APIENTRY

   653     vgGetPaint(VGPaintMode paintMode) VG_APIEXIT;

   654 VG_API_CALL void VG_APIENTRY

   655     vgSetColor(VGPaint paint, VGuint rgba) VG_APIEXIT;

   656 VG_API_CALL VGuint VG_APIENTRY

   657     vgGetColor(VGPaint paint) VG_APIEXIT;

   658 VG_API_CALL void VG_APIENTRY

   659     vgPaintPattern(VGPaint paint, VGImage pattern) VG_APIEXIT;

   661 /* Images */

   662 VG_API_CALL VGImage VG_APIENTRY

   663     vgCreateImage(VGImageFormat format,

   664         VGint width, VGint height,

   665         VGbitfield allowedQuality) VG_APIEXIT;

   666 VG_API_CALL void VG_APIENTRY

   667     vgDestroyImage(VGImage image) VG_APIEXIT;

   668 VG_API_CALL void VG_APIENTRY

   669     vgClearImage(VGImage image,

   670         VGint x, VGint y,

   671         VGint width, VGint height) VG_APIEXIT;

   672 VG_API_CALL void VG_APIENTRY

   673     vgImageSubData(VGImage image,

   674         const void * data,

   675         VGint dataStride,

   676         VGImageFormat dataFormat,

   677         VGint x, VGint y,

   678         VGint width, VGint height) VG_APIEXIT;

   679 VG_API_CALL void VG_APIENTRY

   680     vgGetImageSubData(VGImage image,

   681         void * data,

   682         VGint dataStride,

   683         VGImageFormat dataFormat,

   684         VGint x, VGint y,

   685         VGint width, VGint height) VG_APIEXIT;

   686 VG_API_CALL VGImage VG_APIENTRY

   687     vgChildImage(VGImage parent,

   688         VGint x, VGint y,

   689         VGint width, VGint height) VG_APIEXIT;

   690 VG_API_CALL VGImage VG_APIENTRY

   691     vgGetParent(VGImage image) VG_APIEXIT;

   692 VG_API_CALL void VG_APIENTRY

   693     vgCopyImage(VGImage dst, VGint dx, VGint dy,

   694         VGImage src, VGint sx, VGint sy,

   695         VGint width, VGint height,

   696         VGboolean dither) VG_APIEXIT;

   697 VG_API_CALL void VG_APIENTRY

   698     vgDrawImage(VGImage image) VG_APIEXIT;

   699 VG_API_CALL void VG_APIENTRY

   700     vgSetPixels(VGint dx, VGint dy,

   701         VGImage src, VGint sx, VGint sy,

   702         VGint width, VGint height) VG_APIEXIT;

   703 VG_API_CALL void VG_APIENTRY

   704     vgWritePixels(const void * data, VGint dataStride,

   705         VGImageFormat dataFormat,

   706         VGint dx, VGint dy,

   707         VGint width, VGint height) VG_APIEXIT;

   708 VG_API_CALL void VG_APIENTRY

   709     vgGetPixels(VGImage dst, VGint dx, VGint dy,

   710         VGint sx, VGint sy,

   711         VGint width, VGint height) VG_APIEXIT;

   712 VG_API_CALL void VG_APIENTRY

   713     vgReadPixels(void * data, VGint dataStride,

   714         VGImageFormat dataFormat,

   715         VGint sx, VGint sy,

   716         VGint width, VGint height) VG_APIEXIT;

   717 VG_API_CALL void VG_APIENTRY

   718     vgCopyPixels(VGint dx, VGint dy,

   719         VGint sx, VGint sy,

   720         VGint width, VGint height) VG_APIEXIT;

   722 /* Text */

   723 typedef VGHandle VGFont;

   725 VG_API_CALL VGFont VG_APIENTRY

   726     vgCreateFont(VGint glyphCapacityHint) VG_APIEXIT;

   727 VG_API_CALL void VG_APIENTRY

   728     vgDestroyFont(VGFont font) VG_APIEXIT;

   729 VG_API_CALL void VG_APIENTRY

   730     vgSetGlyphToPath(VGFont font,

   731         VGuint glyphIndex,

   732         VGPath path,

   733         VGboolean isHinted,

   734         const VGfloat glyphOrigin [2],

   735         const VGfloat escapement[2]) VG_APIEXIT;

   736 VG_API_CALL void VG_APIENTRY

   737     vgSetGlyphToImage(VGFont font,

   738         VGuint glyphIndex,

   739         VGImage image,

   740         const VGfloat glyphOrigin [2],

   741         const VGfloat escapement[2]) VG_APIEXIT;

   742 VG_API_CALL void VG_APIENTRY

   743     vgClearGlyph(VGFont font,

   744         VGuint glyphIndex) VG_APIEXIT;

   745 VG_API_CALL void VG_APIENTRY

   746     vgDrawGlyph(VGFont font,

   747         VGuint glyphIndex,

   748         VGbitfield paintModes,

   749         VGboolean allowAutoHinting) VG_APIEXIT;

   750 VG_API_CALL void VG_APIENTRY

   751     vgDrawGlyphs(VGFont font,

   752         VGint glyphCount,

   753         const VGuint * glyphIndices,

   754         const VGfloat * adjustments_x,

   755         const VGfloat * adjustments_y,

   756         VGbitfield paintModes,

   757         VGboolean allowAutoHinting) VG_APIEXIT;

   759 /* Image Filters */

   760 VG_API_CALL void VG_APIENTRY

   761     vgColorMatrix(VGImage dst, VGImage src,

   762         const VGfloat * matrix) VG_APIEXIT;

   763 VG_API_CALL void VG_APIENTRY

   764     vgConvolve(VGImage dst, VGImage src,

   765         VGint kernelWidth, VGint kernelHeight,

   766         VGint shiftX, VGint shiftY,

   767         const VGshort * kernel,

   768         VGfloat scale,

   769         VGfloat bias,

   770         VGTilingMode tilingMode) VG_APIEXIT;

   771 VG_API_CALL void VG_APIENTRY

   772     vgSeparableConvolve(VGImage dst, VGImage src,

   773         VGint kernelWidth,

   774         VGint kernelHeight,

   775         VGint shiftX, VGint shiftY,

   776         const VGshort * kernelX,

   777         const VGshort * kernelY,

   778         VGfloat scale,

   779         VGfloat bias,

   780         VGTilingMode tilingMode) VG_APIEXIT;

   781 VG_API_CALL void VG_APIENTRY

   782     vgGaussianBlur(VGImage dst, VGImage src,

   783         VGfloat stdDeviationX,

   784         VGfloat stdDeviationY,

   785         VGTilingMode tilingMode) VG_APIEXIT;

   786 VG_API_CALL void VG_APIENTRY

   787     vgLookup(VGImage dst, VGImage src,

   788         const VGubyte * redLUT,

   789         const VGubyte * greenLUT,

   790         const VGubyte * blueLUT,

   791         const VGubyte * alphaLUT,

   792         VGboolean outputLinear,

   793         VGboolean outputPremultiplied) VG_APIEXIT;

   794 VG_API_CALL void VG_APIENTRY

   795     vgLookupSingle(VGImage dst, VGImage src,

   796         const VGuint * lookupTable,

   797         VGImageChannel sourceChannel,

   798         VGboolean outputLinear,

   799         VGboolean outputPremultiplied) VG_APIEXIT;

   801 /* Hardware Queries */

   802 VG_API_CALL VGHardwareQueryResult VG_APIENTRY

   803     vgHardwareQuery

   804         (VGHardwareQueryType key,

   805         VGint setting) VG_APIEXIT;

   807 /* Renderer and Extension Information */

   808 VG_API_CALL const VGubyte * VG_APIENTRY

   809     vgGetString(VGStringID name) VG_APIEXIT;

   811 #ifdef __cplusplus

   812 } /* extern "C" */

   813 #endif

   815 #endif /* __VG_1_1_OPENVG_H */

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:27:01 +0100
branch	Symbian2
changeset 3	e1b950c65cb4
parent 2	epoc32/include/VG/1.1/openvg.h@2fe1408b6811
child 4	837f303aceeb
permissions	-rw-r--r--