src/ui/effects/renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderBufferCache.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FUiEffects_RendererGraphicsEngineRenderBufferCache.cpp
  20  * @brief               Implementation of class for buffer caching
  21  *
  22  */
  23
  24
  25 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderBufferCache.h>
  26 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineOpenGLImplementation.h>
  27
  28 namespace Tizen { namespace Ui { namespace Effects { namespace _Renderer { namespace GraphicsEngine
  29 {
  30
  31 IBufferCache::IBufferCache(Render* pRender)
  32         : RenderCache(pRender)
  33         , _bufferId(static_cast<GLuint>(0))
  34         , _dataType(static_cast<GLenum>(0))
  35 {
  36 }
  37
  38 IBufferCache::~IBufferCache() {}
  39
  40 void
  41 IBufferCache::DropCache(void)
  42 {
  43         _bufferId = 0;
  44         return;
  45 }
  46
  47 void
  48 IBufferCache::DestroyCache(void)
  49 {
  50         if (_bufferId)
  51         {
  52                 glDeleteBuffers(1, &_bufferId);
  53         }
  54
  55         return;
  56 }
  57
  58 GLenum
  59 IBufferCache::GetGlUsage(Tizen::Ui::Effects::_Renderer::EngineModel::SolidBufferStrategy::BufferUsage::Value usage)
  60 {
  61         switch (usage)
  62         {
  63         case EngineModel::SolidBufferStrategy::BufferUsage::STREAM_DRAW:
  64                 return GL_STREAM_DRAW;
  65         case EngineModel::SolidBufferStrategy::BufferUsage::STREAM_READ:
  66                 return GL_STREAM_DRAW;
  67         case EngineModel::SolidBufferStrategy::BufferUsage::STREAM_COPY:
  68                 return GL_STREAM_DRAW;
  69         case EngineModel::SolidBufferStrategy::BufferUsage::STATIC_DRAW:
  70                 return GL_STATIC_DRAW;
  71         case EngineModel::SolidBufferStrategy::BufferUsage::STATIC_READ:
  72                 return GL_STATIC_DRAW;
  73         case EngineModel::SolidBufferStrategy::BufferUsage::STATIC_COPY:
  74                 return GL_STATIC_DRAW;
  75         case EngineModel::SolidBufferStrategy::BufferUsage::DYNAMIC_DRAW:
  76                 return GL_DYNAMIC_DRAW;
  77         case EngineModel::SolidBufferStrategy::BufferUsage::DYNAMIC_READ:
  78                 return GL_DYNAMIC_DRAW;
  79         case EngineModel::SolidBufferStrategy::BufferUsage::DYNAMIC_COPY:
  80                 return GL_DYNAMIC_DRAW;
  81         }
  82         return GL_STATIC_DRAW;
  83 }
  84
  85 GLenum
  86 IBufferCache::GetGlDataType(Tizen::Ui::Effects::_Renderer::EngineModel::TypedBufferStrategy::DataType::Value dataType)
  87 {
  88         switch (dataType)
  89         {
  90         case EngineModel::TypedBufferStrategy::DataType::BYTE:
  91                 return GL_BYTE;
  92         case EngineModel::TypedBufferStrategy::DataType::UNSIGNED_BYTE:
  93                 return GL_UNSIGNED_BYTE;
  94         case EngineModel::TypedBufferStrategy::DataType::SHORT:
  95                 return GL_SHORT;
  96         case EngineModel::TypedBufferStrategy::DataType::UNSIGNED_SHORT:
  97                 return GL_UNSIGNED_SHORT;
  98         case EngineModel::TypedBufferStrategy::DataType::INT:
  99                 return GL_INT;
 100         case EngineModel::TypedBufferStrategy::DataType::UNSIGNED_INT:
 101                 return GL_UNSIGNED_INT;
 102         case EngineModel::TypedBufferStrategy::DataType::FLOAT:
 103                 return GL_FLOAT;
 104         case EngineModel::TypedBufferStrategy::DataType::DOUBLE:
 105                 ThrowJmp("GL_DOUBLE is not allowed as buffer data format undel GLES2");
 106                 break;
 107         }
 108         return GL_FLOAT;
 109 }
 110
 111 GLsizei
 112 IBufferCache::GetGlDataTypeSize(Tizen::Ui::Effects::_Renderer::EngineModel::TypedBufferStrategy::DataType::Value dataType)
 113 {
 114         switch (dataType)
 115         {
 116         case EngineModel::TypedBufferStrategy::DataType::BYTE:
 117         case EngineModel::TypedBufferStrategy::DataType::UNSIGNED_BYTE:
 118                 return 1;
 119         case EngineModel::TypedBufferStrategy::DataType::SHORT:
 120         case EngineModel::TypedBufferStrategy::DataType::UNSIGNED_SHORT:
 121                 return 2;
 122         case EngineModel::TypedBufferStrategy::DataType::DOUBLE:
 123                 return 8;
 124         case EngineModel::TypedBufferStrategy::DataType::INT:
 125         case EngineModel::TypedBufferStrategy::DataType::UNSIGNED_INT:
 126         case EngineModel::TypedBufferStrategy::DataType::FLOAT:
 127         default:
 128                 return 4;
 129         }
 130 }
 131
 132 GLenum
 133 IndexBufferCache::GetGlPrimitiveType(Tizen::Ui::Effects::_Renderer::EngineModel::IndexBuffer::PrimitiveType::Value primitiveType)
 134 {
 135         switch (primitiveType)
 136         {
 137         case EngineModel::IndexBuffer::PrimitiveType::POINTS:
 138                 return GL_POINTS;
 139         case EngineModel::IndexBuffer::PrimitiveType::LINE_STRIP:
 140                 return GL_LINE_STRIP;
 141         case EngineModel::IndexBuffer::PrimitiveType::LINE_LOOP:
 142                 return GL_LINE_LOOP;
 143         case EngineModel::IndexBuffer::PrimitiveType::LINES:
 144                 return GL_LINES;
 145         case EngineModel::IndexBuffer::PrimitiveType::TRIANGLE_STRIP:
 146                 return GL_TRIANGLE_STRIP;
 147         case EngineModel::IndexBuffer::PrimitiveType::TRIANGLE_FAN:
 148                 return GL_TRIANGLE_FAN;
 149         case EngineModel::IndexBuffer::PrimitiveType::TRIANGLES:
 150                 return GL_TRIANGLES;
 151         case EngineModel::IndexBuffer::PrimitiveType::QUAD_STRIP:
 152                 ThrowJmp("GL_QUAD_STRIP - is anasseptable as geometry type under GLES2");
 153                 // fall through
 154         case EngineModel::IndexBuffer::PrimitiveType::QUADS:
 155                 ThrowJmp("GL_QUADS - is anasseptable as geometry type under GLES2");
 156                 // fall through
 157         case EngineModel::IndexBuffer::PrimitiveType::POLYGON:
 158                 ThrowJmp("GL_POLYGON - is anasseptable as geometry type under GLES2");
 159                 // fall through
 160         }
 161         return GL_POINTS;
 162 }
 163
 164 IndexBufferCache::IndexBufferCache(Render* pRender, EngineModel::IndexBuffer* pBuffer)
 165         : IBufferCache(pRender)
 166         , __elementsCount(static_cast<GLsizei>(0))
 167         , __primitiveType(static_cast<GLenum>(0))
 168         , __pBuffer(pBuffer)
 169 {
 170 }
 171
 172 IndexBufferCache::~IndexBufferCache()
 173 {}
 174
 175 void
 176 IndexBufferCache::DestroyCache(void)
 177 {
 178         if (__pBuffer)
 179         {
 180                 __pBuffer->SetCache(IndexBufferCachePtr());
 181         }
 182
 183         __pBuffer = null;
 184         IBufferCache::DestroyCache();
 185
 186         return;
 187 }
 188
 189 void
 190 IndexBufferCache::Die(void)
 191 {
 192         __pBuffer = null;
 193         IBufferCache::Die();
 194         return;
 195 }
 196
 197 void
 198 IndexBufferCache::Validate(Render*)
 199 {
 200         if (!_invalid)
 201         {
 202                 return;
 203         }
 204         _dataType = GetGlDataType(__pBuffer->GetDataType());
 205         __elementsCount = static_cast<GLsizei>(__pBuffer->GetSize() / GetGlDataTypeSize(__pBuffer->GetDataType()));
 206         __primitiveType = GetGlPrimitiveType(__pBuffer->GetPrimitiveType());
 207         void* pData = __pBuffer->GetData();
 208         if (!pData)
 209         {
 210                 ThrowJmp("IndexBufferCache::validate: data buffer is null");
 211         }
 212         if (!_bufferId)
 213         {
 214                 glGenBuffers(1, &_bufferId);
 215         }
 216         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _bufferId);
 217         glBufferData(GL_ELEMENT_ARRAY_BUFFER, __pBuffer->GetSize(), pData, GetGlUsage(__pBuffer->GetUsage()));
 218         _invalid = false;
 219         return;
 220 }
 221
 222 void
 223 IndexBufferCache::DrawElements(Render* pRender)
 224 {
 225         if (_invalid)
 226         {
 227                 Validate(pRender);
 228         }
 229         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _bufferId);
 230         glDrawElements(__primitiveType, __elementsCount, _dataType, 0);
 231         return;
 232 }
 233
 234 SolidVertexBufferCache::SolidVertexBufferCache(Render *pRender, EngineModel::VertexBuffer* pBuffer)
 235         : VertexBufferCache(pRender)
 236         , __componentsPerElement(static_cast<GLint>(0))
 237         , __pBuffer(pBuffer)
 238 {
 239 }
 240
 241 SolidVertexBufferCache::~SolidVertexBufferCache()
 242 { }
 243
 244 void
 245 SolidVertexBufferCache::DestroyCache(void)
 246 {
 247         if (__pBuffer)
 248         {
 249                 __pBuffer->SetCache(SolidVertexBufferCachePtr());
 250         }
 251
 252         __pBuffer = null;
 253         IBufferCache::DestroyCache();
 254
 255         return;
 256 }
 257
 258 void
 259 SolidVertexBufferCache::Die(void)
 260 {
 261         __pBuffer = null;
 262         IBufferCache::Die();
 263         return;
 264 }
 265
 266 void
 267 SolidVertexBufferCache::Validate(Render*)
 268 {
 269         if (Valid())
 270         {
 271                 return;
 272         }
 273         __componentsPerElement = static_cast<GLint>(__pBuffer->GetComponentsPerElement());
 274         _dataType = GetGlDataType(__pBuffer->GetDataType());
 275         void* pData = __pBuffer->GetData();
 276         if (!pData)
 277         {
 278                 ThrowJmp("SolidVertexBufferCache::validate: data buffer is null");
 279         }
 280         if (!_bufferId)
 281         {
 282                 glGenBuffers(1, &_bufferId);
 283         }
 284         glBindBuffer(GL_ARRAY_BUFFER, _bufferId);
 285         glBufferData(GL_ARRAY_BUFFER, __pBuffer->GetSize(), pData, GetGlUsage(__pBuffer->GetUsage()));
 286         _invalid = false;
 287         return;
 288 }
 289
 290 void
 291 SolidVertexBufferCache::BindToAttrib(Render* pRender, GLuint index)
 292 {
 293         if (_invalid)
 294         {
 295                 Validate(pRender);
 296         }
 297         glBindBuffer(GL_ARRAY_BUFFER, _bufferId);
 298         glVertexAttribPointer(index, __componentsPerElement, _dataType, GL_FALSE, 0, 0);
 299         return;
 300 }
 301
 302 void
 303 SolidVertexBufferCache::BindAsVertices(Render* pRender)
 304 {
 305         ThrowJmp("SolidVertexBufferCache::bindAsVertices is anasseptable under GLES2");
 306         return;
 307 }
 308
 309 void
 310 SolidVertexBufferCache::BindAsColor(Render* pRender)
 311 {
 312         ThrowJmp("SolidVertexBufferCache::bindAsColor is anasseptable under GLES2");
 313         return;
 314 }
 315
 316 void
 317 SolidVertexBufferCache::BindAsTexCoord(Render* pRender, GLuint stage)
 318 {
 319         ThrowJmp("SolidVertexBufferCache::bindAsTexCoord is anasseptable under GLES2");
 320         return;
 321 }
 322
 323 PartVertexBufferCache::PartVertexBufferCache(Render *pRender, EngineModel::PartVertexBuffer* pBuffer)
 324         : VertexBufferCache(pRender)
 325         , __componentsPerElement(static_cast<GLint>(0))
 326         , __stride(static_cast<GLsizei>(0))
 327         , __pOffset(null)
 328         , __pBuffer(pBuffer)
 329 {
 330 }
 331
 332 PartVertexBufferCache::~PartVertexBufferCache() {}
 333
 334 void
 335 PartVertexBufferCache::DestroyCache(void)
 336 {
 337         if (__pBuffer)
 338         {
 339                 __pBuffer->SetCache(PartVertexBufferCachePtr());
 340         }
 341
 342         __pBuffer = null;
 343         IBufferCache::DestroyCache();
 344
 345         return;
 346 }
 347
 348 void
 349 PartVertexBufferCache::Die(void)
 350 {
 351         __pBuffer = null;
 352         IBufferCache::Die();
 353         return;
 354 }
 355
 356 void
 357 PartVertexBufferCache::Validate(Render*)
 358 {
 359         if (Valid())
 360         {
 361                 return;
 362         }
 363         EngineModel::CompositeVertexBufferPtr composite = __pBuffer->GetCompositeBuffer();
 364         if (!composite)
 365         {
 366                 ThrowJmp("PartVertexBufferCache::validate: no composite buffer in part buffer");
 367         }
 368         __pOffset = reinterpret_cast<GLvoid*>(__pBuffer->GetOffset());
 369         __stride = static_cast<GLsizei>(__pBuffer->GetStride());
 370         __componentsPerElement = static_cast<GLint>(__pBuffer->GetComponentsPerElement());
 371         _dataType = GetGlDataType(composite->GetDataType());
 372         _invalid = false;
 373         return;
 374 }
 375
 376 void
 377 PartVertexBufferCache::BindToAttrib(Render* pRender, GLuint index)
 378 {
 379         if (_invalid)
 380         {
 381                 Validate(pRender);
 382         }
 383         glVertexAttribPointer(index, __componentsPerElement, _dataType, GL_FALSE, __stride, __pOffset);
 384         return;
 385 }
 386
 387 void
 388 PartVertexBufferCache::BindAsVertices(Render* pRender)
 389 {
 390         ThrowJmp("PartVertexBufferCache::bindAsVertices is anasseptable under GLES2");
 391         return;
 392 }
 393
 394 void
 395 PartVertexBufferCache::BindAsColor(Render* pRender)
 396 {
 397         ThrowJmp("PartVertexBufferCache::bindAsColor is anasseptable under GLES2");
 398         return;
 399 }
 400
 401 void
 402 PartVertexBufferCache::BindAsTexCoord(Render* pRender, GLuint stage)
 403 {
 404         ThrowJmp("PartVertexBufferCache::bindAsColor is anasseptable under GLES2");
 405         return;
 406 }
 407
 408 CompositeVertexBufferCache::CompositeVertexBufferCache(Render* pRender, EngineModel::CompositeVertexBuffer* pBuffer):
 409         IBufferCache(pRender), __pBuffer(pBuffer)
 410 {
 411 }
 412
 413 CompositeVertexBufferCache::~CompositeVertexBufferCache(void)
 414 {
 415 }
 416
 417 void
 418 CompositeVertexBufferCache::DestroyCache(void)
 419 {
 420         if (__pBuffer)
 421         {
 422                 __pBuffer->SetCache(CompositeVertexBufferCachePtr());
 423         }
 424
 425         __pBuffer = null;
 426         IBufferCache::DestroyCache();
 427
 428         return;
 429 }
 430
 431 void
 432 CompositeVertexBufferCache::Die(void)
 433 {
 434         __pBuffer = null;
 435         IBufferCache::Die();
 436         return;
 437 }
 438
 439 void
 440 CompositeVertexBufferCache::Validate(Render*)
 441 {
 442         if (Valid())
 443         {
 444                 return;
 445         }
 446         _dataType = GetGlDataType(__pBuffer->GetDataType());
 447         void* pData = __pBuffer->GetData();
 448         if (!pData)
 449         {
 450                 ThrowJmp("CompositeVertexBufferCache::validate: data buffer is null");
 451         }
 452         if (!_bufferId)
 453         {
 454                 glGenBuffers(1, &_bufferId);
 455         }
 456         glBindBuffer(GL_ARRAY_BUFFER, _bufferId);
 457         glBufferData(GL_ARRAY_BUFFER, __pBuffer->GetSize(), pData, GetGlUsage(__pBuffer->GetUsage()));
 458         _invalid = false;
 459         return;
 460 }
 461
 462 void
 463 CompositeVertexBufferCache::Bind(Render* pRender)
 464 {
 465         if (_invalid)
 466         {
 467                 Validate(pRender);
 468         }
 469         glBindBuffer(GL_ARRAY_BUFFER, _bufferId);
 470         return;
 471 }
 472
 473 }}}}} // Tizen::Ui::Effects::_Renderer::GraphicsEngine