use const refs and vectors instead of arrays

Change-Id: Ie853e719528ef7f6f72935c8749a5cb8e97c3153

5 files changed, 99 insertions, 87 deletions

diff --git a/canvas/source/opengl/ogl_canvascustomsprite.cxx b/canvas/source/opengl/ogl_canvascustomsprite.cxx
index 6073e5ab1768..9962eb481397 100644
--- a/canvas/source/opengl/ogl_canvascustomsprite.cxx
+++ b/canvas/source/opengl/ogl_canvascustomsprite.cxx
@@ -161,7 +161,8 @@ namespace oglcanvas
                         maTransformation.m02, maTransformation.m12, 0, 1
                     );
 
-                pRenderHelper->SetModelAndMVP(translate * aGLTransform);
+                //pRenderHelper->SetModelAndMVP(translate * aGLTransform);
+                pRenderHelper->SetModelAndMVP( aGLTransform);
                 // content ended up in background buffer - compose to
                 // screen now. Calls below switches us back to window
                 // context, and binds to generated, dynamic texture
@@ -200,12 +201,12 @@ namespace oglcanvas
                                 aSpriteSizePixel.x,
                                 aSpriteSizePixel.y)));
 
-                    GLfloat vertices[rTriangulatedPolygon.count()*2];
+                    std::vector<glm::vec2> vertices;
+                    vertices.reserve(rTriangulatedPolygon.count());
                     for( sal_uInt32 i=0; i<rTriangulatedPolygon.count(); i++ )
                     {
                         const ::basegfx::B2DPoint& rPt( rTriangulatedPolygon.getB2DPoint(i) );
-                        vertices[i*2]= rPt.getX();
-                        vertices[i*2+1]= rPt.getY();
+                        vertices.push_back(glm::vec2(rPt.getX(), rPt.getY()));
                     }
                     pRenderHelper->renderVertexTex( vertices, fWidth, fHeight,  color, GL_TRIANGLES);
                 }
@@ -214,14 +215,19 @@ namespace oglcanvas
                     const double fWidth=maSize.Width/aSpriteSizePixel.x;
                     const double fHeight=maSize.Height/aSpriteSizePixel.y;
 
-                    GLfloat vertices[] = {0, 0,
-                                          0, (float) aSpriteSizePixel.y,
-                                          (float) aSpriteSizePixel.x, 0,
-                                          (float) aSpriteSizePixel.x, (float) aSpriteSizePixel.y };
-                    GLfloat uvCoordinates[] = {0, 0,
-                                               0, (float) fHeight,
-                                               (float) fWidth, 0,
-                                               (float) fWidth, (float) fHeight };
+                    std::vector<glm::vec2> vertices;
+                    vertices.reserve(4);
+                    vertices.push_back(glm::vec2(0, 0));
+                    vertices.push_back(glm::vec2(0, (float) aSpriteSizePixel.y));
+                    vertices.push_back(glm::vec2((float) aSpriteSizePixel.x, 0));
+                    vertices.push_back(glm::vec2((float) aSpriteSizePixel.x, (float) aSpriteSizePixel.y));
+
+                    std::vector<glm::vec2> uvCoordinates;
+                    uvCoordinates.reserve(4);
+                    uvCoordinates.push_back(glm::vec2(0, 0));
+                    uvCoordinates.push_back(glm::vec2(0, (float) fHeight));
+                    uvCoordinates.push_back(glm::vec2((float) fWidth, 0));
+                    uvCoordinates.push_back(glm::vec2((float) fWidth, (float) fHeight));
 
                     pRenderHelper->renderVertexUVTex(vertices,  uvCoordinates, color, GL_TRIANGLE_STRIP );
                 }
@@ -230,23 +236,25 @@ namespace oglcanvas
 
             }
 
-        // translate sprite to output position
-        pRenderHelper->SetModelAndMVP(translate);
-        GLfloat vertices[] = {-2, -2,
-                              -2, (float) maSize.Height+4,
-                              (float) maSize.Width+4, (float) maSize.Height+4,
-                              (float) maSize.Width+4, -2,
-                              -2, -2,
-                              (float) maSize.Width+4, (float) maSize.Height+4 };
+        std::vector<glm::vec2> vertices;
+        vertices.reserve(6);
+        vertices.push_back(glm::vec2(-2, -2));
+        vertices.push_back(glm::vec2(-2, (float) maSize.Height+4));
+        vertices.push_back(glm::vec2((float) maSize.Width+4, (float) maSize.Height+4));
+        vertices.push_back(glm::vec2((float) maSize.Width+4, -2));
+        vertices.push_back(glm::vec2(-2, -2));
+        vertices.push_back(glm::vec2((float) maSize.Width+4, (float) maSize.Height+4));
 
         pRenderHelper->renderVertexConstColor(vertices, glm::vec4(1, 0, 0, 1), GL_LINE_STRIP);
 
