Added VBO_CONTAINER as a faster storage for vertices (OPENGL_GAL), tuned for...

Added VBO_CONTAINER as a faster storage for vertices (OPENGL_GAL), tuned for exchanging data with GPU.

Removed a few unnecessary variables and fields from OPENGL_GAL.
Added function GAL::ClearCache() for freeing memory used by cached items.
Fixed a few memory leaks (tesselator, PAINTER's settings & VIEW_ITEM's groups).
Changed a few functions into inlines.

common/CMakeLists.txt

@@ -21,6 +21,7 @@ set(GAL_SRCS
     gal/opengl/opengl_gal.cpp
     gal/opengl/shader.cpp
     gal/opengl/vbo_item.cpp
+    gal/opengl/vbo_container.cpp
     gal/cairo/cairo_gal.cpp
     view/wx_view_controls.cpp
     )

common/gal/cairo/cairo_gal.cpp

@@ -99,10 +99,7 @@ CAIRO_GAL::~CAIRO_GAL()
     delete cursorPixels;
     delete cursorPixelsSaved;
 
-    for( int i = groups.size() - 1; i >= 0; --i )
-    {
-        DeleteGroup( i );
-    }
+    ClearCache();
 
     deleteBitmaps();
 }
@@ -687,13 +684,22 @@ void CAIRO_GAL::EndGroup()
 }
 
 
