X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-geometry.cpp;h=03afcd7e2c780227570a1fcdde878ff93bd9655b;hb=b042388ebaef225c58c75e350d101ddda6f5f970;hp=0fc5c78a4e370647b2b38fa5a0152417072a26d8;hpb=65b9b6e1f7782b05be515416706cdc7d5536df5c;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/dali/internal/render/renderers/render-geometry.cpp b/dali/internal/render/renderers/render-geometry.cpp
index 0fc5c78..03afcd7 100644
--- a/dali/internal/render/renderers/render-geometry.cpp
+++ b/dali/internal/render/renderers/render-geometry.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
+// CLASS HEADER
 #include <dali/internal/render/renderers/render-geometry.h>
+
+// INTERNAL INCLUDES
 #include <dali/internal/common/buffer-index.h>
-#include <dali/internal/render/gl-resources/context.h>
-#include <dali/internal/render/gl-resources/gpu-buffer.h>
-#include <dali/internal/render/renderers/render-property-buffer.h>
+#include <dali/internal/render/renderers/render-vertex-buffer.h>
 #include <dali/internal/render/shaders/program.h>
 
 namespace Dali
@@ -27,119 +28,119 @@ namespace Internal
 {
 namespace Render
 {
-
+namespace
+{
+inline constexpr size_t GetSizeOfIndexFromIndexType(Dali::Graphics::Format graphicsFormat)
+{
+  switch(graphicsFormat)
+  {
+    case Dali::Graphics::Format::R16_UINT:
+    {
+      return sizeof(uint16_t);
+    }
+    case Dali::Graphics::Format::R32_UINT:
+    {
+      return sizeof(uint32_t);
+    }
+    default:
+    {
+      // TODO : Not implmeneted.
+      return sizeof(uint16_t);
+    }
+  }
+}
+} // unnamed namespace
 Geometry::Geometry()
 : mIndices(),
-  mIndexBuffer(NULL),
-  mGeometryType( Dali::Geometry::TRIANGLES ),
+  mIndexBuffer(nullptr),
+  mIndexType(Dali::Graphics::Format::R16_UINT),
+  mGeometryType(Dali::Geometry::TRIANGLES),
   mIndicesChanged(false),
-  mRequiresDepthTest(false ),
   mHasBeenUpdated(false),
   mAttributesChanged(true)
 {
 }
 
-Geometry::~Geometry()
-{
-}
+Geometry::~Geometry() = default;
 
-void Geometry::GlContextCreated( Context& context )
+void Geometry::AddVertexBuffer(Render::VertexBuffer* vertexBuffer)
 {
+  mVertexBuffers.PushBack(vertexBuffer);
+  mAttributesChanged = true;
 }
 
-void Geometry::GlContextDestroyed()
+const Vector<Render::VertexBuffer*>& Geometry::GetVertexBuffers() const
 {
+  return mVertexBuffers;
 }
 
-void Geometry::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
+void Geometry::SetIndexBuffer(Uint16ContainerType& indices)
 {
-  mVertexBuffers.PushBack( propertyBuffer );
-  mAttributesChanged = true;
+  mIndices.Swap(indices);
+  mIndicesChanged = true;
+  mIndexType      = Graphics::Format::R16_UINT;
 }
 
-void Geometry::SetIndexBuffer( Dali::Vector<unsigned short>& indices )
+void Geometry::SetIndexBuffer(Uint32ContainerType& indices)
 {
-  mIndices.Swap( indices );
+  // mIndices type is not matched with indices. Copy memory hardly.
+  mIndices.ResizeUninitialized(indices.Count() * 2);
+  memcpy(mIndices.Begin(), indices.Begin(), indices.Count() * sizeof(uint32_t));
   mIndicesChanged = true;
+  mIndexType      = Graphics::Format::R32_UINT;
 }
 
-void Geometry::RemovePropertyBuffer( const Render::PropertyBuffer* propertyBuffer )
+void Geometry::RemoveVertexBuffer(const Render::VertexBuffer* vertexBuffer)
 {
-  size_t bufferCount = mVertexBuffers.Size();
-  for( size_t i(0); i<bufferCount; ++i )
+  const auto&& end = mVertexBuffers.End();
+  // @todo if this buffer is the only instance buffer, reduce instance count to 1.
+  for(auto&& iter = mVertexBuffers.Begin(); iter != end; ++iter)
   {
-    if( propertyBuffer == mVertexBuffers[i] )
+    if(*iter == vertexBuffer)
     {
-      //This will delete the gpu buffer associated to the RenderPropertyBuffer if there is one
-      mVertexBuffers.Remove( mVertexBuffers.Begin()+i);
+      //This will delete the gpu buffer associated to the RenderVertexBuffer if there is one
+      mVertexBuffers.Remove(iter);
       mAttributesChanged = true;
       break;
     }
   }
 }
 
-void Geometry::GetAttributeLocationFromProgram( Vector<GLint>& attributeLocation, Program& program, BufferIndex bufferIndex ) const
-{
-  attributeLocation.Clear();
-
-  for( size_t i(0); i< mVertexBuffers.Size(); ++i )
-  {
-    unsigned int attributeCount = mVertexBuffers[i]->GetAttributeCount();
-    for( unsigned int j = 0; j < attributeCount; ++j )
-    {
-      const std::string& attributeName = mVertexBuffers[i]->GetAttributeName( j );
-      unsigned int index = program.RegisterCustomAttribute( attributeName );
-      GLint location = program.GetCustomAttributeLocation( index );
-
-      if( -1 == location )
-      {
-        DALI_LOG_WARNING( "Attribute not found in the shader: %s\n", attributeName.c_str() );
-      }
-
-      attributeLocation.PushBack( location );
-    }
-  }
-}
-
 void Geometry::OnRenderFinished()
 {
-  mHasBeenUpdated = false;
+  mHasBeenUpdated    = false;
   mAttributesChanged = false;
 }
 
-void Geometry::UploadAndDraw(
-    Context& context,
-    BufferIndex bufferIndex,
-    Vector<GLint>& attributeLocation,
-    size_t elementBufferOffset,
-    size_t elementBufferCount )
+void Geometry::Upload(Graphics::Controller& graphicsController)
 {
-  if( !mHasBeenUpdated )
+  if(!mHasBeenUpdated)
   {
     // Update buffers
-    if( mIndicesChanged )
+    if(mIndicesChanged)
     {
-      if( mIndices.Empty() )
+      if(mIndices.Empty())
       {
-        mIndexBuffer = NULL;
+        mIndexBuffer = nullptr;
       }
       else
       {
-        if ( mIndexBuffer == NULL )
+        if(mIndexBuffer == nullptr)
         {
-          mIndexBuffer = new GpuBuffer( context );
+          // Currently we are unable to reuse index buffer so the write policy is to preserve current content
+          mIndexBuffer = new GpuBuffer(graphicsController, 0 | Graphics::BufferUsage::INDEX_BUFFER, GpuBuffer::WritePolicy::RETAIN);
         }
 
-        std::size_t bufferSize =  sizeof( unsigned short ) * mIndices.Size();
-        mIndexBuffer->UpdateDataBuffer( bufferSize, &mIndices[0], GpuBuffer::STATIC_DRAW, GpuBuffer::ELEMENT_ARRAY_BUFFER );
+        uint32_t bufferSize = static_cast<uint32_t>(sizeof(uint16_t) * mIndices.Size());
+        mIndexBuffer->UpdateDataBuffer(graphicsController, bufferSize, &mIndices[0]);
       }
 
       mIndicesChanged = false;
     }
 
-    for( unsigned int i = 0; i < mVertexBuffers.Count(); ++i )
+    for(auto&& buffer : mVertexBuffers)
     {
-      if( !mVertexBuffers[i]->Update( context ) )
+      if(!buffer->Update(graphicsController))
       {
         //Vertex buffer is not ready ( Size, data or format has not been specified yet )
         return;
@@ -148,107 +149,146 @@ void Geometry::UploadAndDraw(
 
     mHasBeenUpdated = true;
   }
+}
 
+bool Geometry::BindVertexAttributes(Graphics::CommandBuffer& commandBuffer)
+{
   //Bind buffers to attribute locations
-  unsigned int base = 0u;
-  size_t vertexBufferCount(mVertexBuffers.Count());
-  for( unsigned int i = 0; i < vertexBufferCount; ++i )
+  const auto vertexBufferCount = static_cast<uint32_t>(mVertexBuffers.Count());
+
+  std::vector<const Graphics::Buffer*> buffers;
+  std::vector<uint32_t>                offsets;
+
+  for(uint32_t i = 0; i < vertexBufferCount; ++i)
+  {
+    if(mVertexBuffers[i]->GetDivisor() > 0)
+    {
+      mInstanceCount = mVertexBuffers[i]->GetElementCount();
+    }
+
+    const GpuBuffer* gpuBuffer = mVertexBuffers[i]->GetGpuBuffer();
+    if(gpuBuffer)
+    {
+      const Graphics::Buffer* buffer = gpuBuffer->GetGraphicsObject();
+
+      if(buffer)
+      {
+        buffers.push_back(buffer);
+        offsets.push_back(0u);
+      }
+    }
+    //@todo Figure out why this is being drawn without geometry having been uploaded
+  }
+  if(buffers.empty())
   {
-    mVertexBuffers[i]->BindBuffer( GpuBuffer::ARRAY_BUFFER );
-    base += mVertexBuffers[i]->EnableVertexAttributes( context, attributeLocation, base );
+    return false;
   }
 
-  GLenum geometryGLType(0);
-  unsigned int numIndices(0u);
+  commandBuffer.BindVertexBuffers(0, buffers, offsets);
+
+  return true;
+}
+
+bool Geometry::Draw(
+  Graphics::Controller&    graphicsController,
+  Graphics::CommandBuffer& commandBuffer,
+  uint32_t                 elementBufferOffset,
+  uint32_t                 elementBufferCount)
+{
+  uint32_t numIndices(0u);
   intptr_t firstIndexOffset(0u);
-  if( mIndexBuffer )
+  if(mIndexBuffer)
   {
-    numIndices = mIndices.Size();
+    std::size_t sizeOfIndex = GetSizeOfIndexFromIndexType(mIndexType);
+
+    numIndices = static_cast<uint32_t>(mIndices.Size() * sizeof(uint16_t) / sizeOfIndex);
+
+    if(elementBufferOffset != 0u)
+    {
+      elementBufferOffset = (elementBufferOffset >= numIndices) ? numIndices - 1 : elementBufferOffset;
+      firstIndexOffset    = intptr_t(elementBufferOffset * sizeOfIndex);
+      numIndices -= elementBufferOffset;
+    }
+
+    if(elementBufferCount != 0u)
+    {
+      numIndices = std::min(elementBufferCount, numIndices);
+    }
+  }
 
-    if( elementBufferOffset )
+  //Draw call
+  if(mIndexBuffer && mGeometryType != Dali::Geometry::POINTS)
+  {
+    //Indexed draw call
+    const Graphics::Buffer* ibo = mIndexBuffer->GetGraphicsObject();
+    if(ibo)
     {
-      elementBufferOffset = elementBufferOffset >= numIndices ? numIndices- 1 : elementBufferOffset;
-      firstIndexOffset = elementBufferOffset * sizeof(GLushort);
+      commandBuffer.BindIndexBuffer(*ibo, 0, mIndexType);
     }
-    if ( elementBufferCount )
+
+    commandBuffer.DrawIndexed(numIndices, mInstanceCount, firstIndexOffset, 0, 0);
+  }
+  else
+  {
+    // Un-indexed draw call
+    uint32_t numVertices(0u);
+
+    if(mVertexBuffers.Count() > 0)
     {
-      numIndices = std::min( elementBufferCount, numIndices - elementBufferOffset );
+      // truncated, no value loss happening in practice
+      numVertices = static_cast<uint32_t>(mVertexBuffers[0]->GetElementCount());
     }
+
+    commandBuffer.Draw(numVertices, mInstanceCount, 0, 0);
   }
+  return true;
+}
+
+Graphics::PrimitiveTopology Geometry::GetTopology() const
+{
+  Graphics::PrimitiveTopology topology = Graphics::PrimitiveTopology::TRIANGLE_LIST;
 
   switch(mGeometryType)
   {
     case Dali::Geometry::TRIANGLES:
     {
-      geometryGLType = GL_TRIANGLES;
+      topology = Graphics::PrimitiveTopology::TRIANGLE_LIST;
       break;
     }
     case Dali::Geometry::LINES:
     {
-      geometryGLType = GL_LINES;
+      topology = Graphics::PrimitiveTopology::LINE_LIST;
       break;
     }
     case Dali::Geometry::POINTS:
     {
-      geometryGLType = GL_POINTS;
+      topology = Graphics::PrimitiveTopology::POINT_LIST;
       break;
     }
     case Dali::Geometry::TRIANGLE_STRIP:
     {
-      geometryGLType = GL_TRIANGLE_STRIP;
+      topology = Graphics::PrimitiveTopology::TRIANGLE_STRIP;
       break;
     }
     case Dali::Geometry::TRIANGLE_FAN:
     {
-      geometryGLType = GL_TRIANGLE_FAN;
+      topology = Graphics::PrimitiveTopology::TRIANGLE_FAN;
       break;
     }
     case Dali::Geometry::LINE_LOOP:
     {
-      geometryGLType = GL_LINE_LOOP;
+      topology = Graphics::PrimitiveTopology::LINE_LOOP;
       break;
     }
     case Dali::Geometry::LINE_STRIP:
     {
-      geometryGLType = GL_LINE_STRIP;
-      break;
-    }
-    default:
-    {
-      DALI_ASSERT_ALWAYS( 0 && "Geometry type not supported (yet)" );
+      topology = Graphics::PrimitiveTopology::LINE_STRIP;
       break;
     }
   }
-
-  //Draw call
-  if( mIndexBuffer && geometryGLType != GL_POINTS )
-  {
-    //Indexed draw call
-    mIndexBuffer->Bind( GpuBuffer::ELEMENT_ARRAY_BUFFER );
-    context.DrawElements(geometryGLType, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset));
-  }
-  else
-  {
-    //Unindex draw call
-    unsigned int numVertices(0u);
-    if( vertexBufferCount > 0 )
-    {
-      numVertices = mVertexBuffers[0]->GetElementCount();
-    }
-
-    context.DrawArrays( geometryGLType, 0, numVertices );
-  }
-
-  //Disable attributes
-  for( unsigned int i = 0; i < attributeLocation.Count(); ++i )
-  {
-    if( attributeLocation[i] != -1 )
-    {
-      context.DisableVertexAttributeArray( attributeLocation[i] );
-    }
-  }
+  return topology;
 }
 
-} // namespace SceneGraph
+} // namespace Render
 } // namespace Internal
 } // namespace Dali