+#ifdef DEBUG_RENDERING
         std::vector<double> aVec;
         aVec.push_back(mfAlpha);
         aVec.push_back(mfPriority);
         aVec.push_back(maCanvasHelper.getRecordedActionCount());
 
         renderOSD( aVec, 10, pRenderHelper);
+#endif
 
         return true;
     }
diff --git a/canvas/source/opengl/ogl_canvashelper.cxx b/canvas/source/opengl/ogl_canvashelper.cxx
index 74e2ee8fcb6b..7d25491f2e4c 100644
--- a/canvas/source/opengl/ogl_canvashelper.cxx
+++ b/canvas/source/opengl/ogl_canvashelper.cxx
@@ -101,12 +101,14 @@ namespace oglcanvas
                             const geometry::RealPoint2D&     rPoint)
         {
             RenderHelper* pRenderHelper = rHelper.getDeviceHelper()->getRenderHelper();
-            pRenderHelper->SetModelAndMVP(setupState(rTransform, eSrcBlend, eDstBlend));
+            setupState(rTransform, eSrcBlend, eDstBlend);
             glm::vec4 color  = glm::vec4( (float) rColor.Red,
                                 (float) rColor.Green,
                                 (float) rColor.Blue,
                                 (float) rColor.Alpha);
-            GLfloat vertices[] = {(float) rPoint.X, (float) rPoint.Y};
+            std::vector<glm::vec2> vertices;
+            vertices.reserve(1);
+            vertices.push_back(glm::vec2((float) rPoint.X, (float) rPoint.Y));
             pRenderHelper->renderVertexConstColor(vertices, color, GL_POINTS);
             return true;
         }
@@ -120,13 +122,16 @@ namespace oglcanvas
                            const geometry::RealPoint2D&     rEndPoint)
         {
             RenderHelper* pRenderHelper = rHelper.getDeviceHelper()->getRenderHelper();
-            pRenderHelper->SetModelAndMVP(setupState(rTransform, eSrcBlend, eDstBlend));
+            setupState(rTransform, eSrcBlend, eDstBlend);
             glm::vec4 color  = glm::vec4( (float) rColor.Red,
                                 (float) rColor.Green,
                                 (float) rColor.Blue,
                                 (float) rColor.Alpha);
-            GLfloat vertices[] = {(float) rStartPoint.X, (float) rStartPoint.Y,
-                                  (float) rEndPoint.X, (float) rEndPoint.Y };
+
+            std::vector<glm::vec2> vertices;
+            vertices.reserve(2);
+            vertices.push_back(glm::vec2((float) rStartPoint.X, (float) rStartPoint.Y));
+            vertices.push_back(glm::vec2((float) rEndPoint.X, (float) rEndPoint.Y));
             pRenderHelper->renderVertexConstColor(vertices, color, GL_LINES);
             return true;
         }
