thorvg.h

#ifndef _THORVG_H_
#define _THORVG_H_
 
#include <functional>
#include <memory>
#include <string>
#include <list>
 
#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
 
#define _TVG_DECLARE_PRIVATE(A) \
    struct Impl; \
    Impl* pImpl; \
protected: \
    A(const A&) = delete; \
    const A& operator=(const A&) = delete; \
    A()
 
#define _TVG_DISABLE_CTOR(A) \
    A() = delete; \
    ~A() = delete
 
#define _TVG_DECLARE_ACCESSOR(A) \
    friend A
 
namespace tvg
{
 
class RenderMethod;
class Animation;
 
enum class Result
{
    Success = 0,           
    InvalidArguments,      
    InsufficientCondition, 
    FailedAllocation,      
    MemoryCorruption,      
    NonSupport,            
    Unknown                
};
 
 
enum class PathCommand
{
    Close = 0, 
    MoveTo,    
    LineTo,    
    CubicTo    
};
 
 
enum class StrokeCap
{
    Square = 0, 
    Round,      
    Butt        
};
 
 
enum class StrokeJoin
{
    Bevel = 0, 
    Round,     
    Miter      
};
 
 
enum class FillSpread
{
    Pad = 0, 
    Reflect, 
    Repeat   
};
 
 
enum class FillRule
{
    Winding = 0, 
    EvenOdd      
};
 
 
enum class CompositeMethod
{
    None = 0,           
    ClipPath,           
    AlphaMask,          
    InvAlphaMask,       
    LumaMask,           
    InvLumaMask,        
    AddMask,            
    SubtractMask,       
    IntersectMask,      
    DifferenceMask      
};
 
 
enum class BlendMethod : uint8_t
{
    Normal = 0,        
    Add,               
    Screen,            
    Multiply,          
    Overlay,           
    Difference,        
    Exclusion,         
    SrcOver,           
    Darken,            
    Lighten,           
    ColorDodge,        
    ColorBurn,         
    HardLight,         
    SoftLight          
};
 
 
enum class CanvasEngine
{
    Sw = (1 << 1), 
    Gl = (1 << 2), 
    Wg = (1 << 3), 
};
 
 
struct Point
{
    float x, y;
};
 
 
struct Matrix
{
    float e11, e12, e13;
    float e21, e22, e23;
    float e31, e32, e33;
};
 
 
struct Vertex
{
   Point pt;
   Point uv;
};
 
 
struct Polygon
{
   Vertex vertex[3];
};
 
 
class TVG_API Paint
{
public:
    virtual ~Paint();
 
    Result rotate(float degree) noexcept;
 
    Result scale(float factor) noexcept;
 
    Result translate(float x, float y) noexcept;
 
    Result transform(const Matrix& m) noexcept;
 
    Matrix transform() noexcept;
 
    Result opacity(uint8_t o) noexcept;
 
    Result composite(std::unique_ptr<Paint> target, CompositeMethod method) noexcept;
 
    Result blend(BlendMethod method) const noexcept;
 
    TVG_DEPRECATED Result bounds(float* x, float* y, float* w, float* h) const noexcept;
 
    Result bounds(float* x, float* y, float* w, float* h, bool transformed) const noexcept;
 
    Paint* duplicate() const noexcept;
 
    uint8_t opacity() const noexcept;
 
    CompositeMethod composite(const Paint** target) const noexcept;
 
    BlendMethod blend() const noexcept;
 
    uint32_t identifier() const noexcept;
 
    _TVG_DECLARE_PRIVATE(Paint);
};
 
 
class TVG_API Fill
{
public:
    struct ColorStop
    {
        float offset; 
        uint8_t r;    
        uint8_t g;    
        uint8_t b;    
        uint8_t a;    
    };
 
    virtual ~Fill();
 
    Result colorStops(const ColorStop* colorStops, uint32_t cnt) noexcept;
 
    Result spread(FillSpread s) noexcept;
 
    Result transform(const Matrix& m) noexcept;
 
    uint32_t colorStops(const ColorStop** colorStops) const noexcept;
 
    FillSpread spread() const noexcept;
 
    Matrix transform() const noexcept;
 
    Fill* duplicate() const noexcept;
 
    uint32_t identifier() const noexcept;
 
    _TVG_DECLARE_PRIVATE(Fill);
};
 
 
class TVG_API Canvas
{
public:
    Canvas(RenderMethod*);
    virtual ~Canvas();
 
    TVG_DEPRECATED Result reserve(uint32_t n) noexcept;
 
