vkvg.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2025 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so, subject
 * to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#ifndef VKVG_H
#define VKVG_H
 
#include <stdint.h>
#include <stddef.h>
 
#include <vulkan/vulkan.h>
 
#ifdef __cplusplus
extern "C" {
#else
#include <stdbool.h>
#endif
 
#ifndef vkvg_public
#ifdef VKVG_SHARED_BUILD
#if (defined(_WIN32) || defined(__CYGWIN__))
#define vkvg_public __declspec(dllexport)
#else
#define vkvg_public __attribute__((visibility("default")))
#endif
#elif (defined(VKVG_SHARED_LINKING) && (defined(_WIN32) || defined(__CYGWIN__)))
#define vkvg_public __declspec(dllimport)
#else
#define vkvg_public
#endif
#endif
 
#define VKVG_LOG_ERR        0x00000001
#define VKVG_LOG_DEBUG      0x00000002
 
#define VKVG_LOG_INFO_PTS   0x00000004
#define VKVG_LOG_INFO_PATH  0x00000008
#define VKVG_LOG_INFO_CMD   0x00000010
#define VKVG_LOG_INFO_VBO   0x00000020
#define VKVG_LOG_INFO_IBO   0x00000040
#define VKVG_LOG_INFO_VAO   (VKVG_LOG_INFO_VBO | VKVG_LOG_INFO_IBO)
#define VKVG_LOG_THREAD     0x00000080
#define VKVG_LOG_DBG_ARRAYS 0x00001000
#define VKVG_LOG_STROKE     0x00010000
#define VKVG_LOG_FULL       0xffffffff
 
#define VKVG_LOG_INFO       0x00008000 //(VKVG_LOG_INFO_PTS|VKVG_LOG_INFO_PATH|VKVG_LOG_INFO_CMD|VKVG_LOG_INFO_VAO)
 
#ifdef DEBUG
vkvg_public extern uint32_t vkvg_log_level;
#ifdef VKVG_WIRED_DEBUG
typedef enum {
    vkvg_wired_debug_mode_normal = 0x01,
    vkvg_wired_debug_mode_points = 0x02,
    vkvg_wired_debug_mode_lines  = 0x04,
    vkvg_wired_debug_mode_both   = vkvg_wired_debug_mode_points | vkvg_wired_debug_mode_lines,
    vkvg_wired_debug_mode_all    = 0xFFFFFFFF
} vkvg_wired_debug_mode;
vkvg_public extern vkvg_wired_debug_mode vkvg_wired_debug;
#endif
#endif
 
typedef enum {
    VKVG_STATUS_SUCCESS = 0,              
    VKVG_STATUS_NO_MEMORY,                
    VKVG_STATUS_NULL_POINTER,             
    VKVG_STATUS_INVALID_RESTORE,          
    VKVG_STATUS_NO_CURRENT_POINT,         
    VKVG_STATUS_INVALID_MATRIX,           
    VKVG_STATUS_INVALID_STATUS,           
    VKVG_STATUS_INVALID_INDEX,            
    VKVG_STATUS_WRITE_ERROR,              
    VKVG_STATUS_PATTERN_TYPE_MISMATCH,    
    VKVG_STATUS_PATTERN_INVALID_GRADIENT, 
    VKVG_STATUS_INVALID_FORMAT,           
    VKVG_STATUS_FILE_NOT_FOUND,           
    VKVG_STATUS_INVALID_DASH,             
    VKVG_STATUS_INVALID_RECT,             
    VKVG_STATUS_TIMEOUT,      
    VKVG_STATUS_DEVICE_ERROR, 
    VKVG_STATUS_INVALID_DEVICE_CREATE_INFO, 
    VKVG_STATUS_INVALID_IMAGE,              
    VKVG_STATUS_INVALID_SURFACE,            
    VKVG_STATUS_INVALID_FONT,               
    VKVG_STATUS_IN_CACHE, 
    VKVG_STATUS_ENUM_MAX = 0x7FFFFFFF
} vkvg_status_t;
 
typedef enum { VKVG_HORIZONTAL = 0, VKVG_VERTICAL = 1 } vkvg_direction_t;
 
typedef enum { VKVG_FORMAT_ARGB32, VKVG_FORMAT_RGB24, VKVG_FORMAT_A8, VKVG_FORMAT_A1 } vkvg_format_t;
typedef enum {
    VKVG_EXTEND_NONE,    
    VKVG_EXTEND_REPEAT,  
    VKVG_EXTEND_REFLECT, 
    VKVG_EXTEND_PAD      
} vkvg_extend_t;
 
typedef enum {
    VKVG_FILTER_FAST,
    VKVG_FILTER_GOOD,
    VKVG_FILTER_BEST,
    VKVG_FILTER_NEAREST,
    VKVG_FILTER_BILINEAR,
    VKVG_FILTER_GAUSSIAN,
} vkvg_filter_t;
 
typedef enum {
    VKVG_PATTERN_TYPE_SOLID,         
    VKVG_PATTERN_TYPE_SURFACE,       
    VKVG_PATTERN_TYPE_LINEAR,        
    VKVG_PATTERN_TYPE_RADIAL,        
    VKVG_PATTERN_TYPE_MESH,          
    VKVG_PATTERN_TYPE_RASTER_SOURCE, 
} vkvg_pattern_type_t;
 
typedef enum {
    VKVG_LINE_CAP_BUTT,  
    VKVG_LINE_CAP_ROUND, 
    VKVG_LINE_CAP_SQUARE 
} vkvg_line_cap_t;
typedef enum {
    VKVG_LINE_JOIN_MITER, 
    VKVG_LINE_JOIN_ROUND, 
    VKVG_LINE_JOIN_BEVEL  
} vkvg_line_join_t;
 
typedef enum {
    VKVG_FILL_RULE_EVEN_ODD, 
    VKVG_FILL_RULE_NON_ZERO  
} vkvg_fill_rule_t;
 
typedef struct {
    float r; 
    float g; 
    float b; 
    float a; 
} vkvg_color_t;
 
typedef struct {
    float ascent;        
    float descent;       
    float height;        
    float max_x_advance; 
    float max_y_advance; 
} vkvg_font_extents_t;
typedef struct {
    float x_bearing; 
    float y_bearing; 
    float width;     
    float height;    
    float x_advance; 
    float y_advance; 
} vkvg_text_extents_t;
 
typedef struct _glyph_info_t {
    int32_t x_advance;
    int32_t y_advance;
    int32_t x_offset;
    int32_t y_offset;
    /* private */
    uint32_t codepoint; // should be named glyphIndex, but for harfbuzz compatibility...
} vkvg_glyph_info_t;
 
typedef struct _vkvg_text_run_t* VkvgText;
 
typedef struct _vkvg_context_t* VkvgContext;
typedef struct _vkvg_surface_t* VkvgSurface;
typedef struct _vkvg_device_t* VkvgDevice;
typedef struct _vkvg_pattern_t* VkvgPattern;
 
#if VKVG_DBG_STATS
#define VKVG_HAS_DBG_STATS 
typedef struct {
    uint32_t sizePoints;   
    uint32_t sizePathes;   
    uint32_t sizeVertices; 
    uint32_t sizeIndices;  
    uint32_t sizeVBO;      
    uint32_t sizeIBO;      
} vkvg_debug_stats_t;
 
vkvg_debug_stats_t vkvg_device_get_stats(VkvgDevice dev);
void               vkvg_device_reset_stats(VkvgDevice dev);
#endif
 
#define VKVG_IDENTITY_MATRIX (vkvg_matrix_t){1, 0, 0, 1, 0, 0} 
typedef struct {
    float xx;
    float yx;
    float xy;
    float yy;
    float x0;
    float y0;
} vkvg_matrix_t;
vkvg_public void vkvg_matrix_init_identity(vkvg_matrix_t* matrix);
vkvg_public void vkvg_matrix_init(vkvg_matrix_t* matrix, float xx, float yx, float xy, float yy, float x0, float y0);
vkvg_public void vkvg_matrix_init_translate(vkvg_matrix_t* matrix, float tx, float ty);
vkvg_public void vkvg_matrix_init_scale(vkvg_matrix_t* matrix, float sx, float sy);
vkvg_public void vkvg_matrix_init_rotate(vkvg_matrix_t* matrix, float radians);
vkvg_public void vkvg_matrix_translate(vkvg_matrix_t* matrix, float tx, float ty);
vkvg_public void vkvg_matrix_scale(vkvg_matrix_t* matrix, float sx, float sy);
vkvg_public void vkvg_matrix_rotate(vkvg_matrix_t* matrix, float radians);
vkvg_public void vkvg_matrix_multiply(vkvg_matrix_t* result, const vkvg_matrix_t* a, const vkvg_matrix_t* b);
vkvg_public void vkvg_matrix_transform_distance(const vkvg_matrix_t* matrix, float* dx, float* dy);
vkvg_public void vkvg_matrix_transform_point(const vkvg_matrix_t* matrix, float* x, float* y);
vkvg_public vkvg_status_t vkvg_matrix_invert(vkvg_matrix_t* matrix);
vkvg_public void          vkvg_matrix_get_scale(const vkvg_matrix_t* matrix, float* sx, float* sy);
typedef struct {
    VkSampleCountFlags samples;
    bool               deferredResolve;
    VkInstance         inst;
    VkPhysicalDevice   phy;
    VkDevice           vkdev;
    uint32_t           qFamIdx;
    uint32_t           qIndex;
    bool               threadAware; 
} vkvg_device_create_info_t;
 
vkvg_public
    void
    vkvg_device_set_context_cache_size(VkvgDevice dev, uint32_t maxCount);
vkvg_public VkvgDevice vkvg_device_create(vkvg_device_create_info_t* info);
vkvg_public void vkvg_device_destroy(VkvgDevice dev);
vkvg_public vkvg_status_t vkvg_device_status(VkvgDevice dev);
vkvg_public VkvgDevice vkvg_device_reference(VkvgDevice dev);
vkvg_public uint32_t vkvg_device_get_reference_count(VkvgDevice dev);
vkvg_public void vkvg_device_set_dpy(VkvgDevice dev, int hdpy, int vdpy);
vkvg_public void vkvg_device_get_dpy(VkvgDevice dev, int* hdpy, int* vdpy);
 
vkvg_public void vkvg_get_required_instance_extensions(const char** pExtensions, uint32_t* pExtCount);
vkvg_public vkvg_status_t vkvg_get_required_device_extensions(VkPhysicalDevice phy, const char** pExtensions,
                                                              uint32_t* pExtCount);
vkvg_public const void* vkvg_get_device_requirements(VkPhysicalDeviceFeatures* pEnabledFeatures);
vkvg_public VkvgSurface vkvg_surface_create(VkvgDevice dev, uint32_t width, uint32_t height);
vkvg_public VkvgSurface vkvg_surface_create_from_image(VkvgDevice dev, const char* filePath);
vkvg_public VkvgSurface vkvg_surface_create_for_VkhImage(VkvgDevice dev, void* vkhImg);
vkvg_public VkvgSurface vkvg_surface_create_from_bitmap(VkvgDevice dev, unsigned char* img, uint32_t width,
                                                        uint32_t height);
vkvg_public vkvg_status_t vkvg_surface_status(VkvgSurface surf);
vkvg_public VkvgSurface vkvg_surface_reference(VkvgSurface surf);
vkvg_public uint32_t vkvg_surface_get_reference_count(VkvgSurface surf);
vkvg_public void vkvg_surface_destroy(VkvgSurface surf);
vkvg_public vkvg_status_t vkvg_surface_status(VkvgSurface surf);
vkvg_public void vkvg_surface_clear(VkvgSurface surf);
vkvg_public VkImage vkvg_surface_get_vk_image(VkvgSurface surf);
vkvg_public VkFormat vkvg_surface_get_vk_format(VkvgSurface surf);
vkvg_public uint32_t vkvg_surface_get_width(VkvgSurface surf);
vkvg_public uint32_t vkvg_surface_get_height(VkvgSurface surf);
vkvg_public vkvg_status_t vkvg_surface_write_to_png(VkvgSurface surf, const char* path);
vkvg_public vkvg_status_t vkvg_surface_write_to_memory(VkvgSurface surf, unsigned char* const bitmap);
vkvg_public void vkvg_surface_resolve(VkvgSurface surf);
// mimic from cairo, to facilitate usage of vkvg as cairo vulkan backend
 
typedef enum _vkvg_operator {
    VKVG_OPERATOR_CLEAR,
 
    VKVG_OPERATOR_SOURCE,
    VKVG_OPERATOR_OVER,
    /*  VKVG_OPERATOR_IN,
        VKVG_OPERATOR_OUT,
        VKVG_OPERATOR_ATOP,
 
        VKVG_OPERATOR_DEST,
        VKVG_OPERATOR_DEST_OVER,
        VKVG_OPERATOR_DEST_IN,
        VKVG_OPERATOR_DEST_OUT,
        VKVG_OPERATOR_DEST_ATOP,
 
        VKVG_OPERATOR_XOR,
        VKVG_OPERATOR_ADD,
        VKVG_OPERATOR_SATURATE,
 
        VKVG_OPERATOR_MULTIPLY,
        VKVG_OPERATOR_SCREEN,
        VKVG_OPERATOR_OVERLAY,
        VKVG_OPERATOR_DARKEN,
        VKVG_OPERATOR_LIGHTEN,
        VKVG_OPERATOR_COLOR_DODGE,
        VKVG_OPERATOR_COLOR_BURN,
        VKVG_OPERATOR_HARD_LIGHT,
        VKVG_OPERATOR_SOFT_LIGHT,
        */
    VKVG_OPERATOR_DIFFERENCE, /*
   VKVG_OPERATOR_EXCLUSION,
   VKVG_OPERATOR_HSL_HUE,
   VKVG_OPERATOR_HSL_SATURATION,
   VKVG_OPERATOR_HSL_COLOR,
   VKVG_OPERATOR_HSL_LUMINOSITY,*/
    VKVG_OPERATOR_MAX,
} vkvg_operator_t;
 
vkvg_public VkvgContext vkvg_create(VkvgSurface surf);
vkvg_public void vkvg_destroy(VkvgContext ctx);
vkvg_public vkvg_status_t vkvg_status(VkvgContext ctx);
vkvg_public const char* vkvg_status_to_string(vkvg_status_t status);
vkvg_public VkvgContext vkvg_reference(VkvgContext ctx);
vkvg_public uint32_t vkvg_get_reference_count(VkvgContext ctx);
vkvg_public void vkvg_flush(VkvgContext ctx);
vkvg_public void vkvg_new_path(VkvgContext ctx);
vkvg_public void vkvg_close_path(VkvgContext ctx);
vkvg_public void vkvg_new_sub_path(VkvgContext ctx);
vkvg_public void vkvg_path_extents(VkvgContext ctx, float* const x1, float* const y1, float* const x2, float* const y2);
vkvg_public void vkvg_get_current_point(VkvgContext ctx, float* x, float* y);
vkvg_public void vkvg_line_to(VkvgContext ctx, float x, float y);
vkvg_public void vkvg_rel_line_to(VkvgContext ctx, float dx, float dy);
vkvg_public void vkvg_move_to(VkvgContext ctx, float x, float y);
vkvg_public void vkvg_rel_move_to(VkvgContext ctx, float x, float y);
vkvg_public void vkvg_arc(VkvgContext ctx, float xc, float yc, float radius, float a1, float a2);
vkvg_public void vkvg_arc_negative(VkvgContext ctx, float xc, float yc, float radius, float a1, float a2);
vkvg_public void vkvg_curve_to(VkvgContext ctx, float x1, float y1, float x2, float y2, float x3, float y3);
vkvg_public void vkvg_rel_curve_to(VkvgContext ctx, float x1, float y1, float x2, float y2, float x3, float y3);
vkvg_public void vkvg_quadratic_to(VkvgContext ctx, float x1, float y1, float x2, float y2);
vkvg_public void vkvg_rel_quadratic_to(VkvgContext ctx, float x1, float y1, float x2, float y2);
vkvg_public vkvg_status_t vkvg_rectangle(VkvgContext ctx, float x, float y, float w, float h);
vkvg_public vkvg_status_t vkvg_rounded_rectangle(VkvgContext ctx, float x, float y, float w, float h, float radius);
vkvg_public void vkvg_rounded_rectangle2(VkvgContext ctx, float x, float y, float w, float h, float rx, float ry);
 
vkvg_public void vkvg_ellipse(VkvgContext ctx, float radiusX, float radiusY, float x, float y, float rotationAngle);
vkvg_public void vkvg_elliptic_arc_to(VkvgContext ctx, float x, float y, bool large_arc_flag, bool sweep_flag, float rx,
                                      float ry, float phi);
vkvg_public void vkvg_rel_elliptic_arc_to(VkvgContext ctx, float x, float y, bool large_arc_flag, bool sweep_flag,
                                          float rx, float ry, float phi);
vkvg_public void vkvg_stroke(VkvgContext ctx);
vkvg_public void vkvg_stroke_preserve(VkvgContext ctx);
vkvg_public void vkvg_fill(VkvgContext ctx);
vkvg_public void vkvg_fill_preserve(VkvgContext ctx);
vkvg_public void vkvg_paint(VkvgContext ctx);
vkvg_public void vkvg_clear(VkvgContext ctx); // use vkClearAttachment to speed up clearing surf
vkvg_public void vkvg_reset_clip(VkvgContext ctx);
vkvg_public void vkvg_clip(VkvgContext ctx);
vkvg_public void vkvg_clip_preserve(VkvgContext ctx);
vkvg_public void vkvg_set_opacity(VkvgContext ctx, float opacity);
vkvg_public
    float
    vkvg_get_opacity(VkvgContext ctx);
vkvg_public void vkvg_set_source_color(VkvgContext ctx, uint32_t c);
vkvg_public void vkvg_set_source_rgba(VkvgContext ctx, float r, float g, float b, float a);
vkvg_public void vkvg_set_source_rgb(VkvgContext ctx, float r, float g, float b);
vkvg_public void vkvg_set_source_surface(VkvgContext ctx, VkvgSurface surf, float x, float y);
vkvg_public void vkvg_set_source(VkvgContext ctx, VkvgPattern pat);
vkvg_public void vkvg_set_line_width(VkvgContext ctx, float width);
vkvg_public void vkvg_set_miter_limit(VkvgContext ctx, float limit);
vkvg_public float vkvg_get_miter_limit(VkvgContext ctx);
vkvg_public void vkvg_set_line_cap(VkvgContext ctx, vkvg_line_cap_t cap);
vkvg_public void vkvg_set_line_join(VkvgContext ctx, vkvg_line_join_t join);
vkvg_public void vkvg_set_operator(VkvgContext ctx, vkvg_operator_t op);
vkvg_public void vkvg_set_fill_rule(VkvgContext ctx, vkvg_fill_rule_t fr);
vkvg_public void vkvg_set_dash(VkvgContext ctx, const float* dashes, uint32_t num_dashes, float offset);
vkvg_public void vkvg_get_dash(VkvgContext ctx, const float* dashes, uint32_t* num_dashes, float* offset);
 
vkvg_public float vkvg_get_line_width(VkvgContext ctx);
vkvg_public vkvg_line_cap_t vkvg_get_line_cap(VkvgContext ctx);
vkvg_public vkvg_line_join_t vkvg_get_line_join(VkvgContext ctx);
vkvg_public vkvg_operator_t vkvg_get_operator(VkvgContext ctx);
vkvg_public vkvg_fill_rule_t vkvg_get_fill_rule(VkvgContext ctx);
vkvg_public VkvgPattern vkvg_get_source(VkvgContext ctx);
 
vkvg_public VkvgSurface vkvg_get_target(VkvgContext ctx);
vkvg_public bool vkvg_has_current_point(VkvgContext ctx);
 
vkvg_public void vkvg_save(VkvgContext ctx);
vkvg_public void vkvg_restore(VkvgContext ctx);
vkvg_public void vkvg_translate(VkvgContext ctx, float dx, float dy);
vkvg_public void vkvg_scale(VkvgContext ctx, float sx, float sy);
vkvg_public void vkvg_rotate(VkvgContext ctx, float radians);
vkvg_public void vkvg_transform(VkvgContext ctx, const vkvg_matrix_t* matrix);
vkvg_public void vkvg_set_matrix(VkvgContext ctx, const vkvg_matrix_t* matrix);
vkvg_public void vkvg_get_matrix(VkvgContext ctx, vkvg_matrix_t* const matrix);
vkvg_public void vkvg_identity_matrix(VkvgContext ctx);
 
vkvg_public void vkvg_select_font_face(VkvgContext ctx, const char* name);
vkvg_public void vkvg_load_font_from_path(VkvgContext ctx, const char* path, const char* name);
vkvg_public void vkvg_load_font_from_memory(VkvgContext ctx, unsigned char* fontBuffer, long fontBufferByteSize,
                                            const char* name);
vkvg_public void vkvg_set_font_size(VkvgContext ctx, uint32_t size);
vkvg_public void vkvg_show_text(VkvgContext ctx, const char* utf8);
vkvg_public void vkvg_text_extents(VkvgContext ctx, const char* utf8, vkvg_text_extents_t* extents);
vkvg_public void vkvg_font_extents(VkvgContext ctx, vkvg_font_extents_t* extents);
 
// text run holds harfbuz datas, and prevent recreating them multiple times for the same line of text.
vkvg_public VkvgText vkvg_text_run_create(VkvgContext ctx, const char* text);
vkvg_public VkvgText vkvg_text_run_create_with_length(VkvgContext ctx, const char* text, uint32_t length);
vkvg_public void vkvg_text_run_destroy(VkvgText textRun);
vkvg_public void vkvg_show_text_run(VkvgContext ctx, VkvgText textRun);
vkvg_public void vkvg_text_run_get_extents(VkvgText textRun, vkvg_text_extents_t* extents);
vkvg_public uint32_t vkvg_text_run_get_glyph_count(VkvgText textRun);
vkvg_public void vkvg_text_run_get_glyph_position(VkvgText textRun, uint32_t index, vkvg_glyph_info_t* pGlyphInfo);
vkvg_public vkvg_status_t vkvg_pattern_status(VkvgPattern pat);
vkvg_public VkvgPattern vkvg_pattern_reference(VkvgPattern pat);
vkvg_public uint32_t vkvg_pattern_get_reference_count(VkvgPattern pat);
vkvg_public VkvgPattern vkvg_pattern_create_for_surface(VkvgSurface surf);
vkvg_public VkvgPattern vkvg_pattern_create_linear(float x0, float y0, float x1, float y1);
vkvg_public vkvg_status_t vkvg_pattern_edit_linear(VkvgPattern pat, float x0, float y0, float x1, float y1);
vkvg_public vkvg_status_t vkvg_pattern_get_linear_points(VkvgPattern pat, float* x0, float* y0, float* x1, float* y1);
vkvg_public VkvgPattern vkvg_pattern_create_radial(float cx0, float cy0, float radius0, float cx1, float cy1,
                                                   float radius1);
vkvg_public vkvg_status_t vkvg_pattern_edit_radial(VkvgPattern pat, float cx0, float cy0, float radius0, float cx1,
                                                   float cy1, float radius1);
vkvg_public vkvg_status_t vkvg_pattern_get_color_stop_count(VkvgPattern pat, uint32_t* count);
vkvg_public vkvg_status_t vkvg_pattern_get_color_stop_rgba(VkvgPattern pat, uint32_t index, float* offset, float* r,
                                                           float* g, float* b, float* a);
 
vkvg_public void vkvg_pattern_destroy(VkvgPattern pat);
vkvg_public vkvg_status_t vkvg_pattern_add_color_stop(VkvgPattern pat, float offset, float r, float g, float b,
                                                      float a);
vkvg_public void vkvg_pattern_set_extend(VkvgPattern pat, vkvg_extend_t extend);
vkvg_public void vkvg_pattern_set_filter(VkvgPattern pat, vkvg_filter_t filter);
vkvg_public vkvg_extend_t vkvg_pattern_get_extend(VkvgPattern pat);
vkvg_public vkvg_filter_t vkvg_pattern_get_filter(VkvgPattern pat);
vkvg_public vkvg_pattern_type_t vkvg_pattern_get_type(VkvgPattern pat);
vkvg_public void                vkvg_pattern_set_matrix(VkvgPattern pat, const vkvg_matrix_t* matrix);
vkvg_public void                vkvg_pattern_get_matrix(VkvgPattern pat, vkvg_matrix_t* matrix);
 
/********* EXPERIMENTAL **************/
vkvg_public void vkvg_set_source_color_name(VkvgContext ctx, const char* color);
 
#ifdef VKVG_RECORDING
typedef struct _vkvg_recording_t* VkvgRecording;
 
vkvg_public void          vkvg_start_recording(VkvgContext ctx);
vkvg_public VkvgRecording vkvg_stop_recording(VkvgContext ctx);
vkvg_public void          vkvg_replay(VkvgContext ctx, VkvgRecording rec);
vkvg_public void          vkvg_replay_command(VkvgContext ctx, VkvgRecording rec, uint32_t cmdIndex);
vkvg_public void     vkvg_recording_get_command(VkvgRecording rec, uint32_t cmdIndex, uint32_t* cmd, void** dataOffset);
vkvg_public uint32_t vkvg_recording_get_count(VkvgRecording rec);
vkvg_public void*    vkvg_recording_get_data(VkvgRecording rec);
vkvg_public void     vkvg_recording_destroy(VkvgRecording rec);
/*************************************/
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif