render.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2025 Samuel Ugochukwu <sammycageagle@gmail.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 NOVASVG_RENDER_H
#define NOVASVG_RENDER_H
 
#include <stdbool.h>
 
// NOVASVG_MAX/NOVASVG_MIN are defined in novasvg.h, which #includes
// (transitively, via canvas.h) this header -- always available by the
// time any of the macros below are actually used at a call site.
 
// Pure C++ project: no separate C translation units link against this,
// so the extern "C" wrapper this file used to have (for use as a
// standalone C library) has been dropped along with the novasvg_ prefix
// below -- everything here now lives in namespace novasvg::render
// instead.
namespace novasvg {
namespace render {
 
// NovaSVG is header-only: every function is NOVASVG_INLINE, so the default
// linkage must NOT be dllimport/dllexport. On MSVC, __declspec(dllimport) on
// an inline-defined function suppresses the inline body and produces LNK2019
// unresolved externals. Shared-library decoration is therefore opt-in via
// NOVASVG_BUILD_SHARED.
#if defined(NOVASVG_BUILD_STATIC) || !defined(NOVASVG_BUILD_SHARED)
#define NOVASVG_EXPORT
#define NOVASVG_IMPORT
#elif (defined(_WIN32) || defined(__CYGWIN__))
#define NOVASVG_EXPORT __declspec(dllexport)
#define NOVASVG_IMPORT __declspec(dllimport)
#elif defined(__GNUC__) && (__GNUC__ >= 4)
#define NOVASVG_EXPORT __attribute__((__visibility__("default")))
#define NOVASVG_IMPORT
#else
#define NOVASVG_EXPORT
#define NOVASVG_IMPORT
#endif
 
#ifdef NOVASVG_BUILD
#define NOVASVG_API NOVASVG_EXPORT
#else
#define NOVASVG_API NOVASVG_IMPORT
#endif
 
#define NOVASVG_RENDER_VERSION_MAJOR 1
#define NOVASVG_RENDER_VERSION_MINOR 3
#define NOVASVG_RENDER_VERSION_MICRO 2
 
#define NOVASVG_RENDER_VERSION_ENCODE(major, minor, micro) (((major) * 10000) + ((minor) * 100) + ((micro) * 1))
#define NOVASVG_RENDER_VERSION NOVASVG_RENDER_VERSION_ENCODE(NOVASVG_RENDER_VERSION_MAJOR, NOVASVG_RENDER_VERSION_MINOR, NOVASVG_RENDER_VERSION_MICRO)
 
#define NOVASVG_RENDER_VERSION_XSTRINGIZE(major, minor, micro) #major"."#minor"."#micro
#define NOVASVG_RENDER_VERSION_STRINGIZE(major, minor, micro) NOVASVG_RENDER_VERSION_XSTRINGIZE(major, minor, micro)
#define NOVASVG_RENDER_VERSION_STRING NOVASVG_RENDER_VERSION_STRINGIZE(NOVASVG_RENDER_VERSION_MAJOR, NOVASVG_RENDER_VERSION_MINOR, NOVASVG_RENDER_VERSION_MICRO)
 
NOVASVG_API int render_version(void);
 
NOVASVG_API const char* render_version_string(void);
 
typedef void (*destroy_func_t)(void* closure);
 
typedef void (*write_func_t)(void* closure, void* data, int size);
 
#define NOVASVG_PI      3.14159265358979323846f
#define NOVASVG_TWO_PI  6.28318530717958647693f
#define NOVASVG_HALF_PI 1.57079632679489661923f
#define NOVASVG_SQRT2   1.41421356237309504880f
#define NOVASVG_KAPPA   0.55228474983079339840f
 
#define NOVASVG_DEG2RAD(x) ((x) * (NOVASVG_PI / 180.0f))
#define NOVASVG_RAD2DEG(x) ((x) * (180.0f / NOVASVG_PI))
 
typedef struct point {
    float x; 
    float y; 
} point_t;
 
#define NOVASVG_MAKE_POINT(x, y) (point_t{x, y})
#define NOVASVG_EMPTY_POINT NOVASVG_MAKE_POINT(0, 0)
 
typedef struct rect {
    float x; 
    float y; 
    float w; 
    float h; 
} rect_t;
 
#define NOVASVG_MAKE_RECT(x, y, w, h) (rect_t{x, y, w, h})
#define NOVASVG_EMPTY_RECT NOVASVG_MAKE_RECT(0, 0, 0, 0)
 
typedef struct matrix {
    float a; 
    float b; 
    float c; 
    float d; 
    float e; 
    float f; 
} matrix_t;
 
#define NOVASVG_MAKE_MATRIX(a, b, c, d, e, f) (matrix_t{a, b, c, d, e, f})
#define NOVASVG_MAKE_SCALE(x, y) NOVASVG_MAKE_MATRIX(x, 0, 0, y, 0, 0)
#define NOVASVG_MAKE_TRANSLATE(x, y) NOVASVG_MAKE_MATRIX(1, 0, 0, 1, x, y)
#define NOVASVG_IDENTITY_MATRIX NOVASVG_MAKE_MATRIX(1, 0, 0, 1, 0, 0)
 
NOVASVG_API void matrix_init(matrix_t* matrix, float a, float b, float c, float d, float e, float f);
 
NOVASVG_API void matrix_init_identity(matrix_t* matrix);
 
NOVASVG_API void matrix_init_translate(matrix_t* matrix, float tx, float ty);
 
NOVASVG_API void matrix_init_scale(matrix_t* matrix, float sx, float sy);
 
NOVASVG_API void matrix_init_rotate(matrix_t* matrix, float angle);
 
NOVASVG_API void matrix_init_shear(matrix_t* matrix, float shx, float shy);
 
NOVASVG_API void matrix_translate(matrix_t* matrix, float tx, float ty);
 
NOVASVG_API void matrix_scale(matrix_t* matrix, float sx, float sy);
 
NOVASVG_API void matrix_rotate(matrix_t* matrix, float angle);
 
NOVASVG_API void matrix_shear(matrix_t* matrix, float shx, float shy);
 
NOVASVG_API void matrix_multiply(matrix_t* matrix, const matrix_t* left, const matrix_t* right);
 
NOVASVG_API bool matrix_invert(const matrix_t* matrix, matrix_t* inverse);
 
NOVASVG_API void matrix_map(const matrix_t* matrix, float x, float y, float* xx, float* yy);
 
NOVASVG_API void matrix_map_point(const matrix_t* matrix, const point_t* src, point_t* dst);
 
NOVASVG_API void matrix_map_points(const matrix_t* matrix, const point_t* src, point_t* dst, int count);
 
NOVASVG_API void matrix_map_rect(const matrix_t* matrix, const rect_t* src, rect_t* dst);
 
NOVASVG_API bool matrix_parse(matrix_t* matrix, const char* data, int length);
 
typedef struct path path_t;
 
typedef enum path_command {
    NOVASVG_PATH_COMMAND_MOVE_TO, 
    NOVASVG_PATH_COMMAND_LINE_TO, 
    NOVASVG_PATH_COMMAND_CUBIC_TO, 
    NOVASVG_PATH_COMMAND_CLOSE 
} path_command_t;
 
typedef union path_element {
    struct {
        path_command_t command; 
        int length; 
    } header; 
    point_t point; 
} path_element_t;
 
typedef struct path_iterator {
    const path_element_t* elements; 
    int size; 
    int index; 
} path_iterator_t;
 
NOVASVG_API void path_iterator_init(path_iterator_t* it, const path_t* path);
 
NOVASVG_API bool path_iterator_has_next(const path_iterator_t* it);
 
NOVASVG_API path_command_t path_iterator_next(path_iterator_t* it, point_t points[3]);
 
NOVASVG_API path_t* path_create(void);
 
NOVASVG_API path_t* path_reference(path_t* path);
 
NOVASVG_API void path_destroy(path_t* path);
 
NOVASVG_API int path_get_reference_count(const path_t* path);
 
NOVASVG_API int path_get_elements(const path_t* path, const path_element_t** elements);
 
NOVASVG_API void path_move_to(path_t* path, float x, float y);
 
NOVASVG_API void path_line_to(path_t* path, float x, float y);
 
NOVASVG_API void path_quad_to(path_t* path, float x1, float y1, float x2, float y2);
 
NOVASVG_API void path_cubic_to(path_t* path, float x1, float y1, float x2, float y2, float x3, float y3);
 
NOVASVG_API void path_arc_to(path_t* path, float rx, float ry, float angle, bool large_arc_flag, bool sweep_flag, float x, float y);
 
NOVASVG_API void path_close(path_t* path);
 
NOVASVG_API void path_get_current_point(const path_t* path, float* x, float* y);
 
NOVASVG_API void path_reserve(path_t* path, int count);
 
NOVASVG_API void path_reset(path_t* path);
 
NOVASVG_API void path_add_rect(path_t* path, float x, float y, float w, float h);
 
NOVASVG_API void path_add_round_rect(path_t* path, float x, float y, float w, float h, float rx, float ry);
 
NOVASVG_API void path_add_ellipse(path_t* path, float cx, float cy, float rx, float ry);
 
NOVASVG_API void path_add_circle(path_t* path, float cx, float cy, float r);
 
NOVASVG_API void path_add_arc(path_t* path, float cx, float cy, float r, float a0, float a1, bool ccw);
 
NOVASVG_API void path_add_path(path_t* path, const path_t* source, const matrix_t* matrix);
 
NOVASVG_API void path_transform(path_t* path, const matrix_t* matrix);
 
typedef void (*path_traverse_func_t)(void* closure, path_command_t command, const point_t* points, int npoints);
 
NOVASVG_API void path_traverse(const path_t* path, path_traverse_func_t traverse_func, void* closure);
 
NOVASVG_API void path_traverse_flatten(const path_t* path, path_traverse_func_t traverse_func, void* closure);
 
NOVASVG_API void path_traverse_dashed(const path_t* path, float offset, const float* dashes, int ndashes, path_traverse_func_t traverse_func, void* closure);
 
NOVASVG_API path_t* path_clone(const path_t* path);
 
NOVASVG_API path_t* path_clone_flatten(const path_t* path);
 
NOVASVG_API path_t* path_clone_dashed(const path_t* path, float offset, const float* dashes, int ndashes);
 
NOVASVG_API float path_extents(const path_t* path, rect_t* extents, bool tight);
 
NOVASVG_API float path_length(const path_t* path);
 
NOVASVG_API bool path_parse(path_t* path, const char* data, int length);
 
typedef enum text_encoding {
    NOVASVG_TEXT_ENCODING_LATIN1, 
    NOVASVG_TEXT_ENCODING_UTF8, 
    NOVASVG_TEXT_ENCODING_UTF16, 
    NOVASVG_TEXT_ENCODING_UTF32 
} text_encoding_t;
 
typedef struct text_iterator {
    const void* text; 
    int length; 
    text_encoding_t encoding; 
    int index; 
} text_iterator_t;
 
typedef unsigned int codepoint_t;
 
NOVASVG_API void text_iterator_init(text_iterator_t* it, const void* text, int length, text_encoding_t encoding);
 
NOVASVG_API bool text_iterator_has_next(const text_iterator_t* it);
 
NOVASVG_API codepoint_t text_iterator_next(text_iterator_t* it);
 
typedef struct font_face font_face_t;
 
NOVASVG_API font_face_t* font_face_load_from_file(const char* filename, int ttcindex);
 
NOVASVG_API font_face_t* font_face_load_from_data(const void* data, unsigned int length, int ttcindex, destroy_func_t destroy_func, void* closure);
 
NOVASVG_API font_face_t* font_face_reference(font_face_t* face);
 
NOVASVG_API void font_face_destroy(font_face_t* face);
 
NOVASVG_API int font_face_get_reference_count(const font_face_t* face);
 
NOVASVG_API void font_face_get_metrics(const font_face_t* face, float size, float* ascent, float* descent, float* line_gap, rect_t* extents);
 
NOVASVG_API void font_face_get_glyph_metrics(font_face_t* face, float size, codepoint_t codepoint, float* advance_width, float* left_side_bearing, rect_t* extents);
 
NOVASVG_API float font_face_get_glyph_path(font_face_t* face, float size, float x, float y, codepoint_t codepoint, path_t* path);
 
NOVASVG_API float font_face_traverse_glyph_path(font_face_t* face, float size, float x, float y, codepoint_t codepoint, path_traverse_func_t traverse_func, void* closure);
 
NOVASVG_API float font_face_text_extents(font_face_t* face, float size, const void* text, int length, text_encoding_t encoding, rect_t* extents);
 
typedef struct font_face_cache font_face_cache_t;
 
NOVASVG_API font_face_cache_t* font_face_cache_create(void);
 
NOVASVG_API font_face_cache_t* font_face_cache_reference(font_face_cache_t* cache);
 
NOVASVG_API void font_face_cache_destroy(font_face_cache_t* cache);
 
NOVASVG_API int font_face_cache_reference_count(const font_face_cache_t* cache);
 
NOVASVG_API void font_face_cache_reset(font_face_cache_t* cache);
 
NOVASVG_API void font_face_cache_add(font_face_cache_t* cache, const char* family, bool bold, bool italic, font_face_t* face);
 
NOVASVG_API bool font_face_cache_add_file(font_face_cache_t* cache, const char* family, bool bold, bool italic, const char* filename, int ttcindex);
 
NOVASVG_API font_face_t* font_face_cache_get(font_face_cache_t* cache, const char* family, bool bold, bool italic);
 
NOVASVG_API int font_face_cache_load_file(font_face_cache_t* cache, const char* filename);
 
NOVASVG_API int font_face_cache_load_dir(font_face_cache_t* cache, const char* dirname);
 
NOVASVG_API int font_face_cache_load_sys(font_face_cache_t* cache);
 
typedef struct color {
    float r; 
    float g; 
    float b; 
    float a; 
} color_t;
 
#define NOVASVG_MAKE_COLOR(r, g, b, a) (color_t{r, g, b, a})
 
#define NOVASVG_BLACK_COLOR   NOVASVG_MAKE_COLOR(0, 0, 0, 1)
#define NOVASVG_WHITE_COLOR   NOVASVG_MAKE_COLOR(1, 1, 1, 1)
#define NOVASVG_RED_COLOR     NOVASVG_MAKE_COLOR(1, 0, 0, 1)
#define NOVASVG_GREEN_COLOR   NOVASVG_MAKE_COLOR(0, 1, 0, 1)
#define NOVASVG_BLUE_COLOR    NOVASVG_MAKE_COLOR(0, 0, 1, 1)
#define NOVASVG_YELLOW_COLOR  NOVASVG_MAKE_COLOR(1, 1, 0, 1)
#define NOVASVG_CYAN_COLOR    NOVASVG_MAKE_COLOR(0, 1, 1, 1)
#define NOVASVG_MAGENTA_COLOR NOVASVG_MAKE_COLOR(1, 0, 1, 1)
 
NOVASVG_API void color_init_rgb(color_t* color, float r, float g, float b);
 
NOVASVG_API void color_init_rgba(color_t* color, float r, float g, float b, float a);
 
NOVASVG_API void color_init_rgb8(color_t* color, int r, int g, int b);
 
NOVASVG_API void color_init_rgba8(color_t* color, int r, int g, int b, int a);
 
NOVASVG_API void color_init_rgba32(color_t* color, unsigned int value);
 
NOVASVG_API void color_init_argb32(color_t* color, unsigned int value);
 
NOVASVG_API void color_init_hsl(color_t* color, float h, float s, float l);
 
NOVASVG_API void color_init_hsla(color_t* color, float h, float s, float l, float a);
 
NOVASVG_API unsigned int color_to_rgba32(const color_t* color);
 
NOVASVG_API unsigned int color_to_argb32(const color_t* color);
 
NOVASVG_API int color_parse(color_t* color, const char* data, int length);
 
typedef struct surface surface_t;
 
NOVASVG_API surface_t* surface_create(int width, int height);
 
NOVASVG_API surface_t* surface_create_for_data(unsigned char* data, int width, int height, int stride);
 
NOVASVG_API surface_t* surface_load_from_image_file(const char* filename);
 
NOVASVG_API surface_t* surface_load_from_image_data(const void* data, int length);
 
NOVASVG_API surface_t* surface_load_from_image_base64(const char* data, int length);
 
NOVASVG_API surface_t* surface_reference(surface_t* surface);
 
NOVASVG_API void surface_destroy(surface_t* surface);
 
NOVASVG_API int surface_get_reference_count(const surface_t* surface);
 
NOVASVG_API unsigned char* surface_get_data(const surface_t* surface);
 
NOVASVG_API int surface_get_width(const surface_t* surface);
 
NOVASVG_API int surface_get_height(const surface_t* surface);
 
NOVASVG_API int surface_get_stride(const surface_t* surface);
 
NOVASVG_API void surface_clear(surface_t* surface, const color_t* color);
 
NOVASVG_API void convert_argb_to_rgba(unsigned char* dst, const unsigned char* src, int width, int height, int stride);
 
NOVASVG_API void convert_rgba_to_argb(unsigned char* dst, const unsigned char* src, int width, int height, int stride);
 
typedef enum {
    NOVASVG_TEXTURE_TYPE_PLAIN, 
    NOVASVG_TEXTURE_TYPE_TILED 
} texture_type_t;
 
typedef enum {
    NOVASVG_SPREAD_METHOD_PAD, 
    NOVASVG_SPREAD_METHOD_REFLECT, 
    NOVASVG_SPREAD_METHOD_REPEAT 
} spread_method_t;
 
typedef struct {
    float offset; 
    color_t color; 
} gradient_stop_t;
 
typedef struct paint paint_t;
 
NOVASVG_API paint_t* paint_create_rgb(float r, float g, float b);
 
NOVASVG_API paint_t* paint_create_rgba(float r, float g, float b, float a);
 
NOVASVG_API paint_t* paint_create_color(const color_t* color);
 
NOVASVG_API paint_t* paint_create_linear_gradient(float x1, float y1, float x2, float y2,
    spread_method_t spread, const gradient_stop_t* stops, int nstops, const matrix_t* matrix);
 
NOVASVG_API paint_t* paint_create_radial_gradient(float cx, float cy, float cr, float fx, float fy, float fr,
    spread_method_t spread, const gradient_stop_t* stops, int nstops, const matrix_t* matrix);
 
NOVASVG_API paint_t* paint_create_texture(surface_t* surface, texture_type_t type, float opacity, const matrix_t* matrix);
 
NOVASVG_API paint_t* paint_reference(paint_t* paint);
 
NOVASVG_API void paint_destroy(paint_t* paint);
 
NOVASVG_API int paint_get_reference_count(const paint_t* paint);
 
typedef enum {
    NOVASVG_FILL_RULE_NON_ZERO, 
    NOVASVG_FILL_RULE_EVEN_ODD 
} fill_rule_t;
 
typedef enum {
    NOVASVG_OPERATOR_CLEAR,       
    NOVASVG_OPERATOR_SRC,         
    NOVASVG_OPERATOR_DST,         
    NOVASVG_OPERATOR_SRC_OVER,    
    NOVASVG_OPERATOR_DST_OVER,    
    NOVASVG_OPERATOR_SRC_IN,      
    NOVASVG_OPERATOR_DST_IN,      
    NOVASVG_OPERATOR_SRC_OUT,     
    NOVASVG_OPERATOR_DST_OUT,     
    NOVASVG_OPERATOR_SRC_ATOP,    
    NOVASVG_OPERATOR_DST_ATOP,    
    NOVASVG_OPERATOR_XOR,         
    // CSS blend modes (W3C Compositing and Blending): the source is blended with the backdrop's colour,
    // then composited over it. Appended after the Porter-Duff operators; same order as the tables in blend.h.
    NOVASVG_OPERATOR_MULTIPLY,    
    NOVASVG_OPERATOR_SCREEN,      
    NOVASVG_OPERATOR_DARKEN,      
    NOVASVG_OPERATOR_LIGHTEN,     
    NOVASVG_OPERATOR_DIFFERENCE,  
    NOVASVG_OPERATOR_EXCLUSION    
} operator_t;
 
typedef enum {
    NOVASVG_LINE_CAP_BUTT, 
    NOVASVG_LINE_CAP_ROUND, 
    NOVASVG_LINE_CAP_SQUARE 
} line_cap_t;
 
typedef enum {
    NOVASVG_LINE_JOIN_MITER, 
    NOVASVG_LINE_JOIN_ROUND, 
    NOVASVG_LINE_JOIN_BEVEL 
} line_join_t;
 
typedef struct canvas canvas_t;
 
NOVASVG_API canvas_t* canvas_create(surface_t* surface);
 
NOVASVG_API canvas_t* canvas_reference(canvas_t* canvas);
 
NOVASVG_API void canvas_destroy(canvas_t* canvas);
 
NOVASVG_API int canvas_get_reference_count(const canvas_t* canvas);
 
NOVASVG_API surface_t* canvas_get_surface(const canvas_t* canvas);
 
NOVASVG_API void canvas_save(canvas_t* canvas);
 
NOVASVG_API void canvas_restore(canvas_t* canvas);
 
NOVASVG_API void canvas_set_rgb(canvas_t* canvas, float r, float g, float b);
 
NOVASVG_API void canvas_set_rgba(canvas_t* canvas, float r, float g, float b, float a);
 
NOVASVG_API void canvas_set_color(canvas_t* canvas, const color_t* color);
 
NOVASVG_API void canvas_set_linear_gradient(canvas_t* canvas, float x1, float y1, float x2, float y2,
    spread_method_t spread, const gradient_stop_t* stops, int nstops, const matrix_t* matrix);
 
NOVASVG_API void canvas_set_radial_gradient(canvas_t* canvas, float cx, float cy, float cr, float fx, float fy, float fr,
    spread_method_t spread, const gradient_stop_t* stops, int nstops, const matrix_t* matrix);
 
NOVASVG_API void canvas_set_texture(canvas_t* canvas, surface_t* surface, texture_type_t type, float opacity, const matrix_t* matrix);
 
NOVASVG_API void canvas_set_paint(canvas_t* canvas, paint_t* paint);
 
NOVASVG_API paint_t* canvas_get_paint(const canvas_t* canvas, color_t* color);
 
NOVASVG_API void canvas_set_font_face_cache(canvas_t* canvas, font_face_cache_t* cache);
 
NOVASVG_API font_face_cache_t* canvas_get_font_face_cache(const canvas_t* canvas);
 
NOVASVG_API void canvas_add_font_face(canvas_t* canvas, const char* family, bool bold, bool italic, font_face_t* face);
 
NOVASVG_API bool canvas_add_font_file(canvas_t* canvas, const char* family, bool bold, bool italic, const char* filename, int ttcindex);
 
NOVASVG_API bool canvas_select_font_face(canvas_t* canvas, const char* family, bool bold, bool italic);
 
NOVASVG_API void canvas_set_font(canvas_t* canvas, font_face_t* face, float size);
 
NOVASVG_API void canvas_set_font_face(canvas_t* canvas, font_face_t* face);
 
NOVASVG_API font_face_t* canvas_get_font_face(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_font_size(canvas_t* canvas, float size);
 
NOVASVG_API float canvas_get_font_size(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_fill_rule(canvas_t* canvas, fill_rule_t winding);
 
NOVASVG_API fill_rule_t canvas_get_fill_rule(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_operator(canvas_t* canvas, operator_t op);
 
NOVASVG_API operator_t canvas_get_operator(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_opacity(canvas_t* canvas, float opacity);
 
NOVASVG_API float canvas_get_opacity(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_line_width(canvas_t* canvas, float line_width);
 
NOVASVG_API float canvas_get_line_width(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_line_cap(canvas_t* canvas, line_cap_t line_cap);
 
NOVASVG_API line_cap_t canvas_get_line_cap(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_line_join(canvas_t* canvas, line_join_t line_join);
 
NOVASVG_API line_join_t canvas_get_line_join(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_miter_limit(canvas_t* canvas, float miter_limit);
 
NOVASVG_API float canvas_get_miter_limit(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_dash(canvas_t* canvas, float offset, const float* dashes, int ndashes);
 
NOVASVG_API void canvas_set_dash_offset(canvas_t* canvas, float offset);
 
NOVASVG_API float canvas_get_dash_offset(const canvas_t* canvas);
 
NOVASVG_API void canvas_set_dash_array(canvas_t* canvas, const float* dashes, int ndashes);
 
NOVASVG_API int canvas_get_dash_array(const canvas_t* canvas, const float** dashes);
 
NOVASVG_API void canvas_translate(canvas_t* canvas, float tx, float ty);
 
NOVASVG_API void canvas_scale(canvas_t* canvas, float sx, float sy);
 
NOVASVG_API void canvas_shear(canvas_t* canvas, float shx, float shy);
 
NOVASVG_API void canvas_rotate(canvas_t* canvas, float angle);
 
NOVASVG_API void canvas_transform(canvas_t* canvas, const matrix_t* matrix);
 
NOVASVG_API void canvas_reset_matrix(canvas_t* canvas);
 
NOVASVG_API void canvas_set_matrix(canvas_t* canvas, const matrix_t* matrix);
 
NOVASVG_API void canvas_get_matrix(const canvas_t* canvas, matrix_t* matrix);
 
NOVASVG_API void canvas_map(const canvas_t* canvas, float x, float y, float* xx, float* yy);
 
NOVASVG_API void canvas_map_point(const canvas_t* canvas, const point_t* src, point_t* dst);
 
NOVASVG_API void canvas_map_rect(const canvas_t* canvas, const rect_t* src, rect_t* dst);
 
NOVASVG_API void canvas_move_to(canvas_t* canvas, float x, float y);
 
NOVASVG_API void canvas_line_to(canvas_t* canvas, float x, float y);
 
NOVASVG_API void canvas_quad_to(canvas_t* canvas, float x1, float y1, float x2, float y2);
 
NOVASVG_API void canvas_cubic_to(canvas_t* canvas, float x1, float y1, float x2, float y2, float x3, float y3);
 
NOVASVG_API void canvas_arc_to(canvas_t* canvas, float rx, float ry, float angle, bool large_arc_flag, bool sweep_flag, float x, float y);
 
NOVASVG_API void canvas_rect(canvas_t* canvas, float x, float y, float w, float h);
 
NOVASVG_API void canvas_round_rect(canvas_t* canvas, float x, float y, float w, float h, float rx, float ry);
 
NOVASVG_API void canvas_ellipse(canvas_t* canvas, float cx, float cy, float rx, float ry);
 
NOVASVG_API void canvas_circle(canvas_t* canvas, float cx, float cy, float r);
 
NOVASVG_API void canvas_arc(canvas_t* canvas, float cx, float cy, float r, float a0, float a1, bool ccw);
 
NOVASVG_API void canvas_add_path(canvas_t* canvas, const path_t* path);
 
NOVASVG_API void canvas_new_path(canvas_t* canvas);
 
NOVASVG_API void canvas_close_path(canvas_t* canvas);
 
NOVASVG_API void canvas_get_current_point(const canvas_t* canvas, float* x, float* y);
 
NOVASVG_API path_t* canvas_get_path(const canvas_t* canvas);
 
NOVASVG_API bool canvas_fill_contains(canvas_t* canvas, float x, float y);
 
NOVASVG_API bool canvas_stroke_contains(canvas_t* canvas, float x, float y);
 
NOVASVG_API bool canvas_clip_contains(canvas_t* canvas, float x, float y);
 
NOVASVG_API void canvas_fill_extents(canvas_t* canvas, rect_t* extents);
 
NOVASVG_API void canvas_stroke_extents(canvas_t* canvas, rect_t* extents);
 
NOVASVG_API void canvas_clip_extents(canvas_t* canvas, rect_t* extents);
 
NOVASVG_API void canvas_fill(canvas_t* canvas);
 
NOVASVG_API void canvas_stroke(canvas_t* canvas);
 
NOVASVG_API void canvas_clip(canvas_t* canvas);
 
NOVASVG_API void canvas_paint(canvas_t* canvas);
 
NOVASVG_API void canvas_fill_preserve(canvas_t* canvas);
 
NOVASVG_API void canvas_stroke_preserve(canvas_t* canvas);
 
NOVASVG_API void canvas_clip_preserve(canvas_t* canvas);
 
NOVASVG_API void canvas_fill_rect(canvas_t* canvas, float x, float y, float w, float h);
 
NOVASVG_API void canvas_fill_path(canvas_t* canvas, const path_t* path);
 
NOVASVG_API void canvas_stroke_rect(canvas_t* canvas, float x, float y, float w, float h);
 
NOVASVG_API void canvas_stroke_path(canvas_t* canvas, const path_t* path);
 
NOVASVG_API void canvas_clip_rect(canvas_t* canvas, float x, float y, float w, float h);
 
NOVASVG_API void canvas_clip_path(canvas_t* canvas, const path_t* path);
 
NOVASVG_API float canvas_add_glyph(canvas_t* canvas, codepoint_t codepoint, float x, float y);
 
NOVASVG_API float canvas_add_text(canvas_t* canvas, const void* text, int length, text_encoding_t encoding, float x, float y);
 
NOVASVG_API float canvas_fill_text(canvas_t* canvas, const void* text, int length, text_encoding_t encoding, float x, float y);
 
NOVASVG_API float canvas_stroke_text(canvas_t* canvas, const void* text, int length, text_encoding_t encoding, float x, float y);
 
NOVASVG_API float canvas_clip_text(canvas_t* canvas, const void* text, int length, text_encoding_t encoding, float x, float y);
 
NOVASVG_API void canvas_font_metrics(const canvas_t* canvas, float* ascent, float* descent, float* line_gap, rect_t* extents);
 
NOVASVG_API void canvas_glyph_metrics(canvas_t* canvas, codepoint_t codepoint, float* advance_width, float* left_side_bearing, rect_t* extents);
 
NOVASVG_API float canvas_text_extents(canvas_t* canvas, const void* text, int length, text_encoding_t encoding, rect_t* extents);
 
} // namespace render
} // namespace novasvg
 
#endif // NOVASVG_RENDER_H