thorvg_capi.h

 
#ifndef __THORVG_CAPI_H__
#define __THORVG_CAPI_H__
 
#include <stdint.h>
#include <stdbool.h>
 
#ifdef TVG_API
    #undef TVG_API
#endif
 
#ifndef TVG_STATIC
    #ifdef _WIN32
        #if TVG_BUILD
            #define TVG_API __declspec(dllexport)
        #else
            #define TVG_API __declspec(dllimport)
        #endif
    #elif (defined(__SUNPRO_C)  || defined(__SUNPRO_CC))
        #define TVG_API __global
    #else
        #if (defined(__GNUC__) && __GNUC__ >= 4) || defined(__INTEL_COMPILER)
            #define TVG_API __attribute__ ((visibility("default")))
        #else
            #define TVG_API
        #endif
    #endif
#else
    #define TVG_API
#endif
 
#ifdef TVG_DEPRECATED
    #undef TVG_DEPRECATED
#endif
 
#ifdef _WIN32
    #define TVG_DEPRECATED __declspec(deprecated)
#elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
    #define TVG_DEPRECATED __attribute__ ((__deprecated__))
#else
    #define TVG_DEPRECATED
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct _Tvg_Canvas Tvg_Canvas;
 
 
typedef struct _Tvg_Paint Tvg_Paint;
 
 
typedef struct _Tvg_Gradient Tvg_Gradient;
 
 
typedef struct _Tvg_Saver Tvg_Saver;
 
 
typedef enum {
    TVG_ENGINE_SW = (1 << 1),   
    TVG_ENGINE_GL = (1 << 2)    
} Tvg_Engine;
 
 
typedef enum {
    TVG_RESULT_SUCCESS = 0,            
    TVG_RESULT_INVALID_ARGUMENT,       
    TVG_RESULT_INSUFFICIENT_CONDITION, 
    TVG_RESULT_FAILED_ALLOCATION,      
    TVG_RESULT_MEMORY_CORRUPTION,      
    TVG_RESULT_NOT_SUPPORTED,          
    TVG_RESULT_UNKNOWN                 
} Tvg_Result;
 
 
typedef enum {
    TVG_COMPOSITE_METHOD_NONE = 0,           
    TVG_COMPOSITE_METHOD_CLIP_PATH,          
    TVG_COMPOSITE_METHOD_ALPHA_MASK,         
    TVG_COMPOSITE_METHOD_INVERSE_ALPHA_MASK, 
    TVG_COMPOSITE_METHOD_LUMA_MASK           
} Tvg_Composite_Method;
 
 
typedef enum {
    TVG_IDENTIFIER_UNDEF = 0,   
    TVG_IDENTIFIER_SHAPE,       
    TVG_IDENTIFIER_SCENE,       
    TVG_IDENTIFIER_PICTURE,     
    TVG_IDENTIFIER_LINEAR_GRAD, 
    TVG_IDENTIFIER_RADIAL_GRAD  
} Tvg_Identifier;
 
 
typedef enum {
    TVG_PATH_COMMAND_CLOSE = 0, 
    TVG_PATH_COMMAND_MOVE_TO,   
    TVG_PATH_COMMAND_LINE_TO,   
    TVG_PATH_COMMAND_CUBIC_TO   
} Tvg_Path_Command;
 
 
typedef enum {
    TVG_STROKE_CAP_SQUARE = 0, 
    TVG_STROKE_CAP_ROUND,      
    TVG_STROKE_CAP_BUTT        
} Tvg_Stroke_Cap;
 
 
typedef enum {
    TVG_STROKE_JOIN_BEVEL = 0, 
    TVG_STROKE_JOIN_ROUND,     
    TVG_STROKE_JOIN_MITER      
} Tvg_Stroke_Join;
 
 
typedef enum {
    TVG_STROKE_FILL_PAD = 0, 
    TVG_STROKE_FILL_REFLECT, 
    TVG_STROKE_FILL_REPEAT   
} Tvg_Stroke_Fill;
 
 
typedef enum {
    TVG_FILL_RULE_WINDING = 0, 
    TVG_FILL_RULE_EVEN_ODD     
} Tvg_Fill_Rule;
   // end addtogroup ThorVGCapi_Shape
 
 
typedef struct
{
    float offset; 
    uint8_t r;    
    uint8_t g;    
    uint8_t b;    
    uint8_t a;    
} Tvg_Color_Stop;
   // end addtogroup ThorVGCapi_Gradient
 
 
