src/lib/tvgShapeNode.cpp

   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 _TVG_SHAPE_NODE_CPP_
  18 #define _TVG_SHAPE_NODE_CPP_
  19
  20 #include "tvgCommon.h"
  21 #include "tvgShapePath.h"
  22
  23 /************************************************************************/
  24 /* Internal Class Implementation                                        */
  25 /************************************************************************/
  26
  27 struct ShapeFill
  28 {
  29 };
  30
  31
  32 struct ShapeStroke
  33 {
  34 };
  35
  36
  37 struct ShapeTransform
  38 {
  39     float e[4*4];
  40 };
  41
  42
  43 struct ShapeNode::Impl
  44 {
  45     ShapeTransform *transform = nullptr;
  46     ShapeFill *fill = nullptr;
  47     ShapeStroke *stroke = nullptr;
  48     ShapePath *path = nullptr;
  49     uint8_t color[4] = {0, 0, 0, 0};    //r, g, b, a
  50     void *edata = nullptr;              //engine data
  51
  52     Impl() : path(new ShapePath)
  53     {
  54     }
  55
  56     ~Impl()
  57     {
  58         if (path) delete(path);
  59         if (stroke) delete(stroke);
  60         if (fill) delete(fill);
  61         if (transform) delete(transform);
  62     }
  63 };
  64
  65
  66 /************************************************************************/
  67 /* External Class Implementation                                        */
  68 /************************************************************************/
  69
  70 ShapeNode :: ShapeNode() : pImpl(make_unique<Impl>())
  71 {
  72 }
  73
  74
  75 ShapeNode :: ~ShapeNode()
  76 {
  77     cout << "ShapeNode(" << this << ") destroyed!" << endl;
  78 }
  79
  80
  81 unique_ptr<ShapeNode> ShapeNode::gen() noexcept
  82 {
  83     return unique_ptr<ShapeNode>(new ShapeNode);
  84 }
  85
  86
  87 int ShapeNode :: update(RasterMethod* engine) noexcept
  88 {
  89     auto impl = pImpl.get();
  90     assert(impl);
  91
  92     impl->edata = engine->prepare(*this, impl->edata, RasterMethod::UpdateFlag::All);
  93     if (impl->edata) return 0;
  94     return - 1;
  95 }
  96
  97
  98 int ShapeNode :: clear() noexcept
  99 {
 100     auto impl = pImpl.get();
 101     assert(impl);
 102
 103     return impl->path->clear();
 104 }
 105
 106
 107 int ShapeNode :: pathCommands(const PathCommand** cmds) const noexcept
 108 {
 109     auto impl = pImpl.get();
 110     assert(impl && cmds);
 111
 112     *cmds = impl->path->cmds;
 113
 114     return impl->path->cmdCnt;
 115 }
 116
 117
 118 int ShapeNode :: pathCoords(const Point** pts) const noexcept
 119 {
 120     auto impl = pImpl.get();
 121     assert(impl && pts);
 122
 123     *pts = impl->path->pts;
 124
 125     return impl->path->ptsCnt;
 126 }
 127
 128
 129 int ShapeNode :: appendCircle(float cx, float cy, float radius) noexcept
 130 {
 131     return 0;
 132 }
 133
 134
 135 int ShapeNode :: appendRect(float x, float y, float w, float h, float radius) noexcept
 136 {
 137     auto impl = pImpl.get();
 138     assert(impl);
 139
 140     //clamping radius by minimum size
 141     auto min = (w < h ? w : h) * 0.5f;
 142     if (radius > min) radius = min;
 143
 144     //rectangle
 145     if (radius == 0) {
 146         impl->path->reserve(5, 4);
 147         impl->path->moveTo(x, y);
 148         impl->path->lineTo(x + w, y);
 149         impl->path->lineTo(x + w, y + h);
 150         impl->path->lineTo(x, y + h);
 151         impl->path->close();
 152     //circle
 153     } else if (w == h && radius * 2 == w) {
 154         appendCircle(x + (w * 0.5f), y + (h * 0.5f), radius);
 155     } else {
 156         //...
 157     }
 158
 159     return 0;
 160 }
 161
 162
 163 int ShapeNode :: fill(size_t r, size_t g, size_t b, size_t a) noexcept
 164 {
 165     auto impl = pImpl.get();
 166     assert(impl);
 167
 168     impl->color[0] = r;
 169     impl->color[1] = g;
 170     impl->color[2] = b;
 171     impl->color[3] = a;
 172
 173     return 0;
 174 }
 175
 176
 177 int ShapeNode :: fill(size_t* r, size_t* g, size_t* b, size_t* a) const noexcept
 178 {
 179     auto impl = pImpl.get();
 180     assert(impl);
 181
 182     if (r) *r = impl->color[0];
 183     if (g) *g = impl->color[1];
 184     if (b) *b = impl->color[2];
 185     if (a) *a = impl->color[3];
 186
 187     return 0;
 188 }
 189
 190 #endif //_TVG_SHAPE_NODE_CPP_