Added a VertexBuffer implementation to all Drawables that were rendered via VertexArrays.

include/SFML/Graphics/Shape.hpp

@@ -32,6 +32,7 @@
 #include <SFML/Graphics/Drawable.hpp>
 #include <SFML/Graphics/Transformable.hpp>
 #include <SFML/Graphics/VertexArray.hpp>
+#include <SFML/Graphics/VertexBuffer.hpp>
 #include <SFML/System/Vector2.hpp>
 
 
@@ -312,6 +313,8 @@ private:
     float          m_outlineThickness;      ///< Thickness of the shape's outline
     VertexArray    m_vertices;              ///< Vertex array containing the fill geometry
     VertexArray    m_outlineVertices;       ///< Vertex array containing the outline geometry
+    VertexBuffer   m_verticesBuffer;        ///< Vertex buffer containing the fill geometry
+    VertexBuffer   m_outlineVerticesBuffer; ///< Vertex buffer containing the outline geometry
     FloatRect      m_insideBounds;          ///< Bounding rectangle of the inside (fill)
     FloatRect      m_bounds;                ///< Bounding rectangle of the whole shape (outline + fill)
 };

include/SFML/Graphics/Sprite.hpp

@@ -33,6 +33,7 @@
 #include <SFML/Graphics/Transformable.hpp>
 #include <SFML/Graphics/Vertex.hpp>
 #include <SFML/Graphics/Rect.hpp>
+#include <SFML/Graphics/VertexBuffer.hpp>
 
 
 namespace sf
@@ -216,6 +217,7 @@ private:
     // Member data
     ////////////////////////////////////////////////////////////
     Vertex         m_vertices[4];    ///< Vertices defining the sprite's geometry
+    VertexBuffer   m_verticesBuffer; ///< Vertex buffer containing the sprite's geometry
     const Texture* m_texture;        ///< Texture of the sprite
     IntRect        m_textureRect;    ///< Rectangle defining the area of the source texture to display
 };

include/SFML/Graphics/Text.hpp

@@ -34,6 +34,7 @@
 #include <SFML/Graphics/Font.hpp>
 #include <SFML/Graphics/Rect.hpp>
 #include <SFML/Graphics/VertexArray.hpp>
+#include <SFML/Graphics/VertexBuffer.hpp>
 #include <SFML/System/String.hpp>
 #include <string>
 #include <vector>
@@ -446,6 +447,8 @@ private:
     float                m_outlineThickness;      ///< Thickness of the text's outline
     mutable VertexArray  m_vertices;              ///< Vertex array containing the fill geometry
     mutable VertexArray  m_outlineVertices;       ///< Vertex array containing the outline geometry
+    mutable VertexBuffer m_verticesBuffer;        ///< Vertex buffer containing the fill geometry
+    mutable VertexBuffer m_outlineVerticesBuffer; ///< Vertex buffer containing the outline geometry
     mutable FloatRect    m_bounds;                ///< Bounding rectangle of the text (in local coordinates)
     mutable bool         m_geometryNeedUpdate;    ///< Does the geometry need to be recomputed?
     mutable Uint64       m_fontTextureId;         ///< The font texture id

src/SFML/Graphics/Shape.cpp

@@ -87,6 +87,10 @@ void Shape::setTextureRect(const IntRect& rect)
 {
     m_textureRect = rect;
     updateTexCoords();
+
+    // Update the vertex buffers if they are being used
+    if (m_verticesBuffer.getVertexCount())
+        m_verticesBuffer.update(&m_vertices[0]);
 }
 
 
@@ -102,6 +106,10 @@ void Shape::setFillColor(const Color& color)
 {
     m_fillColor = color;
     updateFillColors();
+
+    // Update the vertex buffers if they are being used
+    if (m_verticesBuffer.getVertexCount())
+        m_verticesBuffer.update(&m_vertices[0]);
 }
 
 
@@ -117,6 +125,10 @@ void Shape::setOutlineColor(const Color& color)
 {
     m_outlineColor = color;
     updateOutlineColors();
+
+    // Update the vertex buffers if they are being used
+    if (m_outlineVerticesBuffer.getVertexCount())
+        m_outlineVerticesBuffer.update(&m_outlineVertices[0]);
 }
 
 
@@ -162,9 +174,11 @@ m_texture         (NULL),
 m_textureRect          (),
 m_fillColor            (255, 255, 255),
 m_outlineColor         (255, 255, 255),
-m_outlineThickness(0),
+m_outlineThickness     (0),
 m_vertices             (TriangleFan),
 m_outlineVertices      (TriangleStrip),