@@ -139,7 +144,7 @@ namespace oglcanvas
                                   const ::basegfx::B2DPolyPolygonVector& rPolyPolygons)
         {
             RenderHelper* pRenderHelper = rHelper.getDeviceHelper()->getRenderHelper();
-            pRenderHelper->SetModelAndMVP(setupState(rTransform, eSrcBlend, eDstBlend));
+            setupState(rTransform, eSrcBlend, eDstBlend);
             glm::vec4 color  = glm::vec4( (float) rColor.Red,
                                 (float) rColor.Green,
                                 (float) rColor.Blue,
@@ -278,7 +283,7 @@ namespace oglcanvas
         {
 
             RenderHelper* pRenderHelper = rHelper.getDeviceHelper()->getRenderHelper();
-            pRenderHelper->SetModelAndMVP(setupState(rTransform, eSrcBlend, eDstBlend));
+            setupState(rTransform, eSrcBlend, eDstBlend);
 
             const unsigned int nTexId=rHelper.getDeviceHelper()->getTextureCache().getTexture(
                 rPixelSize, rPixelData.getConstArray(), nPixelCrc32);
@@ -297,14 +302,20 @@ namespace oglcanvas
 
             // blend against fixed vertex color; texture alpha is multiplied in
             glm::vec4 color  = glm::vec4(1, 1, 1, 1);
-            GLfloat vertices[] = {0, 0,
-                                  0, (float) rPixelSize.Height,
-                                  (float) rPixelSize.Width, 0,
-                                  (float) rPixelSize.Width, (float) rPixelSize.Height };
-            GLfloat uvCoordinates[] = {0, 0,
-                                       0, 1,
-                                       1, 0,
-                                       1, 1 };
+
+            std::vector<glm::vec2> vertices;
+            vertices.reserve(4);
+            vertices.push_back(glm::vec2(0, 0));
+            vertices.push_back(glm::vec2(0, (float) rPixelSize.Height));
+            vertices.push_back(glm::vec2((float) rPixelSize.Width, 0));
+            vertices.push_back(glm::vec2((float) rPixelSize.Width, (float) rPixelSize.Height));
+
+            std::vector<glm::vec2> uvCoordinates;
+            uvCoordinates.reserve(4);
+            uvCoordinates.push_back(glm::vec2(0, 0));
+            uvCoordinates.push_back(glm::vec2(0, 1));
+            uvCoordinates.push_back(glm::vec2(1, 0));
+            uvCoordinates.push_back(glm::vec2(1, 1));
             pRenderHelper->renderVertexUVTex(vertices, uvCoordinates, color, GL_TRIANGLE_STRIP );
 
             glBindTexture(GL_TEXTURE_2D, 0);
diff --git a/canvas/source/opengl/ogl_renderHelper.cxx b/canvas/source/opengl/ogl_renderHelper.cxx
index acd0a1746f9e..70f1769f79e1 100644
--- a/canvas/source/opengl/ogl_renderHelper.cxx
+++ b/canvas/source/opengl/ogl_renderHelper.cxx
@@ -10,13 +10,13 @@
 #include <GL/glew.h>
 #include "ogl_renderHelper.hxx"
 #include <vcl/opengl/OpenGLHelper.hxx>
+#include <vcl/opengl/GLMHelper.hxx>
 namespace oglcanvas
 {
-    RenderHelper::RenderHelper()
-    : m_iWidth(1600) //Why this dimensions?
-    , m_iHeight(900) //Whole window, see spritedevicehelper
-    , m_Model(glm::mat4(1.0f))
+    RenderHelper::RenderHelper():
+        m_Model(glm::mat4(1.0f))
     {
+
     }
     void RenderHelper::InitOpenGL()
     {
@@ -29,7 +29,7 @@ namespace oglcanvas
         m_simpleTexUnf = glGetUniformLocation(m_simpleProgID, "TextTex");
 
         m_manCordUnf = glGetUniformLocation(m_texManProgID, "texCord");
-        m_texColorUnf = glGetUniformLocation(m_texProgID, "constColor");
+        m_texColorUnf = glGetUniformLocation(m_texProgID, "constantColor");
 
         m_manColorUnf = glGetUniformLocation(m_texManProgID,"colorTex");
         m_simpleColorUnf = glGetUniformLocation(m_simpleProgID,"colorTex");
@@ -45,29 +45,24 @@ namespace oglcanvas
         m_simplePosAttrb = glGetAttribLocation(m_simpleProgID ,"vPosition");
         m_texPosAttrb = glGetAttribLocation(m_texProgID ,"vPosition");
 
-        //glViewport(0, 0, m_iWidth, m_iHeight);
     }
-    //Todo figgure out, which parameters i should use :)
-    void RenderHelper::SetVP(int width, int height)
+
+    void RenderHelper::SetVP(const float width, const float height)
     {
-        m_Projection = glm::ortho(0.f, float(m_iWidth), 0.f, float(m_iHeight), -4.f, 3.f);
-        m_Projection = m_Projection * glm::scale(glm::vec3((float)width / m_iWidth, -(float)height / m_iHeight, 1.0f));
+        m_VP = glm::ortho(0.0f, width, 0.0f, height);
 
-        m_View       = glm::lookAt(glm::vec3(0,m_iHeight,1),
-                                   glm::vec3(0,m_iHeight,0),
-                                   glm::vec3(0,1,0) );
     }
-    void RenderHelper::SetModelAndMVP(glm::mat4 mat)
+
+    void RenderHelper::SetModelAndMVP(const glm::mat4& mat)
     {
         m_Model = mat;
-        m_MVP = m_Projection * m_View * m_Model;
+        m_MVP = m_Model * m_VP;
     }
 
-
-    void RenderHelper::renderVertexConstColor(GLfloat vertices[], glm::vec4 color, GLenum mode) const
+    void RenderHelper::renderVertexConstColor(const std::vector<glm::vec2>& rVertices, glm::vec4 color, GLenum mode) const
     {
         glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, rVertices.size()*2, &rVertices[0].x, GL_STATIC_DRAW);
 
         glUseProgram(m_texProgID);
 
@@ -85,7 +80,7 @@ namespace oglcanvas
                         (void*)0                      // array buffer offset
         );
 
-        glDrawArrays(mode, 0, sizeof(vertices) / 2);
+        glDrawArrays(mode, 0, rVertices.size());
 
         glDisableVertexAttribArray(m_texPosAttrb);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -93,13 +88,13 @@ namespace oglcanvas
 
     }
     //Renders a TriangleStrip, Texture has to be stored in TextureUnit0
-    void RenderHelper::renderVertexUVTex(GLfloat vertices[], GLfloat uvCoordinates[], glm::vec4 color, GLenum mode) const
+    void RenderHelper::renderVertexUVTex(const std::vector<glm::vec2>& rVertices, const std::vector<glm::vec2>& rUVcoords, glm::vec4 color, GLenum mode) const
     {
         glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, rVertices.size()*2, &rVertices[0].x, GL_STATIC_DRAW);
 
         glBindBuffer(GL_ARRAY_BUFFER, m_uvBuffer);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(uvCoordinates), uvCoordinates, GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, rUVcoords.size()*2, &rUVcoords[0].x, GL_STATIC_DRAW);
 
         glUseProgram(m_simpleProgID);
 
@@ -130,7 +125,7 @@ namespace oglcanvas
             (void*)0                      // array buffer offset
         );
 
