vcl/opengl/RenderList.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  */
  10
  11 #include <opengl/RenderList.hxx>
  12 #include <opengl/VertexUtils.hxx>
  13 #include <opengl/LineRenderUtils.hxx>
  14
  15 #include <basegfx/polygon/b2dpolygontools.hxx>
  16 #include <basegfx/polygon/b2dpolygontriangulator.hxx>
  17 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  18 #include <basegfx/polygon/b2dtrapezoid.hxx>
  19
  20 namespace
  21 {
  22
  23 /** Append vertices for the polyline
  24  *
  25  * OpenGL polyline drawing algorithm inspired by:
  26  * - http://mattdesl.svbtle.com/drawing-lines-is-hard
  27  * - https://www.mapbox.com/blog/drawing-antialiased-lines/
  28  * - https://cesiumjs.org/2013/04/22/Robust-Polyline-Rendering-with-WebGL/
  29  * - http://artgrammer.blogspot.si/2011/05/drawing-nearly-perfect-2d-line-segments.html
  30  * - http://artgrammer.blogspot.si/2011/07/drawing-polylines-by-tessellation.html
  31  *
  32  */
  33 void appendPolyLine(vcl::LineBuilder& rBuilder, const basegfx::B2DPolygon& rPolygon,
  34                     basegfx::B2DLineJoin eLineJoin, css::drawing::LineCap eLineCap,
  35                     double fMiterMinimumAngle)
  36 {
  37     sal_uInt32 nPoints = rPolygon.count();
  38     bool bClosed = rPolygon.isClosed();
  39
  40     if (nPoints == 2 || eLineJoin == basegfx::B2DLineJoin::NONE)
  41     {
  42         // If line joint is NONE or a simple line with 2 points, draw the polyline
  43         // each line segment separately.
  44
  45         for (sal_uInt32 i = 0; i < (bClosed ? nPoints : nPoints - 1); ++i)
  46         {
  47             sal_uInt32 index1 = (i + 0) % nPoints; // loop indices - important when polyline is closed
  48             sal_uInt32 index2 = (i + 1) % nPoints;
  49
  50             glm::vec2 aPoint1(rPolygon.getB2DPoint(index1).getX(), rPolygon.getB2DPoint(index1).getY());
  51             glm::vec2 aPoint2(rPolygon.getB2DPoint(index2).getX(), rPolygon.getB2DPoint(index2).getY());
  52
  53             rBuilder.appendLine(aPoint1, aPoint2);
  54         }
  55     }
  56     else if (nPoints > 2)
  57     {
  58         int i = 0;
  59         int lastPoint = int(nPoints);
  60
  61         glm::vec2 p0(rPolygon.getB2DPoint(nPoints - 1).getX(), rPolygon.getB2DPoint(nPoints - 1).getY());
  62         glm::vec2 p1(rPolygon.getB2DPoint(0).getX(), rPolygon.getB2DPoint(0).getY());
  63         glm::vec2 p2(rPolygon.getB2DPoint(1).getX(), rPolygon.getB2DPoint(1).getY());
  64
  65         glm::vec2 nextLineVector;
  66         glm::vec2 previousLineVector;
  67         glm::vec2 normal; // perpendicular to the line vector
  68
  69         nextLineVector = vcl::vertex::normalize(p2 - p1);
  70
  71         if (!bClosed)
  72         {
  73             normal = glm::vec2(-nextLineVector.y, nextLineVector.x); // make perpendicular
  74             rBuilder.appendAndConnectLinePoint(p1, normal, 1.0f);
  75
  76             i++; // first point done already
  77             lastPoint--; // last point will be calculated separately from the loop
  78
  79             p0 = p1;
  80             previousLineVector = nextLineVector;
  81         }
  82         else
  83         {
  84             lastPoint++; // we need to connect last point to first point so one more line segment to calculate
  85             previousLineVector = vcl::vertex::normalize(p1 - p0);
  86         }
  87
  88         for (; i < lastPoint; ++i)
  89         {
  90             int index1 = (i + 0) % nPoints; // loop indices - important when polyline is closed
  91             int index2 = (i + 1) % nPoints;
  92
  93             p1 = glm::vec2(rPolygon.getB2DPoint(index1).getX(), rPolygon.getB2DPoint(index1).getY());
  94             p2 = glm::vec2(rPolygon.getB2DPoint(index2).getX(), rPolygon.getB2DPoint(index2).getY());
  95
  96             if (p1 == p2) // skip equal points, normals could div-by-0
  97                 continue;
  98
  99             nextLineVector = vcl::vertex::normalize(p2 - p1);
 100
 101             if (eLineJoin == basegfx::B2DLineJoin::Miter)
 102             {
 103                 if (vcl::vertex::lineVectorAngle(previousLineVector, nextLineVector) < fMiterMinimumAngle)
 104                     rBuilder.appendBevelJoint(p1, previousLineVector, nextLineVector);
 105                 else
 106                     rBuilder.appendMiterJoint(p1, previousLineVector, nextLineVector);
 107             }
 108             else if (eLineJoin == basegfx::B2DLineJoin::Bevel)
 109             {
 110                 rBuilder.appendBevelJoint(p1, previousLineVector, nextLineVector);
 111             }
 112             else if (eLineJoin == basegfx::B2DLineJoin::Round)
 113             {
 114                 rBuilder.appendRoundJoint(p1, previousLineVector, nextLineVector);
 115             }
 116             p0 = p1;
 117             previousLineVector = nextLineVector;
 118         }
 119
 120         if (!bClosed)
 121         {
 122             // Create vertices for the last point. There is no line join so just
 123             // use the last line segment normal as the extrusion vector.
 124             p1 = glm::vec2(rPolygon.getB2DPoint(nPoints - 1).getX(), rPolygon.getB2DPoint(nPoints - 1).getY());
 125             normal = glm::vec2(-previousLineVector.y, previousLineVector.x);
 126             rBuilder.appendAndConnectLinePoint(p1, normal, 1.0f);
 127         }
 128     }
 129
 130     if (bClosed || nPoints < 2 || (eLineCap != css::drawing::LineCap_ROUND && eLineCap != css::drawing::LineCap_SQUARE))
 131         return;
 132
 133     glm::vec2 aBeginCapPoint1(rPolygon.getB2DPoint(0).getX(), rPolygon.getB2DPoint(0).getY());
 134     glm::vec2 aBeginCapPoint2(rPolygon.getB2DPoint(1).getX(), rPolygon.getB2DPoint(1).getY());
 135
 136     glm::vec2 aEndCapPoint1(rPolygon.getB2DPoint(nPoints - 1).getX(), rPolygon.getB2DPoint(nPoints - 1).getY());
 137     glm::vec2 aEndCapPoint2(rPolygon.getB2DPoint(nPoints - 2).getX(), rPolygon.getB2DPoint(nPoints - 2).getY());
 138
 139     if (eLineCap == css::drawing::LineCap_ROUND)
 140     {
 141         rBuilder.appendRoundLineCapVertices(aBeginCapPoint1, aBeginCapPoint2);
 142         rBuilder.appendRoundLineCapVertices(aEndCapPoint1, aEndCapPoint2);
 143     }
 144     else if (eLineCap == css::drawing::LineCap_SQUARE)
 145     {
 146         rBuilder.appendSquareLineCapVertices(aBeginCapPoint1, aBeginCapPoint2);
 147         rBuilder.appendSquareLineCapVertices(aEndCapPoint1, aEndCapPoint2);
 148     }
 149 }
 150
 151 void appendTrapezoid(std::vector<Vertex>& rVertices, std::vector<GLuint>& rIndices,
 152                        GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
 153                        GLfloat x3, GLfloat y3, GLfloat x4, GLfloat y4,
 154                        Color nColor, GLfloat fTransparency)
 155 {
 156     GLubyte nR, nG, nB, nA;
 157     vcl::vertex::createColor(nColor, fTransparency, nR, nG, nB, nA);
 158
 159     GLuint zero = rVertices.size();
 160
 161     rVertices.insert(rVertices.end(), {
 162         {glm::vec2{x1, y1}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 163         {glm::vec2{x2, y2}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 164         {glm::vec2{x3, y3}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 165         {glm::vec2{x4, y4}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 166     });
 167
 168     rIndices.insert(rIndices.end(), {
 169         zero + 0, zero + 1, zero + 2,
 170         zero + 2, zero + 1, zero + 3
 171     });
 172 }
 173
 174 void appendRectangle(std::vector<Vertex>& rVertices, std::vector<GLuint>& rIndices,
 175                      GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
 176                      Color nColor, GLfloat fTransparency)
 177 {
 178     GLubyte nR, nG, nB, nA;
 179     vcl::vertex::createColor(nColor, fTransparency, nR, nG, nB, nA);
 180
 181     GLuint zero = rVertices.size();
 182
 183     rVertices.insert(rVertices.end(), {
 184         {glm::vec2{x1, y1}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 185         {glm::vec2{x2, y1}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 186         {glm::vec2{x1, y2}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 187         {glm::vec2{x2, y2}, glm::vec4{nR, nG, nB, nA}, glm::vec4{0.0f, 0.0f, 0.0f, 0.0f}},
 188     });
 189
 190     rIndices.insert(rIndices.end(), {
 191         zero + 0, zero + 1, zero + 2,
 192         zero + 2, zero + 1, zero + 3
 193     });
 194 }
 195
 196 } // end anonymous namespace
 197
 198 void RenderList::addDrawPixel(tools::Long nX, tools::Long nY, Color nColor)
 199 {
 200     if (nColor == SALCOLOR_NONE)
 201         return;
 202
 203     checkOverlapping(basegfx::B2DRange(nX, nY, nX, nY));
 204
 205     RenderParameters& rRenderParameter = maRenderEntries.back().maTriangleParameters;
 206     appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 207                     nX - 0.5f, nY - 0.5f, nX + 0.5f, nY + 0.5f, nColor, 0.0f);
 208 }
 209
 210 void RenderList::addDrawRectangle(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, double fTransparency,
 211                                   Color nLineColor, Color nFillColor)
 212 {
 213     if (nLineColor == SALCOLOR_NONE && nFillColor == SALCOLOR_NONE)
 214         return;
 215     if (fTransparency == 1.0f)
 216         return;
 217
 218     GLfloat fX1(nX);
 219     GLfloat fY1(nY);
 220     GLfloat fX2(nX + nWidth  - 1);
 221     GLfloat fY2(nY + nHeight - 1);
 222
 223     checkOverlapping(basegfx::B2DRange(fX1, fY1, fX2, fY2));
 224
 225     RenderParameters& rRenderParameter = maRenderEntries.back().maTriangleParameters;
 226
 227     // Draw rectangle stroke with line color
 228     if (nLineColor != SALCOLOR_NONE)
 229     {
 230         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 231                     fX1 - 0.5f, fY1 - 0.5f, fX1 + 0.5f, fY2 + 0.5f, nLineColor, fTransparency);
 232         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 233                     fX1 - 0.5f, fY1 - 0.5f, fX2 + 0.5f, fY1 + 0.5f, nLineColor, fTransparency);
 234         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 235                     fX2 - 0.5f, fY1 - 0.5f, fX2 + 0.5f, fY2 + 0.5f, nLineColor, fTransparency);
 236         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 237                     fX1 - 0.5f, fY2 - 0.5f, fX2 + 0.5f, fY2 + 0.5f, nLineColor, fTransparency);
 238     }
 239
 240     if (nFillColor == SALCOLOR_NONE)
 241         return;
 242
 243     // coverity[copy_paste_error : FALSE] - this is correct nLineColor not nFillColor
 244     if (nLineColor == SALCOLOR_NONE)
 245     {
 246         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 247                     fX1 - 0.5f, fY1 - 0.5f, fX1 + 0.5f, fY2 + 0.5f, nFillColor, fTransparency);
 248         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 249                     fX1 - 0.5f, fY1 - 0.5f, fX2 + 0.5f, fY1 + 0.5f, nFillColor, fTransparency);
 250         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 251                     fX2 - 0.5f, fY1 - 0.5f, fX2 + 0.5f, fY2 + 0.5f, nFillColor, fTransparency);
 252         appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 253                     fX1 - 0.5f, fY2 - 0.5f, fX2 + 0.5f, fY2 + 0.5f, nFillColor, fTransparency);
 254     }
 255     // Draw rectangle fill with fill color
 256     appendRectangle(rRenderParameter.maVertices, rRenderParameter.maIndices,
 257                     fX1 + 0.5f, fY1 + 0.5f, fX2 - 0.5f, fY2 - 0.5f, nFillColor, fTransparency);
 258 }
 259
 260 void RenderList::addDrawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2, Color nLineColor, bool bUseAA)
 261 {
 262     if (nLineColor == SALCOLOR_NONE)
 263         return;
 264
 265     checkOverlapping(basegfx::B2DRange(nX1, nY1, nX2, nY2));
 266
 267     RenderParameters& rRenderParameter = maRenderEntries.back().maLineParameters;
 268
 269     glm::vec2 aPoint1(nX1, nY1);
 270     glm::vec2 aPoint2(nX2, nY2);
 271
 272     vcl::LineBuilder aBuilder(rRenderParameter.maVertices, rRenderParameter.maIndices, nLineColor, 0.0f, 1.0f, bUseAA);
 273     aBuilder.appendLine(aPoint1, aPoint2);
 274 }
 275
 276 void RenderList::addDrawPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency,
 277                         Color nLineColor, Color nFillColor, bool bUseAA)
 278 {
 279     if (rPolyPolygon.count() <= 0)
 280         return;
 281     if (nLineColor == SALCOLOR_NONE && nFillColor == SALCOLOR_NONE)
 282         return;
 283     if (fTransparency == 1.0)
 284         return;
 285
 286     checkOverlapping(rPolyPolygon.getB2DRange());
 287
 288     if (nFillColor != SALCOLOR_NONE)
 289     {
 290         basegfx::B2DTrapezoidVector aTrapezoidVector;
 291         basegfx::utils::trapezoidSubdivide(aTrapezoidVector, rPolyPolygon);
 292
 293         if (!aTrapezoidVector.empty())
 294         {
 295             RenderParameters& rTriangleRenderParameter = maRenderEntries.back().maTriangleParameters;
 296
 297             for (const basegfx::B2DTrapezoid & rTrapezoid : aTrapezoidVector)
 298             {
 299                 GLfloat topX1 = rTrapezoid.getTopXLeft();
 300                 GLfloat topX2 = rTrapezoid.getTopXRight();
 301                 GLfloat topY  = rTrapezoid.getTopY();
 302
 303                 GLfloat bottomX1 = rTrapezoid.getBottomXLeft();
 304                 GLfloat bottomX2 = rTrapezoid.getBottomXRight();
 305                 GLfloat bottomY  = rTrapezoid.getBottomY();
 306
 307                 appendTrapezoid(rTriangleRenderParameter.maVertices, rTriangleRenderParameter.maIndices,
 308                                 topX1,    topY, topX2,    topY,
 309                                 bottomX1, bottomY, bottomX2, bottomY,
 310                                 nFillColor, fTransparency);
 311             }
 312         }
 313     }
 314
 315     if (nLineColor == SALCOLOR_NONE && !bUseAA)
 316         return;
 317
 318     RenderParameters& rLineRenderParameter = maRenderEntries.back().maLineParameters;
 319     Color nColor = (nLineColor == SALCOLOR_NONE) ? nFillColor : nLineColor;
 320
 321     vcl::LineBuilder aBuilder(rLineRenderParameter.maVertices, rLineRenderParameter.maIndices,
 322                               nColor, fTransparency, 1.0f, bUseAA);
 323
 324     for (const basegfx::B2DPolygon& rPolygon : rPolyPolygon)
 325     {
 326         basegfx::B2DPolygon aPolygon(rPolygon);
 327         if (rPolygon.areControlPointsUsed())
 328             aPolygon = rPolygon.getDefaultAdaptiveSubdivision();
 329
 330         sal_uInt32 nPoints = aPolygon.count();
 331         if (nPoints <= 1)
 332             continue;
 333
 334         GLfloat x1, y1, x2, y2;
 335         sal_uInt32 index1, index2;
 336
 337         for (sal_uInt32 i = 0; i <= nPoints; ++i)
 338         {
 339             index1 =  i      % nPoints;
 340             index2 = (i + 1) % nPoints;
 341
 342             x1 = aPolygon.getB2DPoint(index1).getX();
 343             y1 = aPolygon.getB2DPoint(index1).getY();
 344             x2 = aPolygon.getB2DPoint(index2).getX();
 345             y2 = aPolygon.getB2DPoint(index2).getY();
 346
 347             aBuilder.appendLine(glm::vec2(x1, y1), glm::vec2(x2, y2));
 348         }
 349     }
 350 }
 351
 352 void RenderList::addDrawTextureWithMaskColor(OpenGLTexture const & rTexture, Color nColor, const SalTwoRect& r2Rect)
 353 {
 354     if (!rTexture)
 355         return;
 356
 357     GLfloat fX1 = r2Rect.mnDestX;
 358     GLfloat fY1 = r2Rect.mnDestY;
 359     GLfloat fX2 = fX1 + r2Rect.mnDestWidth;
 360     GLfloat fY2 = fY1 + r2Rect.mnDestHeight;
 361
 362     checkOverlapping(basegfx::B2DRange(fX1, fY1, fX2, fY2));
 363
 364     GLuint nTextureId = rTexture.Id();
 365
 366     RenderTextureParameters& rTextureParameter = maRenderEntries.back().maTextureParametersMap[nTextureId];
 367     rTextureParameter.maTexture = rTexture;
 368
 369     rTexture.FillCoords<GL_TRIANGLES>(rTextureParameter.maTextureCoords, r2Rect);
 370
 371     vcl::vertex::addRectangle<GL_TRIANGLES>(rTextureParameter.maVertices, fX1, fY1, fX2, fY2);
 372     vcl::vertex::addQuadColors<GL_TRIANGLES>(rTextureParameter.maColors, nColor, 0.0f);
 373 }
 374
 375 void RenderList::addDrawPolyLine(const basegfx::B2DPolygon& rPolygon, double fTransparency,
 376                                  double fLineWidth, basegfx::B2DLineJoin eLineJoin,
 377                                  css::drawing::LineCap eLineCap, double fMiterMinimumAngle,
 378                                  Color nLineColor, bool bUseAA)
 379 {
 380     if (rPolygon.count() <= 1)
 381         return;
 382     if (nLineColor == SALCOLOR_NONE)
 383         return;
 384     if (fTransparency == 1.0)
 385         return;
 386
 387     const bool bIsHairline = fLineWidth <= 1.2;
 388     fLineWidth = bIsHairline ? 1.0f : fLineWidth;
 389
 390     basegfx::B2DPolygon aPolygon(rPolygon);
 391     if (rPolygon.areControlPointsUsed())
 392         aPolygon = rPolygon.getDefaultAdaptiveSubdivision();
 393
 394     checkOverlapping(aPolygon.getB2DRange());
 395
 396     RenderParameters& rParameter = maRenderEntries.back().maLineParameters;
 397
 398     vcl::LineBuilder aBuilder(rParameter.maVertices, rParameter.maIndices,
 399                               nLineColor, fTransparency, fLineWidth, bUseAA);
 400
 401     appendPolyLine(aBuilder, aPolygon, eLineJoin, eLineCap, fMiterMinimumAngle);
 402 }
 403
 404 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */