dali/internal/render/renderers/render-vertex-buffer.h

   1 #ifndef DALI_INTERNAL_RENDER_VERTEX_BUFFER_H
   2 #define DALI_INTERNAL_RENDER_VERTEX_BUFFER_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 // INTERNAL INCLUDES
  21 #include <dali/internal/common/const-string.h>
  22 #include <dali/internal/common/owner-pointer.h>
  23 #include <dali/internal/render/gl-resources/gpu-buffer.h>
  24 #include <dali/internal/render/renderers/render-sampler.h>
  25 #include <dali/public-api/actors/sampling.h>
  26 #include <dali/public-api/common/vector-wrapper.h>
  27 #include <dali/public-api/rendering/sampler.h>
  28
  29 namespace Dali
  30 {
  31 namespace Internal
  32 {
  33 namespace Render
  34 {
  35 class VertexBuffer
  36 {
  37 public:
  38   struct Component
  39   {
  40     ConstString    name;
  41     uint32_t       offset;
  42     uint32_t       size;
  43     Property::Type type;
  44   };
  45
  46   /**
  47    * Structure that holds the meta-data of the format of VertexBuffer.
  48    */
  49   struct Format
  50   {
  51     std::vector<Component> components;
  52     uint32_t               size;
  53   };
  54
  55   /**
  56    * @brief Default constructor
  57    */
  58   VertexBuffer();
  59
  60   /**
  61    * @brief Destructor
  62    */
  63   ~VertexBuffer();
  64
  65   /**
  66    * @brief Set the format of the buffer
  67    *
  68    * This function takes ownership of the pointer
  69    *
  70    * @param[in] format The format for the VertexBuffer
  71    */
  72   void SetFormat(VertexBuffer::Format* format);
  73
  74   /**
  75    * @brief Set the data of the VertexBuffer
  76    *
  77    * This function takes ownership of the pointer
  78    * @param[in] data The new data of the VertexBuffer
  79    * @param[in] size The new size of the buffer
  80    */
  81   void SetData(Dali::Vector<uint8_t>* data, uint32_t size);
  82
  83   /**
  84    * @brief Set the number of elements
  85    * @param[in] size The number of elements
  86    */
  87   void SetSize(uint32_t size);
  88
  89   /**
  90    * Perform the upload of the buffer only when required
  91    * @param graphicsController The controller
  92    */
  93   bool Update(Graphics::Controller& graphicsController);
  94
  95   /**
  96    * Enable the vertex attributes for each vertex buffer from the corresponding
  97    * shader program.
  98    * @param[in] context The GL context
  99    * @param[in] vAttributeLocation Vector containing attributes location for current program
 100    * @param[in] locationBase Index in vAttributeLocation corresponding to the first attribute defined by this buffer
 101    */
 102   uint32_t EnableVertexAttributes(Context& context, Vector<GLint>& vAttributeLocation, uint32_t locationBase);
 103
 104   /**
 105    * Get the number of attributes present in the buffer
 106    * @return The number of attributes stored in this buffer
 107    */
 108   inline uint32_t GetAttributeCount() const
 109   {
 110     DALI_ASSERT_DEBUG(mFormat && "Format should be set ");
 111     return static_cast<uint32_t>(mFormat->components.size());
 112   }
 113
 114   /**
 115    * Retrieve the i-essim attribute name
 116    * @param[in] index The index of the attribute
 117    * @return The name of the attribute
 118    */
 119   inline ConstString GetAttributeName(uint32_t index) const
 120   {
 121     DALI_ASSERT_DEBUG(mFormat && "Format should be set ");
 122     return mFormat->components[index].name;
 123   }
 124
 125   /**
 126    * Retrieve the size of the buffer in bytes
 127    * @return The total size of the buffer
 128    */
 129   inline uint32_t GetDataSize() const
 130   {
 131     DALI_ASSERT_DEBUG(mFormat && "Format should be set ");
 132     return mFormat->size * mSize;
 133   }
 134
 135   /**
 136    * Retrieve the size of one element of the buffer
 137    * @return The size of one element
 138    */
 139   inline uint32_t GetElementSize() const
 140   {
 141     DALI_ASSERT_DEBUG(mFormat && "Format should be set ");
 142     return mFormat->size;
 143   }
 144
 145   /**
 146    * Retrieve the number of elements in the buffer
 147    * @return The total number of elements
 148    */
 149   inline uint32_t GetElementCount() const
 150   {
 151     return mSize;
 152   }
 153
 154   /**
 155    * Retrieve reference to the data storage vector
 156    * @return Reference to the data storage
 157    */
 158   inline const Dali::Vector<uint8_t>& GetData() const
 159   {
 160     return *mData.Get();
 161   }
 162
 163   /**
 164    * Retrieve data writeable pointer ( direct access to the buffer data )
 165    * @return Pointer to data converted to requested type
 166    */
 167   template<typename T>
 168   inline T* GetDataTypedPtr()
 169   {
 170     Dali::Vector<uint8_t>* data = mData.Release();
 171     mData                       = data;
 172     return reinterpret_cast<T*>(&data->operator[](0));
 173   }
 174
 175   inline const VertexBuffer::Format* GetFormat() const
 176   {
 177     return mFormat.Get();
 178   }
 179
 180   inline GpuBuffer& GetGpuBuffer()
 181   {
 182     return *(const_cast<GpuBuffer*>(mGpuBuffer.Get())); // @todo change to unique_ptr to avoid const cast?
 183   }
 184
 185 private:
 186   OwnerPointer<VertexBuffer::Format>   mFormat;    ///< Format of the buffer
 187   OwnerPointer<Dali::Vector<uint8_t> > mData;      ///< Data
 188   OwnerPointer<GpuBuffer>              mGpuBuffer; ///< Pointer to the GpuBuffer associated with this RenderVertexBuffer
 189
 190   uint32_t mSize;        ///< Number of Elements in the buffer
 191   bool     mDataChanged; ///< Flag to know if data has changed in a frame
 192 };
 193
 194 } // namespace Render
 195
 196 } // namespace Internal
 197
 198 } // namespace Dali
 199
 200 #endif //  DALI_INTERNAL_RENDER_VERTEX_BUFFER_H