typedef struct
{
    float x, y;
} Tvg_Point;
 
 
typedef struct
{
    float e11, e12, e13;
    float e21, e22, e23;
    float e31, e32, e33;
} Tvg_Matrix;
 
 
/************************************************************************/
/* Engine API                                                           */
/************************************************************************/
TVG_API Tvg_Result tvg_engine_init(Tvg_Engine engine_method, unsigned threads);
 
 
TVG_API Tvg_Result tvg_engine_term(Tvg_Engine engine_method);
 
   // end defgroup ThorVGCapi_Initializer
 
 
/************************************************************************/
/* SwCanvas API                                                         */
/************************************************************************/
 
typedef enum {
    TVG_MEMPOOL_POLICY_DEFAULT = 0, 
    TVG_MEMPOOL_POLICY_SHAREABLE,   
    TVG_MEMPOOL_POLICY_INDIVIDUAL   
} Tvg_Mempool_Policy;
 
 
typedef enum {
    TVG_COLORSPACE_ABGR8888 = 0, 
    TVG_COLORSPACE_ARGB8888      
} Tvg_Colorspace;
 
 
TVG_API Tvg_Canvas* tvg_swcanvas_create();
 
 
TVG_API Tvg_Result tvg_swcanvas_set_target(Tvg_Canvas* canvas, uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h, Tvg_Colorspace cs);
 
 
TVG_API Tvg_Result tvg_swcanvas_set_mempool(Tvg_Canvas* canvas, Tvg_Mempool_Policy policy);
   // end defgroup ThorVGCapi_SwCanvas
 
 
/************************************************************************/
/* Common Canvas API                                                    */
/************************************************************************/
TVG_API Tvg_Result tvg_canvas_destroy(Tvg_Canvas* canvas);
 
 
TVG_API Tvg_Result tvg_canvas_push(Tvg_Canvas* canvas, Tvg_Paint* paint);
 
 
TVG_DEPRECATED TVG_API Tvg_Result tvg_canvas_reserve(Tvg_Canvas* canvas, uint32_t n);
 
 
TVG_API Tvg_Result tvg_canvas_clear(Tvg_Canvas* canvas, bool free);
 
 
TVG_API Tvg_Result tvg_canvas_update(Tvg_Canvas* canvas);
 
 
TVG_API Tvg_Result tvg_canvas_update_paint(Tvg_Canvas* canvas, Tvg_Paint* paint);
 
 
TVG_API Tvg_Result tvg_canvas_draw(Tvg_Canvas* canvas);
 
 
TVG_API Tvg_Result tvg_canvas_sync(Tvg_Canvas* canvas);
 
   // end defgroup ThorVGCapi_Canvas
 
 