+m_verticesBuffer       (TriangleFan, VertexBuffer::Static),
+m_outlineVerticesBuffer(TriangleStrip, VertexBuffer::Static),
 m_insideBounds         (),
 m_bounds               ()
 {
@@ -180,6 +194,16 @@ void Shape::update()
     {
         m_vertices.resize(0);
         m_outlineVertices.resize(0);
+
+        if (VertexBuffer::isAvailable())
+        {
+            if (m_verticesBuffer.getVertexCount())
+                m_verticesBuffer.create(0);
+
+            if (m_outlineVerticesBuffer.getVertexCount())
+                m_outlineVerticesBuffer.create(0);
+        }
+
         return;
     }
 
@@ -206,6 +230,21 @@ void Shape::update()
 
     // Outline
     updateOutline();
+
+    // Update the vertex buffers if they are being used
+    if (VertexBuffer::isAvailable())
+    {
+        if (m_verticesBuffer.getVertexCount() != m_vertices.getVertexCount())
+            m_verticesBuffer.create(m_vertices.getVertexCount());
+
+        m_verticesBuffer.update(&m_vertices[0]);
+
+        if (m_outlineVerticesBuffer.getVertexCount() != m_outlineVertices.getVertexCount())
+            m_outlineVerticesBuffer.create(m_outlineVertices.getVertexCount());
+
+        if (m_outlineVertices.getVertexCount())
+            m_outlineVerticesBuffer.update(&m_outlineVertices[0]);
+    }
 }
 
 
@@ -216,14 +255,30 @@ void Shape::draw(RenderTarget& target, RenderStates states) const
 
     // Render the inside
     states.texture = m_texture;
+
+    if (VertexBuffer::isAvailable())
+    {
+        target.draw(m_verticesBuffer, states);
+    }
+    else
+    {
         target.draw(m_vertices, states);
+    }
 
     // Render the outline
     if (m_outlineThickness != 0)
     {
         states.texture = NULL;
+
+        if (VertexBuffer::isAvailable())
+        {
+            target.draw(m_outlineVerticesBuffer, states);
+        }
+        else
+        {
             target.draw(m_outlineVertices, states);
         }
+    }
 }
 
 

src/SFML/Graphics/Sprite.cpp

@@ -35,26 +35,37 @@ namespace sf
 {
 ////////////////////////////////////////////////////////////
 Sprite::Sprite() :
+m_verticesBuffer(TrianglesStrip, VertexBuffer::Stream),
 m_texture       (NULL),
-m_textureRect()
+m_textureRect   ()
 {
+    if (VertexBuffer::isAvailable())
+        m_verticesBuffer.create(4);
 }
 
 
 ////////////////////////////////////////////////////////////
 Sprite::Sprite(const Texture& texture) :
+m_verticesBuffer(TrianglesStrip, VertexBuffer::Stream),
 m_texture       (NULL),
-m_textureRect()
+m_textureRect   ()
 {
+    if (VertexBuffer::isAvailable())
+        m_verticesBuffer.create(4);
+
     setTexture(texture);
 }
 
 
 ////////////////////////////////////////////////////////////
 Sprite::Sprite(const Texture& texture, const IntRect& rectangle) :
+m_verticesBuffer(TrianglesStrip, VertexBuffer::Stream),
 m_texture       (NULL),
-m_textureRect()
+m_textureRect   ()
 {
+    if (VertexBuffer::isAvailable())
+        m_verticesBuffer.create(4);
+
     setTexture(texture);
     setTextureRect(rectangle);
 }
@@ -80,6 +91,10 @@ void Sprite::setTextureRect(const IntRect& rectangle)
         m_textureRect = rectangle;
         updatePositions();
         updateTexCoords();
+
+        // Update the vertex buffer if it is being used
+        if (VertexBuffer::isAvailable())
+            m_verticesBuffer.update(m_vertices);
     }
 }
 
@@ -92,6 +107,10 @@ void Sprite::setColor(const Color& color)
     m_vertices[1].color = color;
     m_vertices[2].color = color;
     m_vertices[3].color = color;
+
+    // Update the vertex buffer if it is being used
+    if (VertexBuffer::isAvailable())
+        m_verticesBuffer.update(m_vertices);
 }
 
 
@@ -140,8 +159,16 @@ void Sprite::draw(RenderTarget& target, RenderStates states) const
     {
         states.transform *= getTransform();
         states.texture = m_texture;
+
+        if (VertexBuffer::isAvailable())
+        {
+            target.draw(m_verticesBuffer, states);
+        }
+        else
+        {
             target.draw(m_vertices, 4, TriangleStrip, states);
         }
+    }
 }
 
 

src/SFML/Graphics/Text.cpp

@@ -79,7 +79,7 @@ Text::Text() :
 m_string               (),
 m_font                 (NULL),
 m_characterSize        (30),
-m_letterSpacingFactor(1.f),
+m_letterSpacingFactor  (1.f),
 m_lineSpacingFactor    (1.f),
 m_style                (Regular),
 m_fillColor            (255, 255, 255),