+void CAIRO_GAL::ClearCache()
+{
+    for( int i = groups.size() - 1; i >= 0; --i )
+    {
+        DeleteGroup( i );
+    }
+}
+
+
 void CAIRO_GAL::DeleteGroup( int aGroupNumber )
 {
     storePath();
 
     // Delete the Cairo paths
-    for( std::deque<GroupElement>::iterator it = groups[aGroupNumber].begin(), end = groups[aGroupNumber].end();
-         it != end; ++it )
+    std::deque<GroupElement>::iterator it, end;
+    for( it = groups[aGroupNumber].begin(), end = groups[aGroupNumber].end(); it != end; ++it )
     {
         if( it->command == CMD_FILL_PATH || it->command == CMD_STROKE_PATH )
         {

common/gal/opengl/vbo_item.cpp

@@ -27,107 +27,98 @@
  * @brief Class to handle an item held in a Vertex Buffer Object.
  */
 
+#include <gal/opengl/vbo_container.h>
 #include <gal/opengl/vbo_item.h>
 #include <cstring>
 
 using namespace KiGfx;
 
-VBO_ITEM::VBO_ITEM() :
-        m_vertices( NULL ),
+VBO_ITEM::VBO_ITEM( VBO_CONTAINER* aContainer ) :
         m_offset( 0 ),
         m_size( 0 ),
+        m_container( aContainer ),
         m_isDirty( true ),
         m_transform( NULL )
 {
     // By default no shader is used
     m_shader[0] = 0;
 
-    // Prepare a block for storing vertices & indices
-    useNewBlock();
+    // The item's size is not known yet, so we just start an item in the container
+    aContainer->StartItem( this );
 }
 
 
 VBO_ITEM::~VBO_ITEM()
 {
-    if( m_isDirty )
-    {
-        // Data is still stored in blocks
-        std::list<VBO_VERTEX*>::const_iterator v_it, v_end;
-        for( v_it = m_vertBlocks.begin(), v_end = m_vertBlocks.end(); v_it != v_end; ++v_it )
-            delete[] *v_it;
-    }
-
-    if( m_vertices )
-        delete m_vertices;
+    m_container->Free( this );
 }
 
 
-void VBO_ITEM::PushVertex( const GLfloat* aVertex )
+void VBO_ITEM::PushVertex( VBO_VERTEX* aVertex )
 {
-    if( m_spaceLeft == 0 )
-        useNewBlock();
-
     if( m_transform != NULL )
     {
         // Apply transformations
-        //                X,          Y,          Z coordinates
-        glm::vec4 vertex( aVertex[0], aVertex[1], aVertex[2], 1.0f );
+        glm::vec4 vertex( aVertex->x, aVertex->y, aVertex->z, 1.0f );
         vertex = *m_transform * vertex;
 
         // Replace only coordinates, leave color as it is
-        memcpy( &m_vertPtr->x, &vertex[0], CoordByteSize );
-    }
-    else
-    {
-        // Add the new vertex
-        memcpy( &m_vertPtr->x, aVertex, CoordByteSize );
+        aVertex->x = vertex.x;
+        aVertex->y = vertex.y;
+        aVertex->z = vertex.z;
     }
 
     // Apply currently used color
-    memcpy( &m_vertPtr->r, m_color, ColorByteSize );
+    aVertex->r = m_color[0];
+    aVertex->g = m_color[1];
+    aVertex->b = m_color[2];
+    aVertex->a = m_color[3];
 
     // Apply currently used shader
-    memcpy( &m_vertPtr->shader, m_shader, ShaderByteSize );
+    for( int i = 0; i < ShaderStride; ++i )
+    {
+        aVertex->shader[i] = m_shader[i];
+    }
 
-    // Move to the next free space
-    m_vertPtr++;
+    m_container->Add( this, aVertex );
 
     m_size++;
     m_isDirty = true;
-    m_spaceLeft--;
 }
 
 
-void VBO_ITEM::PushVertices( const GLfloat* aVertices, GLuint aSize )
+void VBO_ITEM::PushVertices( VBO_VERTEX* aVertices, GLuint aSize )
 {
     for( unsigned int i = 0; i < aSize; ++i )
     {
-        PushVertex( &aVertices[i * VertStride] );
+        PushVertex( &aVertices[i] );
     }
 }
 
 
-GLfloat* VBO_ITEM::GetVertices()
+VBO_VERTEX* VBO_ITEM::GetVertices()
 {
     if( m_isDirty )
-        prepareFinal();
+        Finish();
 
-    return m_vertices;
+    return m_container->GetVertices( this );
 }
 
 
 void VBO_ITEM::ChangeColor( const COLOR4D& aColor )
 {
+    wxASSERT_MSG( false, wxT( "This was not tested yet" ) );
+
     if( m_isDirty )
-        prepareFinal();
+        Finish();
 
     // Point to color of vertices
-    GLfloat* vertexPtr = m_vertices + ColorOffset;
+    VBO_VERTEX* vertexPtr = GetVertices();
     const GLfloat newColor[] = { aColor.r, aColor.g, aColor.b, aColor.a };
 
-    for( int i = 0; i < m_size; ++i )
+    for( unsigned int i = 0; i < m_size; ++i )
     {
-        memcpy( vertexPtr, newColor, ColorByteSize );
+        memcpy( &vertexPtr->r, newColor, ColorByteSize );
 
         // Move on to the next vertex
         vertexPtr++;
@@ -135,38 +126,10 @@ void VBO_ITEM::ChangeColor( const COLOR4D& aColor )
 }
 
 
-void VBO_ITEM::useNewBlock()
+void VBO_ITEM::Finish()
 {
-    VBO_VERTEX* newVertBlock = new VBO_VERTEX[BLOCK_SIZE];
-
-    m_vertPtr = newVertBlock;
-    m_vertBlocks.push_back( newVertBlock );
-
-    m_spaceLeft = BLOCK_SIZE;
-}
-
-
-void VBO_ITEM::prepareFinal()
-{
-    if( m_vertices )
-        delete m_vertices;
-
-    // Allocate memory that would store all of vertices
-    m_vertices = new GLfloat[m_size * VertStride];
-    // Set the pointer that will move along the buffer
-    GLfloat* vertPtr = m_vertices;
-
-    // Copy blocks of vertices one after another to m_vertices
-    std::list<VBO_VERTEX*>::const_iterator v_it;
-    for( v_it = m_vertBlocks.begin(); *v_it != m_vertBlocks.back(); ++v_it )
-    {
-        memcpy( vertPtr, *v_it, BLOCK_SIZE * VertByteSize );
-        delete[] *v_it;
-        vertPtr += ( BLOCK_SIZE * VertStride );
-    }
-
-    // In the last block we need to copy only used vertices
-    memcpy( vertPtr, *v_it, ( BLOCK_SIZE - m_spaceLeft ) * VertByteSize );
+    // The unknown-sized item has just ended, so we need to inform the container about it
+    m_container->EndItem();
 
     m_isDirty = false;
 }

common/gal/stroke_font.cpp

@@ -66,8 +66,8 @@ bool STROKE_FONT::LoadNewStrokeFont( const char* const aNewStrokeFont[], int aNe
 
         while( aNewStrokeFont[j][i] )
         {
-            VECTOR2D    point;
-            char        coordinate[2];
+            VECTOR2D    point( 0.0, 0.0 );
+            char        coordinate[2] = { 0, };
 
             for( int k = 0; k < 2; k++ )
             {

common/painter.cpp

@@ -79,6 +79,7 @@ PAINTER::PAINTER( GAL* aGal ) :
 PAINTER::~PAINTER()
 {
     delete m_stroke_font;
+    delete m_settings;
 }
 
 

common/view/view.cpp

@@ -473,6 +473,11 @@ void VIEW::Clear()
 
         l->items->RemoveAll();
     }
+
+    if( m_useGroups )
+    {
+        m_gal->ClearCache();
+    }
 }
 
 

common/view/view_item.cpp

@@ -111,7 +111,7 @@ void VIEW_ITEM::setGroup( int aLayer, int aId )
     if( m_groupsSize > 0 )
     {
         std::copy( m_groups, m_groups + m_groupsSize, newGroups );
-        delete m_groups;
+        delete[] m_groups;
     }
 
     m_groups = newGroups;
@@ -123,7 +123,7 @@ void VIEW_ITEM::deleteGroups()
 {
     if( m_groupsSize > 0 )
     {
-        delete m_groups;
+        delete[] m_groups;
         m_groupsSize = 0;
     }
 }

include/gal/cairo/cairo_gal.h

@@ -212,6 +212,9 @@ public:
     /// @copydoc GAL::DeleteGroup()
     virtual void DeleteGroup( int aGroupNumber );
 
+    /// @copydoc GAL::ClearCache()
+    virtual void ClearCache();
+
     // --------------------------------------------------------
     // Handling the world <-> screen transformation
     // --------------------------------------------------------

include/gal/graphics_abstraction_layer.h

@@ -370,6 +370,11 @@ public:
      */
     virtual void DeleteGroup( int aGroupNumber ) = 0;
 
+    /**
+     * @brief Delete all data created during caching of graphic items.
+     */
+    virtual void ClearCache() = 0;
+
     // --------------------------------------------------------
     // Handling the world <-> screen transformation
     // --------------------------------------------------------

include/gal/opengl/opengl_gal.h

@@ -35,6 +35,8 @@
 
 // OpenGL mathematics library
 #define GLM_FORCE_RADIANS
+#include <gal/opengl/glm/gtc/matrix_transform.hpp>
+
 #include <gal/opengl/vbo_item.h>
 #include <gal/opengl/shader.h>
 
@@ -56,7 +58,7 @@
 namespace KiGfx
 {
 class SHADER;
-class VBO_ITEM;
+class VBO_CONTAINER;
 
 /**
  * @brief Class OpenGL_GAL is the OpenGL implementation of the Graphics Abstraction Layer.
@@ -236,6 +238,9 @@ public:
     /// @copydoc GAL::DeleteGroup()
     virtual void DeleteGroup( int aGroupNumber );
 
+    /// @copydoc GAL::ClearCache()
+    virtual void ClearCache();
+
     // --------------------------------------------------------
     // Handling the world <-> screen transformation
     // --------------------------------------------------------
@@ -315,6 +320,13 @@ public:
         shaderPath = aPath;
     }
 
+    ///< Parameters passed to the GLU tesselator
+    typedef struct
+    {
+        VBO_ITEM* vboItem;                        ///< VBO_ITEM for storing new vertices
+        std::vector<GLdouble*>& intersectPoints;  ///< Intersect points, that have to be freed
+    } TessParams;
+
 protected:
     virtual void DrawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
 
@@ -336,20 +348,19 @@ private:
     wxEvtHandler*   mouseListener;
     wxEvtHandler*   paintListener;
 
-    // Display lists
-    GLuint                displayListsArcs;       ///< Arc display list
-    VBO_ITEM              verticesArc;
+    // Display lists (used in shaderless mode)
+    VBO_CONTAINER*        precomputedContainer;   ///< Container for storing display lists
     GLuint                displayListCircle;      ///< Circle display list
-    VBO_ITEM              verticesCircle;
+    VBO_ITEM*             verticesCircle;
     GLuint                displayListSemiCircle;  ///< Semi circle display list
-    VBO_ITEM              verticesSemiCircle;
+    VBO_ITEM*             verticesSemiCircle;
 
     // Vertex buffer objects related fields
     std::deque<VBO_ITEM*> vboItems;               ///< Stores informations about VBO objects
     VBO_ITEM*             curVboItem;             ///< Currently used VBO_ITEM (for grouping)
-    GLuint                curVboVertId;           ///< Currently used vertices VBO handle
-    GLuint                curVboIndId;            ///< Currently used indices VBO handle
-    int                   vboSize;                ///< Amount of vertices stored in VBO
+    VBO_CONTAINER*        vboContainer;           ///< Container for storing VBO_ITEMs
+    GLuint                vboVertices;            ///< Currently used vertices VBO handle
+    GLuint                vboIndices;             ///< Currently used indices VBO handle
     bool                  vboNeedsUpdate;         ///< Flag indicating if VBO should be rebuilt
     glm::mat4             transform;              ///< Current transformation matrix
     std::stack<glm::mat4> transformStack;         ///< Stack of transformation matrices
@@ -362,6 +373,7 @@ private:
 
     // Polygon tesselation
     GLUtesselator*        tesselator;             ///< Pointer to the tesselator
+    std::vector<GLdouble*> tessIntersects;        ///< Storage of intersecting points
 
     // Shader
     // Possible types of shaders
@@ -519,12 +531,20 @@ private:
      * @brief Starts drawing in immediate mode or does nothing if an item's caching has started.
      * @param aMode specifies the primitive or primitives that will be created.
      */
-    inline void begin( GLenum aMode );
+    inline void begin( GLenum aMode )
+    {
+        if( !isGrouping )
+            glBegin( aMode );
+    }
 
     /**
      * @brief Ends drawing in immediate mode or does nothing if an item's caching has started.
      */
-    inline void end();
+    inline void end()
+    {
+        if( !isGrouping )
+            glEnd();
+    }
 
     /**
      * @brief Adds vertex to the current item or draws it in immediate mode.
@@ -532,7 +552,19 @@ private:
      * @param aY is Y coordinate.
      * @param aZ is Z coordinate.
      */
-    inline void vertex3( double aX, double aY, double aZ );
+    inline void vertex3( double aX, double aY, double aZ )
+    {
+        if( isGrouping )
+        {
+            // New vertex coordinates for VBO
+            VBO_VERTEX vertex( aX, aY, aZ );
+            curVboItem->PushVertex( &vertex );
+        }
+        else
+        {
+            glVertex3d( aX, aY, aZ );
+        }
+    }
 
     /**
      * @brief Function that replaces glTranslate and behaves according to isGrouping variable.
@@ -543,7 +575,17 @@ private:
      * @param aY is translation in Y axis direction.
      * @param aZ is translation in Z axis direction.
      */
-    inline void translate3( double aX, double aY, double aZ );
+    inline void translate3( double aX, double aY, double aZ )
+    {
+        if( isGrouping )
+        {
+            transform = glm::translate( transform, glm::vec3( aX, aY, aZ ) );
+        }
+        else
+        {
+            glTranslated( aX, aY, aZ );
+        }
+    }
 
     /**
      * @brief Function that replaces glColor and behaves according to isGrouping variable.
@@ -555,7 +597,17 @@ private:
      * @param aB is blue component.
      * @param aA is alpha component.
      */
-    inline void color4( double aRed, double aGreen, double aBlue, double aAlpha );
+    inline void color4( double aRed, double aGreen, double aBlue, double aAlpha )
+    {
+        if( isGrouping )
+        {
+            curVboItem->UseColor( COLOR4D( aRed, aGreen, aBlue, aAlpha ) );
+        }
+        else
+        {
+            glColor4d( aRed, aGreen, aBlue, aAlpha );
+        }
+    }
 
     /**
      * @brief Function that replaces glColor and behaves according to isGrouping variable.
@@ -564,7 +616,17 @@ private:
      *
      * @param aColor is the new color.
      */
-    inline void color4( const COLOR4D& aColor );
+    inline void color4( const COLOR4D& aColor )
+    {
+        if( isGrouping )
+        {
+            curVboItem->UseColor( aColor );
+        }
+        else
+        {
+            glColor4d( aColor.r, aColor.g, aColor.b, aColor.a);
+        }
+    }
 
     /**
      * @brief Function that sets shader and its parameters for the currently used VBO_ITEM.

include/gal/opengl/vbo_container.h

+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2013 CERN
+ * @author Maciej Suminski <maciej.suminski@cern.ch>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file vbo_container.h
+ * @brief Class to store VBO_ITEMs.
+ */
+
+#ifndef VBO_CONTAINER_H_
+#define VBO_CONTAINER_H_
+
+#include <GL/gl.h>
+#include <map>
+#include <wx/log.h>
+
+namespace KiGfx
+{
+class VBO_ITEM;
+typedef struct VBO_VERTEX VBO_VERTEX;
+
+class VBO_CONTAINER
+{
+public:
+    VBO_CONTAINER( int aSize = 1048576 );
+    ~VBO_CONTAINER();
+
+    ///< Maps size of free memory chunks to their offsets
+    typedef std::pair<const unsigned int, unsigned int> Chunk;
+    typedef std::multimap<const unsigned int, unsigned int> FreeChunkMap;
+
+    ///< Maps size of reserved memory chunks to their owners (VBO_ITEMs)
+    typedef std::pair<VBO_ITEM* const, Chunk> ReservedChunk;
+    typedef std::multimap<VBO_ITEM* const, Chunk> ReservedChunkMap;
+
+    /**
+     * Function StartItem()
+     * Starts an unknown sized item. After calling the function it is possible to add vertices
+     * using function Add().
+     * @param aVboItem is the item that is going to store vertices in the container.
+     */
+    void StartItem( VBO_ITEM* aVboItem );
+
+    /**
+     * Function EndItem()
+     * Marks current item as finished and returns unused memory to the pool. StartItem() function
+     * has to be called first.
+     */
+    void EndItem();
+
+    /**
+     * Function Add()
+     * Stores given number of vertices in the container for the specific VBO_ITEM.
+     * @param aVboItem is the owner of the vertices.
+     * @param aVertex are vertices data to be stored.
+     * @param aSize is the number of vertices to be added.
+     */
+    void Add( VBO_ITEM* aVboItem, const VBO_VERTEX* aVertex, unsigned int aSize = 1 );
+
+    /**
+     * Function Free()
+     * Frees the chunk reserved by the aVboItem.
+     * @param aVboItem is the owner of the chunk to be freed.
+     */
+    inline void Free( VBO_ITEM* aVboItem )
+    {
+        ReservedChunkMap::iterator it = m_reservedChunks.find( aVboItem );
+        free( it );
+
+        // Dynamic memory freeing, there is no point in holding
+        // a large amount of memory when there is no use for it
+        if( m_freeSpace > ( m_currentSize / 2 ) )
+        {
+            resizeContainer( m_currentSize / 2 );
+        }
+    }
+
+    /**
+     * Function GetAllVertices()
+     * Returns all vertices stored in the container. It is especially useful for transferring
+     * data to the GPU memory.
+     */
+    VBO_VERTEX* GetAllVertices() const;
+
+    /**
+     * Function GetVertices()
+     * Returns vertices stored by the specific item.
+     * @aVboItem is the specific item.
+     */
+    VBO_VERTEX* GetVertices( const VBO_ITEM* aVboItem ) const;
+
+    /**
+     * Function GetSize()
+     * Returns amount of vertices currently stored in the container.
+     */
+    inline int GetSize() const
+    {
+        return m_currentSize;
+    }
+
+private:
+    ///< Stores size & offset of free chunks.
+    FreeChunkMap        m_freeChunks;
+    ///< Stores owners (VBO_ITEM*) of reserved chunks and their size & offset.
+    ReservedChunkMap    m_reservedChunks;
+
+    /**
+    * Function allocate()
+    * Finds an offset where the number of vertices can be stored in a continous space. If there is
+    * no such chunk, appropriate amount of memory is allocated first.
+    * @param aVboItem is the owner of vertices to be stored.
+    * @param aSize is the number of vertices to be stored.
+    */
+    unsigned int allocate( VBO_ITEM* aVboItem, unsigned int aSize );
+
+    /**
+     * Function getChunkSize()
+     * Returns size of the given chunk (works both for reserved and free chunks).
+     * @param aChunk is the chunk.
+     */
+    inline int getChunkSize( const Chunk& aChunk ) const
+    {
+        return aChunk.first;
+    }
+
+    inline int getChunkSize( const ReservedChunk& aChunk ) const
+    {
+        return aChunk.second.first;
+    }
+
+    /**
+     * Function getChunkOffset()
+     * Returns offset of the given chunk (works both for reserved and free chunks).
+     * @param aChunk is the chunk.
+     */
+    inline unsigned int getChunkOffset( const Chunk& aChunk ) const
+    {
+        return aChunk.second;
+    }
+
+    inline unsigned int getChunkOffset( const ReservedChunk& aChunk ) const
+    {
+        return aChunk.second.second;
+    }
+
+    /**
+     * Function getChunkOffset()
+     * Upadtes offset of the given chunk (works both for reserved and free chunks).
+     * !! IMPORTANT: it does not reallocate the chunk, it just changes its properties.
+     * @param aChunk is the chunk.
+     */
+    inline void setChunkOffset( Chunk& aChunk, unsigned int aOffset ) const
+    {
+        aChunk.second = aOffset;
+    }
+
+    inline void setChunkOffset( ReservedChunk& aChunk, unsigned int aOffset ) const
+    {
+        aChunk.second.second = aOffset;
+    }
+
+    /**
+     * Function getChunkVboItem()
+     * Returns owner of the given reserved chunk.
+     * @param aChunk is the chunk.
+     */
+    inline VBO_ITEM* getChunkVboItem( const ReservedChunk& aChunk ) const
+    {
+        return aChunk.first;
+    }
+
+    /**
+     * Function defragment()
+     * Removes empty spaces between chunks, so after that there is a long continous space
+     * for storing vertices at the and of the container.
+     * @return false in case of failure (eg. memory shortage)
+     */
+    bool defragment( VBO_VERTEX* aTarget = NULL );
+
+    /**
+     * Function resizeChunk()
+     * Changes size of the chunk that stores vertices of aVboItem.
+     * @param aVboItem is the item for which reserved space size should be changed.
+     * @param aNewSize is the new size for the aVboItem, expressed in vertices number.
+     */
+    void resizeChunk( VBO_ITEM* aVboItem, int aNewSize );
+
+    /**
+     * Function resizeContainer()
+     * Prepares a bigger container of a given size.
+     * @param aNewSize is the new size of container, expressed in vertices
+     * @return false in case of failure (eg. memory shortage)
+     */
+    bool resizeContainer( unsigned int aNewSize );
+
+    /**
+     * Function free()
+     * Frees the space described in aChunk and returns it to the free space pool.
+     * @param aChunk is a space to be freed.
+     */
+    void free( const ReservedChunkMap::iterator& aChunk );
+
+    ///< How many vertices we can store in the container
+    unsigned int m_freeSpace;
+
+    ///< How big is the current container, expressed in vertices
+    unsigned int m_currentSize;
+
+    ///< Actual storage memory
+    VBO_VERTEX* m_vertices;
+
+    ///< A flag saying if there is the item with an unknown size being added
+    bool itemStarted;
+
+    ///< Variables holding the state of the item currently being added
+    unsigned int itemSize, itemChunkSize;
+    VBO_ITEM* item;
+
+    /**
+     * Function getPowerOf2()
+     * Returns the nearest power of 2, bigger than aNumber.
+     * @param aNumber is the number for which we look for a bigger power of 2.
+     */
+    unsigned int getPowerOf2( unsigned int aNumber )
+    {
+        unsigned int power = 1;
+
+        while( power < aNumber && power )
+            power <<= 1;
+
+        return power;
+    }
+};
+} // namespace KiGfx
+
+#endif /* VBO_CONTAINER_H_ */

include/gal/opengl/vbo_item.h

@@ -36,8 +36,6 @@
 
 #include <cstddef>
 
-#include <list>
-
 namespace KiGfx
 {
 typedef struct VBO_VERTEX
@@ -45,12 +43,31 @@ typedef struct VBO_VERTEX
     GLfloat x, y, z;        // Coordinates
     GLfloat r, g, b, a;     // Color
     GLfloat shader[4];      // Shader type & params
+    GLfloat _padding;
+
+    VBO_VERTEX()
+    {}
+
+    VBO_VERTEX( const GLfloat aX, const GLfloat aY, const GLfloat aZ ) :
+        x( aX ), y( aY ), z( aZ )
+    {}
+
+    VBO_VERTEX( const GLfloat *aData ) :
+        x( aData[0] ), y( aData[1] ), z( aData[2] )
+    {}
+
+    operator GLfloat*()
+    {
+        return &x;
+    }
 } VBO_VERTEX;
 
+class VBO_CONTAINER;
+
 class VBO_ITEM
 {
 public:
-    VBO_ITEM();
+    VBO_ITEM( VBO_CONTAINER* aContainer );
     ~VBO_ITEM();
 
     /**
@@ -60,7 +77,7 @@ public:
      * @param aVertex is a vertex to be added.
      * @param aShader is an attribute for shader.
      */
-    void PushVertex( const GLfloat* aVertex );
+    void PushVertex( VBO_VERTEX* aVertex );
 
     /**
      * Function PushVertices()
@@ -71,14 +88,14 @@ public:
      * @param aSize is an amount of vertices to be added.
      * @param aShader is an attribute for shader.
      */
-    void PushVertices( const GLfloat* aVertices, GLuint aSize );
+    void PushVertices( VBO_VERTEX* aVertices, GLuint aSize );
 
     /**
      * Function GetVertices()
      * Returns a pointer to the array containing all vertices.
      * @return Pointer to vertices packed in format {X, Y, Z, R, G, B, A}.
      */
-    GLfloat* GetVertices();
+    VBO_VERTEX* GetVertices();
 
 
     /**
@@ -86,7 +103,7 @@ public:
      * Returns information about number of vertices stored.
      * @param Amount of vertices.
      */
-    inline int GetSize() const
+    inline unsigned int GetSize() const
     {
         return m_size;
     }
@@ -96,7 +113,7 @@ public:
      * Sets data offset in the VBO.
      * @param aOffset is the offset expressed as a number of vertices.
      */
-    void SetOffset( int aOffset )
+    void SetOffset( unsigned int aOffset )
     {
         m_offset = aOffset;
     }
@@ -106,7 +123,7 @@ public:
      * Returns data offset in the VBO.
      * @return Data offset expressed as a number of vertices.
      */
-    inline int GetOffset() const
+    inline unsigned int GetOffset() const
     {
         return m_offset;
     }
@@ -156,16 +173,8 @@ public:
         }
     }
 
-
-    inline void FreeVerticesData()
-    {
-        if( m_vertices && !m_isDirty )
-        {
-            delete[] m_vertices;
-            m_vertices = NULL;
-        }
-    }
-
+    ///< Informs the container that there will be no more vertices for the current VBO_ITEM
+    void Finish();
 
     ///< Data organization information for vertices {X,Y,Z,R,G,B,A} (@see VBO_VERTEX).
     static const int VertByteSize       = sizeof(VBO_VERTEX);
@@ -191,28 +200,12 @@ public:
     static const int IndByteSize        = sizeof(GLuint);
 
 private:
-    ///< Contains vertices coordinates and colors.
-    ///< Packed by 7 floats for each vertex: {X, Y, Z, R, G, B, A}
-    GLfloat*                m_vertices;
-
-    ///< Lists of data blocks storing vertices
-    std::list<VBO_VERTEX*>  m_vertBlocks;
-
-    ///< Pointers to current blocks that should be used for storing data
-    VBO_VERTEX*             m_vertPtr;
-
-    ///< How many vertices can be stored in the current buffer
-    int                     m_spaceLeft;
-    ///< Number of vertices stored in a single block
-    static const int        BLOCK_SIZE = 256;
-    ///< Creates a new block for storing vertices data
-    void                    useNewBlock();
-    ///< Prepares a continuous block of data that can be copied to graphics card buffer.
-    void                    prepareFinal();
-
-    ///< Offset and size of data in VBO.
-    int                     m_offset;
-    int                     m_size;
+    ///< Offset and size of data stored in the VBO_CONTAINER.
+    unsigned int        m_offset;
+    unsigned int        m_size;
+
+    ///< Storage for vertices.
+    VBO_CONTAINER*      m_container;
 
     ///< Color used for new vertices pushed.
     GLfloat             m_color[ColorStride];

include/view/view_item.h

@@ -68,7 +68,7 @@ public:
         ALL = 0xff
     };
 
-    VIEW_ITEM() : m_view( NULL ), m_viewVisible( true ), m_groupsSize( 0 ) {}
+    VIEW_ITEM() : m_view( NULL ), m_viewVisible( true ), m_groups( NULL ), m_groupsSize( 0 ) {}
 
     /**
      * Destructor. For dynamic views, removes the item from the view.
@@ -76,6 +76,7 @@ public:
     virtual ~VIEW_ITEM()
     {
         ViewRelease();
+        delete[] m_groups;
     };
 
     /**