-        glDrawArrays(mode, 0, sizeof(vertices) / 2);
+        glDrawArrays(mode, 0, rVertices.size());
 
         glDisableVertexAttribArray(m_simplePosAttrb);
         glDisableVertexAttribArray(m_simpleUvAttrb);
@@ -150,10 +145,10 @@ namespace oglcanvas
 
     // Renders a Polygon, Texture has to be stored in TextureUnit0
     // Uses fWidth,fHeight to generate texture coordinates in vertex-shader.
-    void RenderHelper::renderVertexTex(GLfloat vertices[], GLfloat fWidth, GLfloat fHeight, glm::vec4 color, GLenum mode) const
+    void RenderHelper::renderVertexTex(const std::vector<glm::vec2>& rVertices, GLfloat fWidth, GLfloat fHeight, glm::vec4 color, GLenum mode) const
     {
         glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, rVertices.size()*2, &rVertices[0].x, GL_STATIC_DRAW);
 
         glUseProgram(m_texManProgID);
 
@@ -174,7 +169,7 @@ namespace oglcanvas
             (void*)0                      // array buffer offset
         );
 
-        glDrawArrays(mode, 0, sizeof(vertices) / 2);
+        glDrawArrays(mode, 0, rVertices.size());
 
         glDisableVertexAttribArray(m_manPosAttrb);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
diff --git a/canvas/source/opengl/ogl_renderHelper.hxx b/canvas/source/opengl/ogl_renderHelper.hxx
index 803e198806ec..504df4ffcc11 100644
--- a/canvas/source/opengl/ogl_renderHelper.hxx
+++ b/canvas/source/opengl/ogl_renderHelper.hxx
@@ -12,20 +12,21 @@
 #include <GL/glew.h>
 #include <glm/glm.hpp>
 #include "glm/gtx/transform.hpp"