@@ -87,6 +87,8 @@ m_outlineColor       (0, 0, 0),
 m_outlineThickness     (0),
 m_vertices             (Triangles),
 m_outlineVertices      (Triangles),
+m_verticesBuffer       (Triangles, VertexBuffer::Static),
+m_outlineVerticesBuffer(Triangles, VertexBuffer::Static),
 m_bounds               (),
 m_geometryNeedUpdate   (false),
 m_fontTextureId        (0)
@@ -100,7 +102,7 @@ Text::Text(const String& string, const Font& font, unsigned int characterSize) :
 m_string               (string),
 m_font                 (&font),
 m_characterSize        (characterSize),
-m_letterSpacingFactor(1.f),
+m_letterSpacingFactor  (1.f),
 m_lineSpacingFactor    (1.f),
 m_style                (Regular),
 m_fillColor            (255, 255, 255),
@@ -108,6 +110,8 @@ m_outlineColor       (0, 0, 0),
 m_outlineThickness     (0),
 m_vertices             (Triangles),
 m_outlineVertices      (Triangles),
+m_verticesBuffer       (Triangles, VertexBuffer::Static),
+m_outlineVerticesBuffer(Triangles, VertexBuffer::Static),
 m_bounds               (),
 m_geometryNeedUpdate   (true),
 m_fontTextureId        (0)
@@ -202,6 +206,14 @@ void Text::setFillColor(const Color& color)
         {
             for (std::size_t i = 0; i < m_vertices.getVertexCount(); ++i)
                 m_vertices[i].color = m_fillColor;
+
+            if (VertexBuffer::isAvailable())
+            {
+                if (m_verticesBuffer.getVertexCount() != m_vertices.getVertexCount())
+                    m_verticesBuffer.create(m_vertices.getVertexCount());
+
+                m_verticesBuffer.update(&m_vertices[0]);
+            }
         }
     }
 }
@@ -220,6 +232,14 @@ void Text::setOutlineColor(const Color& color)
         {
             for (std::size_t i = 0; i < m_outlineVertices.getVertexCount(); ++i)
                 m_outlineVertices[i].color = m_outlineColor;
+
+            if (VertexBuffer::isAvailable())
+            {
+                if (m_outlineVerticesBuffer.getVertexCount() != m_outlineVertices.getVertexCount())
+                    m_outlineVerticesBuffer.create(m_outlineVertices.getVertexCount());
+
+                m_outlineVerticesBuffer.update(&m_outlineVertices[0]);
+            }
         }
     }
 }
@@ -382,10 +402,26 @@ void Text::draw(RenderTarget& target, RenderStates states) const
 
         // Only draw the outline if there is something to draw
         if (m_outlineThickness != 0)
+        {
+            if (VertexBuffer::isAvailable())
+            {
+                target.draw(m_outlineVerticesBuffer, states);
+            }
+            else
+            {
                 target.draw(m_outlineVertices, states);
+            }
+        }
 
+        if (VertexBuffer::isAvailable())
+        {
+            target.draw(m_verticesBuffer, states);
+        }
+        else
+        {
             target.draw(m_vertices, states);
         }
+    }
 }
 
 
@@ -408,11 +444,23 @@ void Text::ensureGeometryUpdate() const
     // Clear the previous geometry
     m_vertices.clear();
     m_outlineVertices.clear();
+
     m_bounds = FloatRect();
 
     // No text: nothing to draw
     if (m_string.isEmpty())
+    {
+        if (VertexBuffer::isAvailable())
+        {
+            if (m_verticesBuffer.getVertexCount())
+                m_verticesBuffer.create(0);
+
+            if (m_outlineVerticesBuffer.getVertexCount())
+                m_outlineVerticesBuffer.create(0);
+        }
+
         return;
+    }
 
     // Compute values related to the text style
     bool  isBold             = m_style & Bold;
@@ -562,6 +610,20 @@ void Text::ensureGeometryUpdate() const
     m_bounds.top = minY;
     m_bounds.width = maxX - minX;
     m_bounds.height = maxY - minY;
+
+    // Update the vertex buffer if it is being used
+    if (VertexBuffer::isAvailable())
+    {
+        if (m_verticesBuffer.getVertexCount() != m_vertices.getVertexCount())
+            m_verticesBuffer.create(m_vertices.getVertexCount());
+
+        m_verticesBuffer.update(&m_vertices[0]);
+
+        if (m_outlineVerticesBuffer.getVertexCount() != m_outlineVertices.getVertexCount())
+            m_outlineVerticesBuffer.create(m_outlineVertices.getVertexCount());
+
+        m_outlineVerticesBuffer.update(&m_outlineVertices[0]);
+    }
 }
 
 } // namespace sf