inc/thorvg.h

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *               http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  */
  17 #ifndef _THORVG_H_
  18 #define _THORVG_H_
  19
  20 #include <memory>
  21
  22 #ifdef TVG_BUILD
  23     #define TVG_EXPORT __attribute__ ((visibility ("default")))
  24 #else
  25     #define TVG_EXPORT
  26 #endif
  27
  28 #ifdef  LOG_TAG
  29 #undef  LOG_TAG
  30 #endif
  31 #define LOG_TAG "TVG"
  32
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif
  37
  38
  39 #define _TVG_DECLARE_PRIVATE(A) \
  40 protected: \
  41     struct Impl; \
  42     std::unique_ptr<Impl> pImpl; \
  43     A(const A&) = delete; \
  44     const A& operator=(const A&) = delete; \
  45     A()
  46
  47 #define _TVG_DISABLE_CTOR(A) \
  48     A() = delete; \
  49     ~A() = delete
  50
  51 #define _TVG_DECLARE_ACCESSOR(A) \
  52     friend A
  53
  54 #define _TVG_DECALRE_IDENTIFIER() \
  55     auto id() const { return _id; } \
  56 protected: \
  57     unsigned _id
  58
  59 namespace tvg
  60 {
  61
  62 class RenderMethod;
  63 class Scene;
  64 class Canvas;
  65
  66
  67 enum class TVG_EXPORT Result { Success = 0, InvalidArguments, InsufficientCondition, FailedAllocation, MemoryCorruption, NonSupport, Unknown };
  68 enum class TVG_EXPORT PathCommand { Close = 0, MoveTo, LineTo, CubicTo };
  69 enum class TVG_EXPORT StrokeCap { Square = 0, Round, Butt };
  70 enum class TVG_EXPORT StrokeJoin { Bevel = 0, Round, Miter };
  71 enum class TVG_EXPORT FillSpread { Pad = 0, Reflect, Repeat };
  72 enum class TVG_EXPORT CanvasEngine { Sw = 0, Gl };
  73
  74
  75 struct Point
  76 {
  77     float x, y;
  78 };
  79
  80
  81 struct Matrix
  82 {
  83     float e11, e12, e13;
  84     float e21, e22, e23;
  85     float e31, e32, e33;
  86 };
  87
  88
  89 /**
  90  * @class Paint
  91  *
  92  * @ingroup ThorVG
  93  *
  94  * @brief description...
  95  *
  96  */
  97 class TVG_EXPORT Paint
  98 {
  99 public:
 100     virtual ~Paint();
 101
 102     Result rotate(float degree) noexcept;
 103     Result scale(float factor) noexcept;
 104     Result translate(float x, float y) noexcept;
 105     Result transform(const Matrix& m) noexcept;
 106     Result bounds(float* x, float* y, float* w, float* h) const noexcept;
 107
 108     _TVG_DECLARE_PRIVATE(Paint);
 109     _TVG_DECLARE_ACCESSOR(Canvas);
 110     _TVG_DECLARE_ACCESSOR(Scene);
 111 };
 112
 113
 114 /**
 115  * @class Fill
 116  *
 117  * @ingroup ThorVG
 118  *
 119  * @brief description...
 120  *
 121  */
 122 class TVG_EXPORT Fill
 123 {
 124 public:
 125     struct ColorStop
 126     {
 127         float offset;
 128         uint8_t r, g, b, a;
 129     };
 130
 131     virtual ~Fill();
 132
 133     Result colorStops(const ColorStop* colorStops, uint32_t cnt) noexcept;
 134     Result spread(FillSpread s) noexcept;
 135
 136     uint32_t colorStops(const ColorStop** colorStops) const noexcept;
 137     FillSpread spread() const noexcept;
 138
 139     _TVG_DECALRE_IDENTIFIER();
 140     _TVG_DECLARE_PRIVATE(Fill);
 141 };
 142
 143
 144 /**
 145  * @class Canvas
 146  *
 147  * @ingroup ThorVG
 148  *
 149  * @brief description...
 150  *
 151  */
 152 class TVG_EXPORT Canvas
 153 {
 154 public:
 155     Canvas(RenderMethod*);
 156     virtual ~Canvas();
 157
 158     Result reserve(uint32_t n) noexcept;
 159     virtual Result push(std::unique_ptr<Paint> paint) noexcept;
 160     virtual Result clear() noexcept;
 161     virtual Result update(Paint* paint) noexcept;
 162     virtual Result draw() noexcept;
 163     virtual Result sync() noexcept;
 164
 165     _TVG_DECLARE_PRIVATE(Canvas);
 166 };
 167
 168
 169
 170 /**
 171  * @class LinearGradient
 172  *
 173  * @ingroup ThorVG
 174  *
 175  * @brief description...
 176  *
 177  */
 178 class TVG_EXPORT LinearGradient final : public Fill
 179 {
 180 public:
 181     ~LinearGradient();
 182
 183     Result linear(float x1, float y1, float x2, float y2) noexcept;
 184     Result linear(float* x1, float* y1, float* x2, float* y2) const noexcept;
 185
 186     static std::unique_ptr<LinearGradient> gen() noexcept;
 187
 188     _TVG_DECLARE_PRIVATE(LinearGradient);
 189 };
 190
 191
 192 /**
 193  * @class RadialGradient
 194  *
 195  * @ingroup ThorVG
 196  *
 197  * @brief description...
 198  *
 199  */
 200 class TVG_EXPORT RadialGradient final : public Fill
 201 {
 202 public:
 203     ~RadialGradient();
 204
 205     Result radial(float cx, float cy, float radius) noexcept;
 206     Result radial(float* cx, float* cy, float* radius) const noexcept;
 207
 208     static std::unique_ptr<RadialGradient> gen() noexcept;
 209
 210     _TVG_DECLARE_PRIVATE(RadialGradient);
 211 };
 212
 213
 214
 215 /**
 216  * @class Shape
 217  *
 218  * @ingroup ThorVG
 219  *
 220  * @brief description...
 221  *
 222  */
 223 class TVG_EXPORT Shape final : public Paint
 224 {
 225 public:
 226     ~Shape();
 227
 228     Result reset() noexcept;
 229
 230     //Path
 231     Result moveTo(float x, float y) noexcept;
 232     Result lineTo(float x, float y) noexcept;
 233     Result cubicTo(float cx1, float cy1, float cx2, float cy2, float x, float y) noexcept;
 234     Result close() noexcept;
 235
 236     //Shape
 237     Result appendRect(float x, float y, float w, float h, float rx, float ry) noexcept;
 238     Result appendCircle(float cx, float cy, float rx, float ry) noexcept;
 239     Result appendPath(const PathCommand* cmds, uint32_t cmdCnt, const Point* pts, uint32_t ptsCnt) noexcept;
 240
 241     //Stroke
 242     Result stroke(float width) noexcept;
 243     Result stroke(uint8_t r, uint8_t g, uint8_t b, uint8_t a) noexcept;
 244     Result stroke(const float* dashPattern, uint32_t cnt) noexcept;
 245     Result stroke(StrokeCap cap) noexcept;
 246     Result stroke(StrokeJoin join) noexcept;
 247
 248     //Fill
 249     Result fill(uint8_t r, uint8_t g, uint8_t b, uint8_t a) noexcept;
 250     Result fill(std::unique_ptr<Fill> f) noexcept;
 251
 252     //Getters
 253     uint32_t pathCommands(const PathCommand** cmds) const noexcept;
 254     uint32_t pathCoords(const Point** pts) const noexcept;
 255     Result fill(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) const noexcept;
 256     const Fill* fill() const noexcept;
 257
 258     float strokeWidth() const noexcept;
 259     Result strokeColor(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) const noexcept;
 260     uint32_t strokeDash(const float** dashPattern) const noexcept;
 261     StrokeCap strokeCap() const noexcept;
 262     StrokeJoin strokeJoin() const noexcept;
 263
 264     static std::unique_ptr<Shape> gen() noexcept;
 265
 266     _TVG_DECLARE_PRIVATE(Shape);
 267 };
 268
 269
 270 /**
 271  * @class Scene
 272  *
 273  * @ingroup ThorVG
 274  *
 275  * @brief description...
 276  *
 277  */
 278 class TVG_EXPORT Scene final : public Paint
 279 {
 280 public:
 281     ~Scene();
 282
 283     Result push(std::unique_ptr<Paint> paint) noexcept;
 284     Result reserve(uint32_t size) noexcept;
 285     Result load(const std::string& path) noexcept;
 286
 287     static std::unique_ptr<Scene> gen() noexcept;
 288
 289     _TVG_DECLARE_PRIVATE(Scene);
 290 };
 291
 292
 293 /**
 294  * @class SwCanvas
 295  *
 296  * @ingroup ThorVG
 297  *
 298   @brief description...
 299  *
 300  */
 301 class TVG_EXPORT SwCanvas final : public Canvas
 302 {
 303 public:
 304     ~SwCanvas();
 305
 306     Result target(uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h) noexcept;
 307
 308     static std::unique_ptr<SwCanvas> gen() noexcept;
 309
 310     _TVG_DECLARE_PRIVATE(SwCanvas);
 311 };
 312
 313
 314 /**
 315  * @class GlCanvas
 316  *
 317  * @ingroup ThorVG
 318  *
 319  * @brief description...
 320  *
 321  */
 322 class TVG_EXPORT GlCanvas final : public Canvas
 323 {
 324 public:
 325     ~GlCanvas();
 326
 327     //TODO: Gl Specific methods. Need gl backend configuration methods as well.
 328     Result target(uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h) noexcept;
 329
 330     static std::unique_ptr<GlCanvas> gen() noexcept;
 331
 332     _TVG_DECLARE_PRIVATE(GlCanvas);
 333 };
 334
 335
 336 /**
 337  * @class Engine
 338  *
 339  * @ingroup ThorVG
 340  *
 341  * @brief description...
 342  *
 343  */
 344 class TVG_EXPORT Initializer final
 345 {
 346 public:
 347
 348     /**
 349      * @brief ...
 350      *
 351      * @param[in] arg ...
 352      *
 353      * @note ...
 354      *
 355      * @return ...
 356      *
 357      * @see ...
 358      */
 359     static Result init(CanvasEngine engine) noexcept;
 360     static Result term(CanvasEngine engine) noexcept;
 361
 362     _TVG_DISABLE_CTOR(Initializer);
 363 };
 364
 365 } //namespace
 366
 367 #ifdef __cplusplus
 368 }
 369 #endif
 370
 371 #endif //_THORVG_H_