opengl: deferred texture drawing in RenderList, add drawAlphaRect

Drawing accumulated textures (in Accumulatedtextures) is independent
of drawing with render list which causes problems with rendering
order when render list and accumulated textures are flushed. To
solve this we need to combine both so we can check for overlapped
drawing.

Previously drawRect was using RenderList batch drawing but not
drawAlphaRect which is essentially the same as drawRect but
additionally supports alpha value. This adds support to draw
alpha rectangles to RenderList and converts drawAlphaRect.

Change-Id: I82bf0b410e5ebabb13bab7b29a2e53a6fdaa404f

4 files changed, 121 insertions, 108 deletions

diff --git a/vcl/opengl/RenderList.cxx b/vcl/opengl/RenderList.cxx
index de5a9d6dc02a..818831950aaf 100644
--- a/vcl/opengl/RenderList.cxx
+++ b/vcl/opengl/RenderList.cxx
@@ -52,10 +52,13 @@ void RenderList::addDrawPixel(long nX, long nY, const SalColor& rColor)
     vcl::vertex::addQuadEmptyExtrusionVectors<GL_TRIANGLES>(rRenderParameter.maExtrusionVectors);
 }
 
-void RenderList::addDrawRectangle(long nX, long nY, long nWidth, long nHeight, const SalColor& rLineColor, const SalColor& rFillColor)
+void RenderList::addDrawRectangle(long nX, long nY, long nWidth, long nHeight, double fTransparency,
+                                  const SalColor& rLineColor, const SalColor& rFillColor)
 {
     if (rLineColor == SALCOLOR_NONE && rFillColor == SALCOLOR_NONE)
         return;
+    if (fTransparency == 1.0f)
+        return;
 
     GLfloat fX1(nX);
     GLfloat fY1(nY);
@@ -74,10 +77,10 @@ void RenderList::addDrawRectangle(long nX, long nY, long nWidth, long nHeight, c
         vcl::vertex::addRectangle<GL_TRIANGLES>(rRenderParameter.maVertices, fX2 - 0.5f, fY1 - 0.5f, fX2 + 0.5f, fY2 + 0.5f);
         vcl::vertex::addRectangle<GL_TRIANGLES>(rRenderParameter.maVertices, fX1 - 0.5f, fY2 - 0.5f, fX2 + 0.5f, fY2 + 0.5f);
 
-        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, 0.0f);
-        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, 0.0f);
-        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, 0.0f);
-        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, 0.0f);
+        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, fTransparency);
+        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, fTransparency);
+        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, fTransparency);
+        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rLineColor, fTransparency);
 
         vcl::vertex::addQuadEmptyExtrusionVectors<GL_TRIANGLES>(rRenderParameter.maExtrusionVectors);
         vcl::vertex::addQuadEmptyExtrusionVectors<GL_TRIANGLES>(rRenderParameter.maExtrusionVectors);
@@ -95,10 +98,10 @@ void RenderList::addDrawRectangle(long nX, long nY, long nWidth, long nHeight, c
             vcl::vertex::addRectangle<GL_TRIANGLES>(rRenderParameter.maVertices, fX2 - 0.5f, fY1 - 0.5f, fX2 + 0.5f, fY2 + 0.5f);
             vcl::vertex::addRectangle<GL_TRIANGLES>(rRenderParameter.maVertices, fX1 - 0.5f, fY2 - 0.5f, fX2 + 0.5f, fY2 + 0.5f);
 
-            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, 0.0f);
-            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, 0.0f);
-            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, 0.0f);
-            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, 0.0f);
+            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, fTransparency);
+            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, fTransparency);
+            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, fTransparency);
+            vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, fTransparency);
 
             vcl::vertex::addQuadEmptyExtrusionVectors<GL_TRIANGLES>(rRenderParameter.maExtrusionVectors);
             vcl::vertex::addQuadEmptyExtrusionVectors<GL_TRIANGLES>(rRenderParameter.maExtrusionVectors);
@@ -107,7 +110,7 @@ void RenderList::addDrawRectangle(long nX, long nY, long nWidth, long nHeight, c
         }
         // Draw rectangle fill with fill color
         vcl::vertex::addRectangle<GL_TRIANGLES>(rRenderParameter.maVertices, fX1 + 0.5f, fY1 + 0.5f, fX2 - 0.5f, fY2 - 0.5f);