/************************************************************************/
/* Paint API                                                            */
/************************************************************************/
TVG_API Tvg_Result tvg_paint_del(Tvg_Paint* paint);
 
 
TVG_API Tvg_Result tvg_paint_scale(Tvg_Paint* paint, float factor);
 
 
TVG_API Tvg_Result tvg_paint_rotate(Tvg_Paint* paint, float degree);
 
 
TVG_API Tvg_Result tvg_paint_translate(Tvg_Paint* paint, float x, float y);
 
 
TVG_API Tvg_Result tvg_paint_set_transform(Tvg_Paint* paint, const Tvg_Matrix* m);
 
 
TVG_API Tvg_Result tvg_paint_get_transform(Tvg_Paint* paint, Tvg_Matrix* m);
 
 
TVG_API Tvg_Result tvg_paint_set_opacity(Tvg_Paint* paint, uint8_t opacity);
 
 
TVG_API Tvg_Result tvg_paint_get_opacity(const Tvg_Paint* paint, uint8_t* opacity);
 
 
TVG_API Tvg_Paint* tvg_paint_duplicate(Tvg_Paint* paint);
 
 
TVG_API Tvg_Result tvg_paint_get_bounds(const Tvg_Paint* paint, float* x, float* y, float* w, float* h, bool transformed);
 
 
TVG_API Tvg_Result tvg_paint_set_composite_method(Tvg_Paint* paint, Tvg_Paint* target, Tvg_Composite_Method method);
 
 
TVG_API Tvg_Result tvg_paint_get_composite_method(const Tvg_Paint* paint, const Tvg_Paint** target, Tvg_Composite_Method* method);
 
 
TVG_API Tvg_Result tvg_paint_get_identifier(const Tvg_Paint* paint, Tvg_Identifier* identifier);   // end defgroup ThorVGCapi_Paint
 
 
/************************************************************************/
/* Shape API                                                            */
/************************************************************************/
TVG_API Tvg_Paint* tvg_shape_new();
 
 
TVG_API Tvg_Result tvg_shape_reset(Tvg_Paint* paint);
 
 
TVG_API Tvg_Result tvg_shape_move_to(Tvg_Paint* paint, float x, float y);
 
 
TVG_API Tvg_Result tvg_shape_line_to(Tvg_Paint* paint, float x, float y);
 
 
TVG_API Tvg_Result tvg_shape_cubic_to(Tvg_Paint* paint, float cx1, float cy1, float cx2, float cy2, float x, float y);
 
 
TVG_API Tvg_Result tvg_shape_close(Tvg_Paint* paint);
 
 
TVG_API Tvg_Result tvg_shape_append_rect(Tvg_Paint* paint, float x, float y, float w, float h, float rx, float ry);
 
 
TVG_API Tvg_Result tvg_shape_append_circle(Tvg_Paint* paint, float cx, float cy, float rx, float ry);
 
 
TVG_API Tvg_Result tvg_shape_append_arc(Tvg_Paint* paint, float cx, float cy, float radius, float startAngle, float sweep, uint8_t pie);
 
 
TVG_API Tvg_Result tvg_shape_append_path(Tvg_Paint* paint, const Tvg_Path_Command* cmds, uint32_t cmdCnt, const Tvg_Point* pts, uint32_t ptsCnt);
 
 
TVG_API Tvg_Result tvg_shape_get_path_coords(const Tvg_Paint* paint, const Tvg_Point** pts, uint32_t* cnt);
 
 
TVG_API Tvg_Result tvg_shape_get_path_commands(const Tvg_Paint* paint, const Tvg_Path_Command** cmds, uint32_t* cnt);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_width(Tvg_Paint* paint, float width);
 
 
TVG_API Tvg_Result tvg_shape_get_stroke_width(const Tvg_Paint* paint, float* width);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_color(Tvg_Paint* paint, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 
 
TVG_API Tvg_Result tvg_shape_get_stroke_color(const Tvg_Paint* paint, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_linear_gradient(Tvg_Paint* paint, Tvg_Gradient* grad);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_radial_gradient(Tvg_Paint* paint, Tvg_Gradient* grad);
 
 
TVG_API Tvg_Result tvg_shape_get_stroke_gradient(const Tvg_Paint* paint, Tvg_Gradient** grad);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_dash(Tvg_Paint* paint, const float* dashPattern, uint32_t cnt);
 
 
TVG_API Tvg_Result tvg_shape_get_stroke_dash(const Tvg_Paint* paint, const float** dashPattern, uint32_t* cnt);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_cap(Tvg_Paint* paint, Tvg_Stroke_Cap cap);
 
 
TVG_API Tvg_Result tvg_shape_get_stroke_cap(const Tvg_Paint* paint, Tvg_Stroke_Cap* cap);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_join(Tvg_Paint* paint, Tvg_Stroke_Join join);
 
 
TVG_API Tvg_Result tvg_shape_get_stroke_join(const Tvg_Paint* paint, Tvg_Stroke_Join* join);
 
 
TVG_API Tvg_Result tvg_shape_set_stroke_miterlimit(Tvg_Paint* paint, float miterlimit);
 
 
TVG_API Tvg_Result tvg_shape_get_stroke_miterlimit(const Tvg_Paint* paint, float* miterlimit);
 
 
TVG_API Tvg_Result tvg_shape_set_fill_color(Tvg_Paint* paint, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 
 
TVG_API Tvg_Result tvg_shape_get_fill_color(const Tvg_Paint* paint, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a);
 
 
TVG_API Tvg_Result tvg_shape_set_fill_rule(Tvg_Paint* paint, Tvg_Fill_Rule rule);
 
 
TVG_API Tvg_Result tvg_shape_get_fill_rule(const Tvg_Paint* paint, Tvg_Fill_Rule* rule);
 
 
TVG_API Tvg_Result tvg_shape_set_paint_order(Tvg_Paint* paint, bool strokeFirst);
 
 
TVG_API Tvg_Result tvg_shape_set_linear_gradient(Tvg_Paint* paint, Tvg_Gradient* grad);
 
 
TVG_API Tvg_Result tvg_shape_set_radial_gradient(Tvg_Paint* paint, Tvg_Gradient* grad);
 
 
TVG_API Tvg_Result tvg_shape_get_gradient(const Tvg_Paint* paint, Tvg_Gradient** grad);
 
   // end defgroup ThorVGCapi_Shape
 
 
/************************************************************************/
/* Gradient API                                                         */
/************************************************************************/
TVG_API Tvg_Gradient* tvg_linear_gradient_new();
 
 
TVG_API Tvg_Gradient* tvg_radial_gradient_new();
 
 
TVG_API Tvg_Result tvg_linear_gradient_set(Tvg_Gradient* grad, float x1, float y1, float x2, float y2);
 
 
TVG_API Tvg_Result tvg_linear_gradient_get(Tvg_Gradient* grad, float* x1, float* y1, float* x2, float* y2);
 
 
TVG_API Tvg_Result tvg_radial_gradient_set(Tvg_Gradient* grad, float cx, float cy, float radius);
 
 
TVG_API Tvg_Result tvg_radial_gradient_get(Tvg_Gradient* grad, float* cx, float* cy, float* radius);
 
 
TVG_API Tvg_Result tvg_gradient_set_color_stops(Tvg_Gradient* grad, const Tvg_Color_Stop* color_stop, uint32_t cnt);
 
 
TVG_API Tvg_Result tvg_gradient_get_color_stops(const Tvg_Gradient* grad, const Tvg_Color_Stop** color_stop, uint32_t* cnt);
 
 
TVG_API Tvg_Result tvg_gradient_set_spread(Tvg_Gradient* grad, const Tvg_Stroke_Fill spread);
 
 
TVG_API Tvg_Result tvg_gradient_get_spread(const Tvg_Gradient* grad, Tvg_Stroke_Fill* spread);
 
 
TVG_API Tvg_Result tvg_gradient_set_transform(Tvg_Gradient* grad, const Tvg_Matrix* m);
 
 
TVG_API Tvg_Result tvg_gradient_get_transform(const Tvg_Gradient* grad, Tvg_Matrix* m);
 
TVG_API Tvg_Result tvg_gradient_get_identifier(const Tvg_Gradient* grad, Tvg_Identifier* identifier);
 
 
TVG_API Tvg_Gradient* tvg_gradient_duplicate(Tvg_Gradient* grad);
 
 
TVG_API Tvg_Result tvg_gradient_del(Tvg_Gradient* grad);
 
   // end defgroup ThorVGCapi_Gradient
 
 
/************************************************************************/
/* Picture API                                                          */
/************************************************************************/
TVG_API Tvg_Paint* tvg_picture_new();
 
 
TVG_API Tvg_Result tvg_picture_load(Tvg_Paint* paint, const char* path);
 
 
TVG_API Tvg_Result tvg_picture_load_raw(Tvg_Paint* paint, uint32_t *data, uint32_t w, uint32_t h, bool copy);
 
 
TVG_API Tvg_Result tvg_picture_load_data(Tvg_Paint* paint, const char *data, uint32_t size, const char *mimetype, bool copy);
 
 
TVG_API Tvg_Result tvg_picture_set_size(Tvg_Paint* paint, float w, float h);
 
 
TVG_API Tvg_Result tvg_picture_get_size(const Tvg_Paint* paint, float* w, float* h);
 
   // end defgroup ThorVGCapi_Picture
 
 
/************************************************************************/
/* Scene API                                                            */
/************************************************************************/
TVG_API Tvg_Paint* tvg_scene_new();
 
 
TVG_DEPRECATED TVG_API Tvg_Result tvg_scene_reserve(Tvg_Paint* scene, uint32_t size);
 
 
TVG_API Tvg_Result tvg_scene_push(Tvg_Paint* scene, Tvg_Paint* paint);
 
 
TVG_API Tvg_Result tvg_scene_clear(Tvg_Paint* scene, bool free);
   // end defgroup ThorVGCapi_Scene
 
 
/************************************************************************/
/* Saver API                                                            */
/************************************************************************/
TVG_API Tvg_Saver* tvg_saver_new();
 
 
TVG_API Tvg_Result tvg_saver_save(Tvg_Saver* saver, Tvg_Paint* paint, const char* path, bool compress);
 
 
TVG_API Tvg_Result tvg_saver_sync(Tvg_Saver* saver);
 
 
TVG_API Tvg_Result tvg_saver_del(Tvg_Saver* saver);
 
   // end defgroup ThorVGCapi_Saver
 
   // end defgroup ThorVG_CAPI
 
 
#ifdef __cplusplus
}
#endif
 
#endif //_THORVG_CAPI_H_