src/renderer/src/thorvg_renderer.cpp

   1 #include "thorvg_renderer.hpp"
   2 #include "math/vec2d.hpp"
   3 #include "shapes/paint/color.hpp"
   4
   5 using namespace rive;
   6
   7 ThorvgRenderPath::ThorvgRenderPath() : m_Pushed(false)
   8 {
   9         this->m_Path = tvg::Shape::gen().release();
  10 }
  11
  12 void ThorvgRenderPath::fillRule(FillRule value)
  13 {
  14         switch (value)
  15         {
  16                 case FillRule::evenOdd:
  17                         m_Path->fill(tvg::FillRule::EvenOdd);
  18                         break;
  19                 case FillRule::nonZero:
  20                         break;
  21         }
  22 }
  23
  24 void ThorvgRenderPath::addRenderPath(RenderPath* path, const Mat2D& transform)
  25 {
  26    std::vector<ThorvgPathType> &m_PathType = reinterpret_cast<ThorvgRenderPath*>(path)->m_PathType;
  27    std::vector<ThorvgPoint> &m_PathPoints = reinterpret_cast<ThorvgRenderPath*>(path)->m_PathPoints;
  28
  29    int index = 0;
  30    for (int i = 0; i < m_PathType.size(); i++)
  31    {
  32       ThorvgPathType type = m_PathType[i];
  33       switch(type)
  34       {
  35          case ThorvgPathType::MoveTo:
  36             m_Path->moveTo(m_PathPoints[index].x, m_PathPoints[index].y);
  37             index += 1;
  38             break;
  39          case ThorvgPathType::LineTo:
  40             m_Path->lineTo(m_PathPoints[index].x, m_PathPoints[index].y);
  41             index += 1;
  42             break;
  43          case ThorvgPathType::CubicTo:
  44             m_Path->cubicTo(m_PathPoints[index].x, m_PathPoints[index].y,
  45                             m_PathPoints[index+1].x, m_PathPoints[index+1].y,
  46                             m_PathPoints[index+2].x, m_PathPoints[index+2].y);
  47             index += 3;
  48             break;
  49          case ThorvgPathType::Close:
  50             m_Path->close();
  51             break;
  52       }
  53    }
  54 }
  55
  56 void ThorvgRenderPath::reset()
  57 {
  58    m_PathType.clear();
  59    m_PathPoints.clear();
  60 }
  61
  62 void ThorvgRenderPath::moveTo(float x, float y)
  63 {
  64    m_PathType.push_back(ThorvgPathType::MoveTo);
  65    m_PathPoints.push_back(ThorvgPoint(x, y));
  66 }
  67
  68 void ThorvgRenderPath::lineTo(float x, float y)
  69 {
  70    m_PathType.push_back(ThorvgPathType::LineTo);
  71    m_PathPoints.push_back(ThorvgPoint(x, y));
  72 }
  73
  74 void ThorvgRenderPath::cubicTo(float ox, float oy, float ix, float iy, float x, float y)
  75 {
  76    m_PathType.push_back(ThorvgPathType::CubicTo);
  77    m_PathPoints.push_back(ThorvgPoint(ox, oy));
  78    m_PathPoints.push_back(ThorvgPoint(ix, iy));
  79    m_PathPoints.push_back(ThorvgPoint(x, y));
  80 }
  81
  82 void ThorvgRenderPath::close()
  83 {
  84    m_PathType.push_back(ThorvgPathType::Close);
  85 }
  86
  87 void ThorvgRenderer::save()
  88 {
  89 }
  90
  91 void ThorvgRenderer::restore()
  92 {
  93 }
  94
  95 void ThorvgRenderer::transform(const Mat2D& transform)
  96 {
  97    m_Transform = transform;
  98 }
  99
 100 void ThorvgRenderer::drawPath(RenderPath* path, RenderPaint* paint)
 101 {
 102         tvg::Matrix m = {m_Transform[0], 0, m_Transform[4],
 103                     0, m_Transform[3], m_Transform[5],
 104                     0, 0, 1};
 105
 106    ThorvgRenderPath *renderPath = reinterpret_cast<ThorvgRenderPath*>(path);
 107    tvg::Shape *drawPath = reinterpret_cast<ThorvgRenderPath*>(path)->path();
 108    drawPath->transform(m);
 109
 110    ThorvgPaint *drawPaint = reinterpret_cast<ThorvgRenderPaint*>(paint)->paint();
 111    if (drawPaint->isFill)
 112      drawPath->fill(drawPaint->fillColor[0], drawPaint->fillColor[1], drawPaint->fillColor[2], drawPaint->fillColor[3]);
 113    if (drawPaint->isStroke)
 114    {
 115      drawPath->stroke(drawPaint->strokeColor[0], drawPaint->strokeColor[1], drawPaint->strokeColor[2], drawPaint->strokeColor[3]);
 116      if (drawPaint->thickness != 0)
 117        drawPath->stroke(drawPaint->thickness);
 118    }
 119
 120    if (!renderPath->getPushed())
 121    {
 122       tvg::Result ret = m_Canvas->push(std::unique_ptr<tvg::Shape>(drawPath));
 123       renderPath->setPushed(true);
 124    }
 125    else
 126    {
 127       tvg::Result ret = m_Canvas->update(drawPath);
 128    }
 129 }
 130
 131 void ThorvgRenderer::clipPath(RenderPath* path)
 132 {
 133
 134 }
 135
 136 ThorvgRenderPaint::ThorvgRenderPaint()
 137 {
 138
 139 }
 140
 141 void ThorvgRenderPaint::style(RenderPaintStyle style)
 142 {
 143         switch (style)
 144         {
 145                 case RenderPaintStyle::fill:
 146          m_Paint.style = RenderPaintStyle::fill;
 147          m_Paint.isFill = true;
 148                         break;
 149                 case RenderPaintStyle::stroke:
 150          m_Paint.style = RenderPaintStyle::stroke;
 151          m_Paint.isStroke = true;
 152                         break;
 153         }
 154 }
 155 void ThorvgRenderPaint::color(unsigned int value)
 156 {
 157    int b = value >> 0 & 255;
 158    int g = value >> 8 & 255;
 159    int r = value >> 16 & 255;
 160    int a = value >> 24 & 255;
 161
 162    if (m_Paint.style == RenderPaintStyle::fill)
 163    {
 164       m_Paint.fillColor[0] = r;
 165       m_Paint.fillColor[1] = g;
 166       m_Paint.fillColor[2] = b;
 167       m_Paint.fillColor[3] = a;
 168    }
 169    else if (m_Paint.style == RenderPaintStyle::stroke)
 170    {
 171       m_Paint.strokeColor[0] = r;
 172       m_Paint.strokeColor[1] = g;
 173       m_Paint.strokeColor[2] = b;
 174       m_Paint.strokeColor[3] = a;
 175    }
 176 }
 177
 178 void ThorvgRenderPaint::thickness(float value)
 179 {
 180    m_Paint.thickness = value;
 181 }
 182
 183 void ThorvgRenderPaint::join(StrokeJoin value)
 184 {
 185
 186 }
 187
 188 void ThorvgRenderPaint::cap(StrokeCap value)
 189 {
 190
 191 }
 192
 193 void ThorvgRenderPaint::linearGradient(float sx, float sy, float ex, float ey)
 194 {
 195
 196 }
 197
 198 void ThorvgRenderPaint::radialGradient(float sx, float sy, float ex, float ey)
 199 {
 200 }
 201
 202 void ThorvgRenderPaint::addStop(unsigned int color, float stop)
 203 {
 204 }
 205
 206 void ThorvgRenderPaint::completeGradient()
 207 {
 208
 209 }
 210
 211 void ThorvgRenderPaint::blendMode(BlendMode value)
 212 {
 213
 214 }
 215
 216 namespace rive
 217 {
 218    RenderPath* makeRenderPath() { return new ThorvgRenderPath();}
 219    RenderPaint* makeRenderPaint() { return new ThorvgRenderPaint();}
 220 }