-        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, 0.0f);
+        vcl::vertex::addQuadColors<GL_TRIANGLES>(rRenderParameter.maColors, rFillColor, fTransparency);
         vcl::vertex::addQuadEmptyExtrusionVectors<GL_TRIANGLES>(rRenderParameter.maExtrusionVectors);
     }
 }
@@ -213,4 +216,29 @@ void RenderList::addDrawPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon,
     }
 }
 
+bool RenderList::addDrawTextureWithMaskColor(OpenGLTexture& rTexture, const SalColor& rColor, const SalTwoRect& r2Rect)
+{
+    if (!rTexture)
+        return false;
+
+    GLfloat fX1 = r2Rect.mnDestX;
+    GLfloat fY1 = r2Rect.mnDestY;
+    GLfloat fX2 = fX1 + r2Rect.mnDestWidth;
+    GLfloat fY2 = fY1 + r2Rect.mnDestHeight;
+
+    checkOverlapping(basegfx::B2DRange(fX1, fY1, fX2, fY2));
+
+    GLuint nTextureId = rTexture.Id();
+
+    RenderTextureParameters& rTextureParameter = maRenderEntries.back().maTextureParametersMap[nTextureId];
+    rTextureParameter.maTexture = rTexture;
+
+    rTexture.FillCoords<GL_TRIANGLES>(rTextureParameter.maTextureCoords, r2Rect, false);
+
+    vcl::vertex::addRectangle<GL_TRIANGLES>(rTextureParameter.maVertices, fX1, fY1, fX2, fY2);
+    vcl::vertex::addQuadColors<GL_TRIANGLES>(rTextureParameter.maColors, rColor, 0.0f);
+
+    return true;
+}
+
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/opengl/combinedTextureFragmentShader.glsl b/vcl/opengl/combinedTextureFragmentShader.glsl
index d8864cfe21c5..67797be2c096 100644
--- a/vcl/opengl/combinedTextureFragmentShader.glsl
+++ b/vcl/opengl/combinedTextureFragmentShader.glsl
@@ -10,6 +10,9 @@
 varying vec2 tex_coord;
 varying vec2 alpha_coord;
 varying vec2 mask_coord;
+#ifdef USE_VERTEX_COLORS
+varying vec4 vertex_color;
+#endif
 
 uniform sampler2D texture;
 uniform sampler2D mask;
@@ -56,7 +59,11 @@ void main()
     }
     else if (type == TYPE_MASKED_COLOR)
     {
+#ifdef USE_VERTEX_COLORS
+        gl_FragColor = vertex_color;
+#else
         gl_FragColor = color;
+#endif
         gl_FragColor.a = 1.0 - texelTexture.r;
     }
 }
diff --git a/vcl/opengl/combinedTextureVertexShader.glsl b/vcl/opengl/combinedTextureVertexShader.glsl
index 883ec631fa73..3086806266f9 100644
--- a/vcl/opengl/combinedTextureVertexShader.glsl
+++ b/vcl/opengl/combinedTextureVertexShader.glsl
@@ -11,10 +11,16 @@ attribute vec4 position;
 attribute vec2 tex_coord_in;
 attribute vec2 mask_coord_in;
 attribute vec2 alpha_coord_in;
+#ifdef USE_VERTEX_COLORS
+attribute vec4 vertex_color_in;
+#endif
 
 varying vec2 tex_coord;
 varying vec2 mask_coord;
 varying vec2 alpha_coord;
+#ifdef USE_VERTEX_COLORS
+varying vec4 vertex_color;
+#endif
 
 uniform mat4 mvp;
 uniform mat4 transform;
@@ -27,6 +33,9 @@ void main()
    tex_coord = tex_coord_in;
    mask_coord = mask_coord_in;
    alpha_coord = alpha_coord_in;