    std::list<Paint*>& paints() noexcept;
 
    virtual Result push(std::unique_ptr<Paint> paint) noexcept;
 
    virtual Result clear(bool free = true) noexcept;
 
    virtual Result update(Paint* paint = nullptr) noexcept;
 
    virtual Result draw() noexcept;
 
    virtual Result sync() noexcept;
 
    _TVG_DECLARE_PRIVATE(Canvas);
};
 
 
class TVG_API LinearGradient final : public Fill
{
public:
    ~LinearGradient();
 
    Result linear(float x1, float y1, float x2, float y2) noexcept;
 
    Result linear(float* x1, float* y1, float* x2, float* y2) const noexcept;
 
    static std::unique_ptr<LinearGradient> gen() noexcept;
 
    static uint32_t identifier() noexcept;
 
    _TVG_DECLARE_PRIVATE(LinearGradient);
};
 
 
class TVG_API RadialGradient final : public Fill
{
public:
    ~RadialGradient();
 
    Result radial(float cx, float cy, float radius) noexcept;
 
    Result radial(float* cx, float* cy, float* radius) const noexcept;
 
    static std::unique_ptr<RadialGradient> gen() noexcept;
 
    static uint32_t identifier() noexcept;
 
    _TVG_DECLARE_PRIVATE(RadialGradient);
};
 
 
class TVG_API Shape final : public Paint
{
public:
    ~Shape();
 
    Result reset() noexcept;
 
    Result moveTo(float x, float y) noexcept;
 
    Result lineTo(float x, float y) noexcept;
 
    Result cubicTo(float cx1, float cy1, float cx2, float cy2, float x, float y) noexcept;
 
    Result close() noexcept;
 
    Result appendRect(float x, float y, float w, float h, float rx = 0, float ry = 0) noexcept;
 
    Result appendCircle(float cx, float cy, float rx, float ry) noexcept;
 
    Result appendArc(float cx, float cy, float radius, float startAngle, float sweep, bool pie) noexcept;
 
    Result appendPath(const PathCommand* cmds, uint32_t cmdCnt, const Point* pts, uint32_t ptsCnt) noexcept;
 
    Result stroke(float width) noexcept;
 
    Result stroke(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) noexcept;
 
    Result stroke(std::unique_ptr<Fill> f) noexcept;
 
    Result stroke(const float* dashPattern, uint32_t cnt) noexcept;
 
    Result stroke(StrokeCap cap) noexcept;
 
    Result stroke(StrokeJoin join) noexcept;
 
 
    Result strokeMiterlimit(float miterlimit) noexcept;
 
    Result fill(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) noexcept;
 
    Result fill(std::unique_ptr<Fill> f) noexcept;
 
    Result fill(FillRule r) noexcept;
 
 
    Result order(bool strokeFirst) noexcept;
 
 
    uint32_t pathCommands(const PathCommand** cmds) const noexcept;
 
    uint32_t pathCoords(const Point** pts) const noexcept;
 
    const Fill* fill() const noexcept;
 
    Result fillColor(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a = nullptr) const noexcept;
 
    FillRule fillRule() const noexcept;
 
    float strokeWidth() const noexcept;
 
    Result strokeColor(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a = nullptr) const noexcept;
 
    const Fill* strokeFill() const noexcept;
 
    uint32_t strokeDash(const float** dashPattern) const noexcept;
 
    StrokeCap strokeCap() const noexcept;
 
    StrokeJoin strokeJoin() const noexcept;
 
    float strokeMiterlimit() const noexcept;
 
    static std::unique_ptr<Shape> gen() noexcept;
 
    static uint32_t identifier() noexcept;
 
    _TVG_DECLARE_PRIVATE(Shape);
};
 
 
class TVG_API Picture final : public Paint
{
public:
    ~Picture();
 
    Result load(const std::string& path) noexcept;
 
    TVG_DEPRECATED Result load(const char* data, uint32_t size, bool copy = false) noexcept;
 
    Result load(const char* data, uint32_t size, const std::string& mimeType, bool copy = false) noexcept;
 
    Result size(float w, float h) noexcept;
 
    Result size(float* w, float* h) const noexcept;
 
    Result load(uint32_t* data, uint32_t w, uint32_t h, bool copy) noexcept;
 
    Result mesh(const Polygon* triangles, uint32_t triangleCnt) noexcept;
 
    uint32_t mesh(const Polygon** triangles) const noexcept;
 
    static std::unique_ptr<Picture> gen() noexcept;
 
    static uint32_t identifier() noexcept;
 
