GPUBuffer is unnecessarily large

Signed-off-by: Paul Wisbey <p.wisbey@samsung.com>

diff --git a/dali/internal/render/dynamics/scene-graph-dynamics-debug-renderer.cpp b/dali/internal/render/dynamics/scene-graph-dynamics-debug-renderer.cpp
index 589c94f..1e49200 100644 (file)
--- a/dali/internal/render/dynamics/scene-graph-dynamics-debug-renderer.cpp
+++ b/dali/internal/render/dynamics/scene-graph-dynamics-debug-renderer.cpp
@@ -67,7 +67,7 @@ void DynamicsDebugRenderer::UpdateBuffer( const Integration::DynamicsDebugVertex
   {
     if( !mBuffer )
     {
-      mBuffer = new GpuBuffer(*mContext, GL_ARRAY_BUFFER, GL_STATIC_DRAW);
+      mBuffer = new GpuBuffer(*mContext, GpuBuffer::ARRAY_BUFFER, GpuBuffer::STATIC_DRAW);
     }
 
     if( vertices.size() > 1 )

diff --git a/dali/internal/render/gl-resources/gpu-buffer.cpp b/dali/internal/render/gl-resources/gpu-buffer.cpp
index 84a66e9..bdbc2f9 100644 (file)
--- a/dali/internal/render/gl-resources/gpu-buffer.cpp
+++ b/dali/internal/render/gl-resources/gpu-buffer.cpp
@@ -26,19 +26,82 @@ namespace Dali
 namespace Internal
 {
 
-GpuBuffer::GpuBuffer(Context& context,GLenum target,GLenum usage)
-:mCapacity(0),
- mSize(0),
- mContext(context),
- mBufferId(0),
- mBufferCreated(false),
- mTarget(target),
- mUsage(usage)
+namespace
+{
+/**
+ * Helper to get our type enum as GL enum
+ * @param type to convert
+ * @return the corresponding GL enum or -1
+ */
+inline GLenum TypeAsGlEnum( GpuBuffer::Target type )
+{
+  GLenum retval( -1 );
+  switch( type )
+  {
+    case GpuBuffer::ARRAY_BUFFER :
+    {
+      retval = GL_ARRAY_BUFFER;
+      break;
+    }
+    case GpuBuffer::ELEMENT_ARRAY_BUFFER :
+    {
+      retval = GL_ELEMENT_ARRAY_BUFFER;
+      break;
+    }
+    case GpuBuffer::TRANSFORM_FEEDBACK_BUFFER :
+    {
+      retval = GL_TRANSFORM_FEEDBACK_BUFFER;
+      break;
+    }
+  }
+  return retval;
+}
+
+/**
+ * Helper to get our drawmode enum as GL enum
+ * @param type to convert
+ * @return the corresponding GL enum or -1
+ */
+inline GLenum ModeAsGlEnum( GpuBuffer::Usage type )
+{
+  GLenum retval( -1 );
+  switch( type )
+  {
+    case GpuBuffer::STREAM_DRAW :
+    {
+      retval = GL_STREAM_DRAW;
+      break;
+    }
+    case GpuBuffer::STATIC_DRAW :
+    {
+      retval = GL_STATIC_DRAW;
+      break;
+    }
+    case GpuBuffer::DYNAMIC_DRAW :
+    {
+      retval = GL_DYNAMIC_DRAW;
+      break;
+    }
+  }
+  return retval;
+}
+
+}
+
+GpuBuffer::GpuBuffer( Context& context, Target target, Usage usage )
+: mContext( context ),
+  mCapacity( 0 ),
+  mSize( 0 ),
+  mBufferId( 0 ),
+  mTarget( target ),
+  mUsage( usage ),
+  mBufferCreated( false )
 {
   // the buffer is owned by the GPU so if we lose context, we lose the buffer
   // so we need to know when we lose context
   mContext.AddObserver(*this);
 }
+
 GpuBuffer::~GpuBuffer()
 {
   mContext.RemoveObserver(*this);
@@ -70,43 +133,41 @@ void GpuBuffer::UpdateDataBuffer(GLsizeiptr size,const GLvoid *data)
     // if the data will fit in the existing buffer, just update it
     if (size <= mCapacity )
     {
-      mContext.BufferSubData(mTarget,0, size, data);
+      mContext.BufferSubData( TypeAsGlEnum(mTarget), 0, size, data );
     }
     else
     {
       // create a new buffer of the larger size,
       // gl should automatically deallocate the old buffer
-      mContext.BufferData(mTarget, size, data, mUsage);
+      mContext.BufferData( TypeAsGlEnum(mTarget), size, data, ModeAsGlEnum( mUsage ) );
       mCapacity = size;
     }
   }
   else
   {
     // create the buffer
-    mContext.BufferData(mTarget, size, data, mUsage);
+    mContext.BufferData( TypeAsGlEnum(mTarget), size, data, ModeAsGlEnum( mUsage ) );
     mBufferCreated = true;
     mCapacity = size;
   }
 
   switch (mTarget)
   {
-    case GL_ARRAY_BUFFER:
+    case ARRAY_BUFFER:
     {
       mContext.BindArrayBuffer(0);
       break;
     }
-    case GL_ELEMENT_ARRAY_BUFFER:
+    case ELEMENT_ARRAY_BUFFER:
     {
       mContext.BindElementArrayBuffer(0);
       break;
     }
-    case GL_TRANSFORM_FEEDBACK_BUFFER:
+    case TRANSFORM_FEEDBACK_BUFFER:
     {
       mContext.BindTransformFeedbackBuffer(0);
       break;
     }
-    default:
-      DALI_ASSERT_DEBUG(false && "Unsupported type");
   }
 }
 
@@ -131,7 +192,7 @@ void GpuBuffer::GlContextToBeDestroyed()
   {
     // If the buffer is currently bound, then unbind it by setting the
     // currently bound buffer to zero.
-    if (mContext.GetCurrentBoundArrayBuffer(mTarget) == mBufferId)
+    if (mContext.GetCurrentBoundArrayBuffer( TypeAsGlEnum( mTarget ) ) == mBufferId)
     {
       BindNoChecks(0);
     }
@@ -161,7 +222,7 @@ void GpuBuffer::BindNoChecks(GLuint bufferId) const
   // and it caches both of them (as in it won't bind them if the
   // buffer id is already bound).
 
-  if (mTarget == GL_ARRAY_BUFFER)
+  if (mTarget == ARRAY_BUFFER)
   {
     mContext.BindArrayBuffer(bufferId);
   }

diff --git a/dali/internal/render/gl-resources/gpu-buffer.h b/dali/internal/render/gl-resources/gpu-buffer.h
index 62af3e0..ea37380 100644 (file)
--- a/dali/internal/render/gl-resources/gpu-buffer.h
+++ b/dali/internal/render/gl-resources/gpu-buffer.h
@@ -40,16 +40,37 @@ namespace Internal
  */
 class GpuBuffer : public ContextObserver
 {
+public:
+
+  /**
+   * Enum to encapsulate the GL buffer type. This is to avoid having to store a whole int for type
+   */
+  enum Target
+  {
+    ARRAY_BUFFER,             ///< GL_ARRAY_BUFFER
+    ELEMENT_ARRAY_BUFFER,     ///< GL_ELEMENT_ARRAY_BUFFER
+    TRANSFORM_FEEDBACK_BUFFER ///< GL_TRANSFORM_FEEDBACK_BUFFER
+  };
+
+  /**
+   * Enum to encapsulate the GL draw mode. This is to avoid having to store a whole int for mode
+   */
+  enum Usage
+  {
+    STREAM_DRAW, ///< GL_STREAM_DRAW
+    STATIC_DRAW, ///< GL_STATIC_DRAW
+    DYNAMIC_DRAW, ///< GL_DYNAMIC_DRAW
+  };
 
 public:
 
   /**
    * constructor
    * @param context drawing context
-   * @param target the type of buffer to create (GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER)
-   * @param usage how the buffer will be used (see GL_STATIC_DRAW)
+   * @param target the type of buffer to create @see Type
+   * @param usage how the buffer will be used @see DrawMode
    */
-  GpuBuffer(Context& context,GLenum target,GLenum usage);
+  GpuBuffer( Context& context, Target target, Usage usage );
 
   /**
    * Destructor
@@ -61,7 +82,6 @@ public:
    * Creates or updates a buffer object and binds it to the target.
    * @param size Specifies the size in bytes of the buffer object's new data store.
    * @param data pointer to the data to load
-   *
    */
   void UpdateDataBuffer(GLsizeiptr size,const GLvoid *data);
 
@@ -105,13 +125,17 @@ private:
    */
   void BindNoChecks(GLuint bufferId) const;
 
+private: // Data
+
+  Context&           mContext;             ///< dali drawing context
   GLsizeiptr         mCapacity;            ///< buffer capacity
   GLsizeiptr         mSize;                ///< buffer size
-  Context&           mContext;             ///< dali drawing context
   GLuint             mBufferId;            ///< buffer object name(id)
-  bool               mBufferCreated;       ///< whether buffer has been created
-  GLenum             mTarget;              ///< type of buffer (array/element)
-  GLenum             mUsage;               ///< how the buffer is used (read, read/write etc).
+
+  Target             mTarget:2;            ///< type of buffer (array/element), 2 bits are enough
+  Usage              mUsage:2;             ///< how the buffer is used (read, read/write etc), 2 bits are enough
+  bool               mBufferCreated:1;     ///< whether buffer has been created
+
 };
 
 } // namespace Internal

diff --git a/dali/internal/render/renderers/scene-graph-image-renderer.cpp b/dali/internal/render/renderers/scene-graph-image-renderer.cpp
index c590841..fd10090 100644 (file)
--- a/dali/internal/render/renderers/scene-graph-image-renderer.cpp
+++ b/dali/internal/render/renderers/scene-graph-image-renderer.cpp
@@ -317,7 +317,7 @@ void ImageRenderer::UpdateVertexBuffer( GLsizeiptr size, const GLvoid *data )
   // create/destroy if needed/not needed.
   if ( size && !mVertexBuffer )
   {
-    mVertexBuffer = new GpuBuffer( *mContext, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW );
+    mVertexBuffer = new GpuBuffer( *mContext, GpuBuffer::ARRAY_BUFFER, GpuBuffer::DYNAMIC_DRAW );
   }
   else if ( !size && mVertexBuffer )
   {
@@ -336,7 +336,7 @@ void ImageRenderer::UpdateIndexBuffer( GLsizeiptr size, const GLvoid *data )
   // create/destroy if needed/not needed.
   if ( size && !mIndexBuffer )
   {
-    mIndexBuffer = new GpuBuffer( *mContext, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW );
+    mIndexBuffer = new GpuBuffer( *mContext, GpuBuffer::ELEMENT_ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
   }
   else if ( !size && mIndexBuffer )
   {
@@ -784,14 +784,15 @@ void ImageRenderer::GenerateMeshIndices(GLushort* indices, int rectanglesX, int
 
 ImageRenderer::ImageRenderer( RenderDataProvider& dataprovider )
 : Renderer( dataprovider ),
+  mTexture( NULL ),
+  mBorder( 0.45, 0.45, 0.1, 0.1 ),
+  mPixelArea(),
+  mGeometrySize(),
+  mTextureId( 0 ),
   mMeshType( ImageRenderer::QUAD ),
   mIsMeshGenerated( false ),
   mBorderInPixels( false ),
-  mUsePixelArea( false ),
-  mGeometrySize(),
-  mBorder( 0.45, 0.45, 0.1, 0.1 ),
-  mTextureId( 0 ),
-  mTexture( NULL )
+  mUsePixelArea( false )
 {
 }
 

diff --git a/dali/internal/render/renderers/scene-graph-image-renderer.h b/dali/internal/render/renderers/scene-graph-image-renderer.h
index 8f72d1d..2eb6f54 100644 (file)
--- a/dali/internal/render/renderers/scene-graph-image-renderer.h
+++ b/dali/internal/render/renderers/scene-graph-image-renderer.h
@@ -190,21 +190,22 @@ private:
 
 private:
 
-  // flags
-  MeshType  mMeshType        : 3; // 4 values fits in 3 bits just fine
-  bool      mIsMeshGenerated : 1;
-  bool      mBorderInPixels  : 1;
-  bool      mUsePixelArea    : 1;
+  Texture*    mTexture;
+
+  OwnerPointer< GpuBuffer > mVertexBuffer;
+  OwnerPointer< GpuBuffer > mIndexBuffer;
 
-  Vector2   mGeometrySize;
   Vector4   mBorder;
   PixelArea mPixelArea;
+  Vector2   mGeometrySize;
 
   ResourceId  mTextureId;
-  Texture*    mTexture;
 
-  OwnerPointer< GpuBuffer > mVertexBuffer;
-  OwnerPointer< GpuBuffer > mIndexBuffer;
+  // flags
+  MeshType  mMeshType        : 3; // 4 values fits in 3 bits just fine
+  bool      mIsMeshGenerated : 1;
+  bool      mBorderInPixels  : 1;
+  bool      mUsePixelArea    : 1;
 
 };
 

diff --git a/dali/internal/render/renderers/scene-graph-text-renderer.cpp b/dali/internal/render/renderers/scene-graph-text-renderer.cpp
index b7e450a..38a5396 100644 (file)
--- a/dali/internal/render/renderers/scene-graph-text-renderer.cpp
+++ b/dali/internal/render/renderers/scene-graph-text-renderer.cpp
@@ -164,12 +164,12 @@ void TextRenderer::SetVertexData( TextVertexBuffer* vertexData )
 
     if ( !mVertexBuffer )
     {
-      mVertexBuffer = new GpuBuffer( *mContext, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW );
+      mVertexBuffer = new GpuBuffer( *mContext, GpuBuffer::ARRAY_BUFFER, GpuBuffer::DYNAMIC_DRAW );
     }
 
     if ( !mIndexBuffer )
     {
-      mIndexBuffer = new GpuBuffer( *mContext, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW );
+      mIndexBuffer = new GpuBuffer( *mContext, GpuBuffer::ELEMENT_ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
     }
 
     mVertexBuffer->UpdateDataBuffer( vertexData->mVertices.size() * sizeof(TextVertex2D), &vertexData->mVertices[0] );
@@ -501,9 +501,13 @@ void TextRenderer::DoRender( BufferIndex bufferIndex, const Matrix& modelViewMat
 
 TextRenderer::TextRenderer( RenderDataProvider& dataprovider )
 : Renderer( dataprovider ),
-  mTextureId( 0 ),
   mTexture( NULL ),
   mTextColor( NULL ),
+  mVertexBuffer(),
+  mIndexBuffer(),
+  mTextParameters(),
+  mInvTextSize(),
+  mTextureId( 0 ),
   mSmoothing( Dali::TextStyle::DEFAULT_SMOOTH_EDGE_DISTANCE_FIELD ),
   mPixelSize(0.0f)
 {

diff --git a/dali/internal/render/renderers/scene-graph-text-renderer.h b/dali/internal/render/renderers/scene-graph-text-renderer.h
index 89ad97d..7f2c7b6 100644 (file)
--- a/dali/internal/render/renderers/scene-graph-text-renderer.h
+++ b/dali/internal/render/renderers/scene-graph-text-renderer.h
@@ -170,15 +170,16 @@ private:
 
 private:
 
-  ResourceId  mTextureId;
-  Texture*    mTexture;
+  Texture*    mTexture;   ///< pointer to texture
+  Vector4*    mTextColor; ///< optional color
 
   OwnerPointer< GpuBuffer > mVertexBuffer;        ///< GPU Buffer containing Vertex coordinate (and texture coordinate) information
   OwnerPointer< GpuBuffer > mIndexBuffer;         ///< GPU Buffer containing Index information
-  Vector2 mInvTextSize;                           ///< 1.0 / (2D size of Vertices in vertex buffer (max extent - min extent))
-
   OwnerPointer< TextParameters > mTextParameters; ///< Optional text parameters
-  Vector4* mTextColor;
+
+  Vector2    mInvTextSize;                        ///< 1.0 / (2D size of Vertices in vertex buffer (max extent - min extent))
+  ResourceId mTextureId;
+
   float   mSmoothing;
   float   mPixelSize;
 

diff --git a/dali/internal/update/modeling/scene-graph-mesh.cpp b/dali/internal/update/modeling/scene-graph-mesh.cpp
index e371a59..1309fb3 100644 (file)
--- a/dali/internal/update/modeling/scene-graph-mesh.cpp
+++ b/dali/internal/update/modeling/scene-graph-mesh.cpp
@@ -114,7 +114,7 @@ void Mesh::UploadVertexData( Context& context, BufferIndex renderBufferIndex )
   DALI_ASSERT_DEBUG( !vertices.empty() );
   if ( !mVertexBuffer )
   {
-    mVertexBuffer = new GpuBuffer(context,GL_ARRAY_BUFFER,GL_STATIC_DRAW);
+    mVertexBuffer = new GpuBuffer(context,GpuBuffer::ARRAY_BUFFER,GpuBuffer::STATIC_DRAW);
   }
   DALI_ASSERT_DEBUG(mVertexBuffer);
 
@@ -128,7 +128,7 @@ void Mesh::UploadVertexData( Context& context, BufferIndex renderBufferIndex )
 
     if ( !mIndicesBuffer )
     {
-      mIndicesBuffer = new GpuBuffer(context,GL_ELEMENT_ARRAY_BUFFER,GL_STATIC_DRAW);
+      mIndicesBuffer = new GpuBuffer(context,GpuBuffer::ELEMENT_ARRAY_BUFFER,GpuBuffer::STATIC_DRAW);
     }
 
     mIndicesBuffer->UpdateDataBuffer( numberOfIndices * sizeof(GLushort), &(faces.at(0)) );