+#ifdef USE_VERTEX_COLORS
+   vertex_color = vertex_color_in;
+#endif
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/opengl/gdiimpl.cxx b/vcl/opengl/gdiimpl.cxx
index 0d939e31df2f..245c468b21fd 100644
--- a/vcl/opengl/gdiimpl.cxx
+++ b/vcl/opengl/gdiimpl.cxx
@@ -84,7 +84,6 @@ OpenGLSalGraphicsImpl::OpenGLSalGraphicsImpl(SalGraphics& rParent, SalGeometryPr
     , mnDrawCountAtFlush(0)
     , mProgramSolidColor(SALCOLOR_NONE)
     , mProgramSolidTransparency(0.0)
-    , mpAccumulatedTextures(new AccumulatedTextures)
     , mpRenderList(new RenderList)
 {
 }
@@ -1501,107 +1500,90 @@ void OpenGLSalGraphicsImpl::DrawMask( OpenGLTexture& rMask, SalColor nMaskColor,
 
 void OpenGLSalGraphicsImpl::DeferredTextDraw(OpenGLTexture& rTexture, SalColor aMaskColor, const SalTwoRect& rPosAry)
 {
-    mpAccumulatedTextures->insert(rTexture, aMaskColor, rPosAry);
+    mpRenderList->addDrawTextureWithMaskColor(rTexture, aMaskColor, rPosAry);
 }
 
 void OpenGLSalGraphicsImpl::FlushDeferredDrawing()
 {
-    if (mpAccumulatedTextures->empty() && mpRenderList->empty())
+    if (mpRenderList->empty())
         return;
 
     VCL_GL_INFO("FlushDeferredDrawing: " << mpRenderList->getEntries().size());
 
-    if (!mpAccumulatedTextures->empty())
-    {
-        InitializePreDrawState();
-
-        OpenGLZone aZone;
+    InitializePreDrawState(XOROption::IMPLEMENT_XOR);
 
-        if (!UseProgram("combinedTextureVertexShader", "combinedTextureFragmentShader"))
-            return;
-        mpProgram->SetShaderType(TextureShaderType::MaskedColor);
-        mpProgram->SetIdentityTransform("transform");
-        mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-        for (auto& rPair : mpAccumulatedTextures->getAccumulatedTexturesMap())
+    OpenGLZone aZone;
+    for (RenderEntry& rRenderEntry : mpRenderList->getEntries())
+    {
+        if (rRenderEntry.hasTriangles() && UseProgram("combinedVertexShader", "combinedFragmentShader", "#define USE_VERTEX_COLORS"))
         {
-            OpenGLTexture& rTexture = rPair.second->maTexture;
-            mpProgram->SetTexture("texture", rTexture);
-            for (auto& rColorTwoRectPair: rPair.second->maColorTextureDrawParametersMap)
+            RenderParameters& rParameters = rRenderEntry.maTriangleParameters;
+            VCL_GL_INFO("Flush Triangles: " << rParameters.maVertices.size());
+            mpProgram->SetShaderType(DrawShaderType::Normal);
+            mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            ApplyProgramMatrices(0.5f);
+            mpProgram->SetExtrusionVectors(rParameters.maExtrusionVectors.data());
+            mpProgram->SetVertexColors(rParameters.maColors);
+            mpProgram->DrawArrays(GL_TRIANGLES, rParameters.maVertices);
+            CHECK_GL_ERROR();
+            mpProgram->Clean();
+        }
+        if (rRenderEntry.hasLines() && UseProgram("combinedVertexShader", "combinedFragmentShader", "#define USE_VERTEX_COLORS"))
+        {
+            RenderParameters& rParameters = rRenderEntry.maLineParameters;
+            VCL_GL_INFO("Flush Lines: " << rParameters.maVertices.size());
+            mpProgram->SetShaderType(DrawShaderType::Line);
+            mpProgram->SetUniform1f("line_width", 1.0f);
+            mpProgram->SetUniform1f("feather", 0.0f); // Anti-Aliasing disabled
+            mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            ApplyProgramMatrices(0.5f);
+            mpProgram->SetExtrusionVectors(rParameters.maExtrusionVectors.data());
+            mpProgram->SetVertexColors(rParameters.maColors);
+            mpProgram->DrawArrays(GL_TRIANGLES, rParameters.maVertices);
+            CHECK_GL_ERROR();
+            mpProgram->Clean();
+        }
+        if (rRenderEntry.hasLinesAA() && UseProgram("combinedVertexShader", "combinedFragmentShader", "#define USE_VERTEX_COLORS"))
+        {
+            RenderParameters& rParameters = rRenderEntry.maLineAAParameters;
+            VCL_GL_INFO("Flush Lines AA: " << rParameters.maVertices.size());
+            mpProgram->SetShaderType(DrawShaderType::Line);
+            mpProgram->SetUniform1f("line_width", 1.0f);
+            mpProgram->SetUniform1f("feather", 0.5f); // Anti-Aliasing enabled
+            mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            ApplyProgramMatrices(0.5f);
+            mpProgram->SetExtrusionVectors(rParameters.maExtrusionVectors.data());
+            mpProgram->SetVertexColors(rParameters.maColors);
+            mpProgram->DrawArrays(GL_TRIANGLES, rParameters.maVertices);
+            CHECK_GL_ERROR();
+            mpProgram->Clean();
+        }
+        if (rRenderEntry.hasTextures() && UseProgram("combinedTextureVertexShader", "combinedTextureFragmentShader", "#define USE_VERTEX_COLORS"))
+        {
+            mpProgram->SetShaderType(TextureShaderType::MaskedColor);
+            mpProgram->SetIdentityTransform("transform");
+            mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+            for (auto& rPair : rRenderEntry.maTextureParametersMap)
             {
-                mpProgram->SetColor("color", rColorTwoRectPair.first, 0);
-                TextureDrawParameters& rParameters = rColorTwoRectPair.second;
+                RenderTextureParameters& rParameters = rPair.second;
+                mpProgram->SetTexture("texture", rParameters.maTexture);
                 ApplyProgramMatrices();
                 mpProgram->SetTextureCoord(rParameters.maTextureCoords.data());
                 mpProgram->SetMaskCoord(rParameters.maTextureCoords.data());
                 mpProgram->SetAlphaCoord(rParameters.maTextureCoords.data());
-                mpProgram->DrawArrays(GL_TRIANGLES, rParameters.maVertices);
-            }
-        }
-        mpProgram->Clean();
-        mpAccumulatedTextures->clear();
-
-        PostDraw();
-    }
-
-    if (!mpRenderList->empty())
-    {
-        InitializePreDrawState(XOROption::IMPLEMENT_XOR);
-
-        OpenGLZone aZone;
-        for (RenderEntry& rRenderEntry : mpRenderList->getEntries())
-        {
-            if (rRenderEntry.hasTriangles() && UseProgram("combinedVertexShader", "combinedFragmentShader", "#define USE_VERTEX_COLORS"))
-            {
-                RenderParameters& rParameters = rRenderEntry.maTriangleParameters;
-                VCL_GL_INFO("Flush Triangles: " << rParameters.maVertices.size());
-                mpProgram->SetShaderType(DrawShaderType::Normal);
-                mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                ApplyProgramMatrices(0.5f);
-                mpProgram->SetExtrusionVectors(rParameters.maExtrusionVectors.data());
-                mpProgram->SetVertexColors(rParameters.maColors);
-                mpProgram->DrawArrays(GL_TRIANGLES, rParameters.maVertices);
-                CHECK_GL_ERROR();
-                mpProgram->Clean();
-            }
-            if (rRenderEntry.hasLines() && UseProgram("combinedVertexShader", "combinedFragmentShader", "#define USE_VERTEX_COLORS"))
-            {
-                RenderParameters& rParameters = rRenderEntry.maLineParameters;
-                VCL_GL_INFO("Flush Lines: " << rParameters.maVertices.size());
-                mpProgram->SetShaderType(DrawShaderType::Line);
-                mpProgram->SetUniform1f("line_width", 1.0f);
-                mpProgram->SetUniform1f("feather", 0.0f); // Anti-Aliasing disabled
-                mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                ApplyProgramMatrices(0.5f);
-                mpProgram->SetExtrusionVectors(rParameters.maExtrusionVectors.data());
                 mpProgram->SetVertexColors(rParameters.maColors);
                 mpProgram->DrawArrays(GL_TRIANGLES, rParameters.maVertices);
                 CHECK_GL_ERROR();
-                mpProgram->Clean();
-            }
-            if (rRenderEntry.hasLinesAA() && UseProgram("combinedVertexShader", "combinedFragmentShader", "#define USE_VERTEX_COLORS"))
-            {
-                RenderParameters& rParameters = rRenderEntry.maLineAAParameters;
-                VCL_GL_INFO("Flush Lines AA: " << rParameters.maVertices.size());
-                mpProgram->SetShaderType(DrawShaderType::Line);
-                mpProgram->SetUniform1f("line_width", 1.0f);
-                mpProgram->SetUniform1f("feather", 0.5f); // Anti-Aliasing enabled
-                mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                ApplyProgramMatrices(0.5f);
-                mpProgram->SetExtrusionVectors(rParameters.maExtrusionVectors.data());
-                mpProgram->SetVertexColors(rParameters.maColors);
-                mpProgram->DrawArrays(GL_TRIANGLES, rParameters.maVertices);
-                CHECK_GL_ERROR();
-                mpProgram->Clean();
             }
+            mpProgram->Clean();
         }
-
-        mpRenderList->clear();
-        PostDraw();
     }
 
-    VCL_GL_INFO("End FlushDeferredDrawing");
+    mpRenderList->clear();
+    PostDraw();
 
+    VCL_GL_INFO("End FlushDeferredDrawing");
 }
 
 void OpenGLSalGraphicsImpl::DrawLinearGradient( const Gradient& rGradient, const Rectangle& rRect )
@@ -1731,7 +1713,7 @@ void OpenGLSalGraphicsImpl::drawLine(long nX1, long nY1, long nX2, long nY2)
 void OpenGLSalGraphicsImpl::drawRect( long nX, long nY, long nWidth, long nHeight )
 {
     VCL_GL_INFO("::drawRect (" << nX << ", " << nY << ") [" << nWidth << ", " << nHeight << "]");
-    mpRenderList->addDrawRectangle(nX, nY, nWidth, nHeight, mnLineColor, mnFillColor);
+    mpRenderList->addDrawRectangle(nX, nY, nWidth, nHeight, 0.0, mnLineColor, mnFillColor);
 }
 
 void OpenGLSalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry )
@@ -1925,17 +1907,11 @@ void OpenGLSalGraphicsImpl::drawMask(
             const SalBitmap& rSalBitmap,
             SalColor nMaskColor )
 {
-    assert(dynamic_cast<const OpenGLSalBitmap*>(&rSalBitmap));
-
-    OpenGLZone aZone;
+    VCL_GL_INFO("::drawMask");
 
+    assert(dynamic_cast<const OpenGLSalBitmap*>(&rSalBitmap));
     const OpenGLSalBitmap& rBitmap = static_cast<const OpenGLSalBitmap&>(rSalBitmap);
-    OpenGLTexture& rTexture( rBitmap.GetTexture() );
-
-    VCL_GL_INFO( "::drawMask" );
-    PreDraw();
-    DrawMask( rTexture, nMaskColor, rPosAry );
-    PostDraw();
+    mpRenderList->addDrawTextureWithMaskColor(rBitmap.GetTexture(), nMaskColor, rPosAry);
 }
 
 SalBitmap* OpenGLSalGraphicsImpl::getBitmap( long nX, long nY, long nWidth, long nHeight )
@@ -2151,15 +2127,8 @@ bool OpenGLSalGraphicsImpl::drawAlphaRect(
                 long nWidth, long nHeight,
                 sal_uInt8 nTransparency )
 {
-    VCL_GL_INFO( "::drawAlphaRect" );
-    if( mnFillColor != SALCOLOR_NONE && nTransparency < 100 )
-    {
-        PreDraw();
-        UseSolid( mnFillColor, nTransparency );
-        DrawRect( nX, nY, nWidth, nHeight );
-        PostDraw();
-    }
-
+    VCL_GL_INFO("::drawAlphaRect (" << nX << ", " << nY << ") [" << nWidth << ", " << nHeight << "]");
+    mpRenderList->addDrawRectangle(nX, nY, nWidth, nHeight, double(nTransparency / 100.0), mnLineColor, mnFillColor);
     return true;
 }