+#include <vector>
 namespace oglcanvas
 {
     class RenderHelper
     {
     public:
 
-        void renderVertexConstColor(GLfloat vertices[], glm::vec4 color, GLenum mode) const;
-        void renderVertexUVTex(GLfloat vertices[], GLfloat uvCoordinates[], glm::vec4 color, GLenum mode) const;
-        void renderVertexTex(GLfloat vertices[], GLfloat, GLfloat, glm::vec4 color, GLenum mode) const;
+        void renderVertexConstColor(const std::vector<glm::vec2>& rVertices, glm::vec4 color, GLenum mode) const;
+        void renderVertexUVTex(const std::vector<glm::vec2>& rVertices, const std::vector<glm::vec2>& rUVcoords, glm::vec4 color, GLenum mode) const;
+        void renderVertexTex(const std::vector<glm::vec2>& rVertices, GLfloat, GLfloat, glm::vec4 color, GLenum mode) const;
 
         RenderHelper();
 
-        void SetVP(int width, int height);
-        void SetModelAndMVP(glm::mat4 mat);
+        void SetVP(const float width, const float height);
+        void SetModelAndMVP(const glm::mat4& mat);
         void dispose();
         void  InitOpenGL();
 
@@ -59,10 +60,7 @@ namespace oglcanvas
         int                                               m_iWidth;
         int                                               m_iHeight;
 
-        // Projection matrix : default 45 degree Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
-        glm::mat4                                         m_Projection;
-        // Camera matrix
-        glm::mat4                                         m_View;
+        glm::mat4                                         m_VP;
         // Model matrix : an identity matrix (model will be at the origin
         glm::mat4                                         m_Model;
         // Our ModelViewProjection : multiplication of our 3 matrices
diff --git a/canvas/source/opengl/ogl_spritedevicehelper.cxx b/canvas/source/opengl/ogl_spritedevicehelper.cxx
index 63eeef3101e1..0d171d62664b 100644
--- a/canvas/source/opengl/ogl_spritedevicehelper.cxx
+++ b/canvas/source/opengl/ogl_spritedevicehelper.cxx
@@ -300,6 +300,17 @@ namespace oglcanvas
         SystemChildWindow* pChildWindow = mpContext->getChildWindow();
         const ::Size& rOutputSize = pChildWindow->GetSizePixel();
         initTransformation(rOutputSize);
+
+        glm::mat4 ViewTranslate = glm::translate(
+        glm::mat4(1.0f),
+        glm::vec3(-1.0,  1.0, 0.0));
+        glm::mat4 ViewScaled = glm::scale(
+        ViewTranslate,
+        glm::vec3(2.0  / rOutputSize.Width(),
+              -2.0/ rOutputSize.Height(),
+              1.0 ));
+        mRenderHelper.SetModelAndMVP(ViewScaled);
+
         // render the actual spritecanvas content
         mpSpriteCanvas->renderRecordedActions();
 
@@ -318,33 +329,21 @@ namespace oglcanvas
 
 
         // frame counter, other info
-        glMatrixMode(GL_MODELVIEW);
-        glLoadIdentity();
-        glTranslated(-1.0, 1.0, 0.0);
-        glScaled( 2.0  / rOutputSize.Width(),
-                  -2.0 / rOutputSize.Height(),
-                  1.0 );
-
         const double denominator( maLastUpdate.getElapsedTime() );
         maLastUpdate.reset();
 
         const double fps(denominator == 0.0 ? 100.0 : 1.0/denominator);
+
+        mRenderHelper.SetModelAndMVP(ViewScaled);
+
+#ifdef  RENDER_DEBUG
         std::vector<double> aVec; aVec.push_back(fps);
         aVec.push_back(maActiveSprites.size());
         aVec.push_back(mpTextureCache->getCacheSize());
         aVec.push_back(mpTextureCache->getCacheMissCount());
         aVec.push_back(mpTextureCache->getCacheHitCount());
-
-        glm::mat4 ViewTranslate = glm::translate(
-            glm::mat4(1.0f),
-            glm::vec3(-1.0,1.0,0.0));
-        glm::mat4 ViewScaled = glm::scale(
-            ViewTranslate,
-            glm::vec3(2.0  / rOutputSize.Width(),
-                  -2.0 / rOutputSize.Height(),
-                  1.0 ));
-        mRenderHelper.SetModelAndMVP(ViewScaled);
         renderOSD( aVec, 20 , getRenderHelper());
+#endif
 
         /*
          * TODO: moggi: fix it!
@@ -404,6 +403,7 @@ namespace oglcanvas
             SystemChildWindow* pChildWindow = mpContext->getChildWindow();
             pChildWindow->setPosSizePixel(
                 0,0,rBounds.Width,rBounds.Height);
+            mRenderHelper.SetVP(rBounds.Width, rBounds.Height);
         }
     }