    _TVG_DECLARE_ACCESSOR(Animation);
    _TVG_DECLARE_PRIVATE(Picture);
};
 
 
class TVG_API Scene final : public Paint
{
public:
    ~Scene();
 
    Result push(std::unique_ptr<Paint> paint) noexcept;
 
    TVG_DEPRECATED Result reserve(uint32_t size) noexcept;
 
    std::list<Paint*>& paints() noexcept;
 
    Result clear(bool free = true) noexcept;
 
    static std::unique_ptr<Scene> gen() noexcept;
 
    static uint32_t identifier() noexcept;
 
    _TVG_DECLARE_PRIVATE(Scene);
};
 
 
class TVG_API Text final : public Paint
{
public:
    ~Text();
 
    Result font(const char* name, float size, const char* style = nullptr) noexcept;
 
    Result text(const char* text) noexcept;
 
    Result fill(uint8_t r, uint8_t g, uint8_t b) noexcept;
 
    Result fill(std::unique_ptr<Fill> f) noexcept;
 
    static Result load(const std::string& path) noexcept;
 
    static Result unload(const std::string& path) noexcept;
 
    static std::unique_ptr<Text> gen() noexcept;
 
    static uint32_t identifier() noexcept;
 
    _TVG_DECLARE_PRIVATE(Text);
};
 
 
class TVG_API SwCanvas final : public Canvas
{
public:
    ~SwCanvas();
 
    enum Colorspace
    {
        ABGR8888 = 0,      
        ARGB8888,          
        ABGR8888S,         
        ARGB8888S,         
    };
 
    enum MempoolPolicy
    {
        Default = 0, 
        Shareable,   
        Individual   
    };
 
    Result target(uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h, Colorspace cs) noexcept;
 
    Result mempool(MempoolPolicy policy) noexcept;
 
    static std::unique_ptr<SwCanvas> gen() noexcept;
 
    _TVG_DECLARE_PRIVATE(SwCanvas);
};
 
 
class TVG_API GlCanvas final : public Canvas
{
public:
    ~GlCanvas();
 
    Result target(uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h) noexcept;
 
    static std::unique_ptr<GlCanvas> gen() noexcept;
 
    _TVG_DECLARE_PRIVATE(GlCanvas);
};
 
 
class TVG_API WgCanvas final : public Canvas
{
public:
    ~WgCanvas();
 
    Result target(void* window, uint32_t w, uint32_t h) noexcept;
 
    static std::unique_ptr<WgCanvas> gen() noexcept;
 
    _TVG_DECLARE_PRIVATE(WgCanvas);
};
 
 
class TVG_API Initializer final
{
public:
    static Result init(CanvasEngine engine, uint32_t threads) noexcept;
 
    static Result term(CanvasEngine engine) noexcept;
 
    _TVG_DISABLE_CTOR(Initializer);
};
 
 
class TVG_API Animation
{
public:
    ~Animation();
 
    Result frame(float no) noexcept;
 
    Picture* picture() const noexcept;
 
    float curFrame() const noexcept;
 
    float totalFrame() const noexcept;
 
    float duration() const noexcept;
 
    static std::unique_ptr<Animation> gen() noexcept;
 
    _TVG_DECLARE_PRIVATE(Animation);
};
 
 
class TVG_API Saver final
{
public:
    ~Saver();
 
    Result background(std::unique_ptr<Paint> paint) noexcept;
 
    Result save(std::unique_ptr<Paint> paint, const std::string& path, bool compress = true) noexcept;
 
    Result save(std::unique_ptr<Animation> animation, const std::string& path, uint32_t quality = 100, uint32_t fps = 0) noexcept;
 
    Result sync() noexcept;
 
    static std::unique_ptr<Saver> gen() noexcept;
 
    _TVG_DECLARE_PRIVATE(Saver);
};
 
 
class TVG_API Accessor final
{
public:
    ~Accessor();
 
    std::unique_ptr<Picture> set(std::unique_ptr<Picture> picture, std::function<bool(const Paint* paint)> func) noexcept;
 
    static std::unique_ptr<Accessor> gen() noexcept;
 
    _TVG_DECLARE_PRIVATE(Accessor);
};
 
 
template<typename T = tvg::Paint>
std::unique_ptr<T> cast(Paint* paint)
{
    return std::unique_ptr<T>(static_cast<T*>(paint));
}
 
 
template<typename T = tvg::Fill>
std::unique_ptr<T> cast(Fill* fill)
{
    return std::unique_ptr<T>(static_cast<T*>(fill));
}
 
 
} //namespace
 
#endif //_THORVG_H_