src/ui/effects/renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderDrawableCache.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_RendererGraphicsEngineRenderDrawableCache.cpp
  20  * @brief               Implementation of class for drawable objects cache
  21  *
  22  */
  23
  24
  25 #include <renderer/engine-model/FUiEffects_RendererEngineModelBuffer.h>
  26 #include <renderer/engine-model/FUiEffects_RendererEngineModelGeometry.h>
  27 #include <renderer/engine-model/FUiEffects_RendererEngineModelDrawable.h>
  28 #include <renderer/engine-model/FUiEffects_RendererEngineModelMaterial.h>
  29 #include <renderer/engine-model/FUiEffects_RendererEngineModelShaderProperty.h>
  30 #include <renderer/engine-model/FUiEffects_RendererEngineModelProgramProperty.h>
  31 #include <renderer/engine-model/FUiEffects_RendererEngineModelTexture2DProperty.h>
  32 #include <renderer/engine-model/FUiEffects_RendererEngineModelMatrix4fProperty.h>
  33 #include <renderer/engine-model/FUiEffects_RendererEngineModelIntProperty.h>
  34 #include <renderer/engine-model/FUiEffects_RendererEngineModelFloatProperty.h>
  35 #include <renderer/engine-model/FUiEffects_RendererEngineModelVector2fProperty.h>
  36 #include <renderer/engine-model/FUiEffects_RendererEngineModelVector3fProperty.h>
  37 #include <renderer/engine-model/FUiEffects_RendererEngineModelVector4fProperty.h>
  38 #include <renderer/engine-model/FUiEffects_RendererEngineModelFloatArrayProperty.h>
  39
  40 #include <renderer/math/FUiEffects_RendererMathVector.h>
  41
  42 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineOpenGLImplementation.h>
  43 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderDrawableCache.h>
  44 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderBufferCache.h>
  45 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderTextureCache.h>
  46 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRenderShaderCache.h>
  47 #include <renderer/graphics-engine/FUiEffects_RendererGraphicsEngineRender.h>
  48
  49 namespace Tizen { namespace Ui { namespace Effects { namespace _Renderer { namespace GraphicsEngine
  50 {
  51
  52 UseProgram::UseProgram(RenderProgramCache* pProgram):
  53         __pProgram(pProgram)
  54 {
  55 }
  56
  57 void
  58 UseProgram::Apply(Render* pRender)
  59 {
  60         __pProgram->UseProgram(pRender); __pProgram->EnableAttributes(pRender);
  61
  62         return;
  63 }
  64
  65 DisableProgramAttributers::DisableProgramAttributers(RenderProgramCache* pProgram):
  66         __pProgram(pProgram)
  67 {
  68 }
  69
  70 void
  71 DisableProgramAttributers::Apply(Render* pRender)
  72 {
  73         __pProgram->DisableAttributes(pRender);
  74         return;
  75 }
  76
  77 Sampler2dUniform::Sampler2dUniform(RenderTexture2dCache* pTexture, GLuint stage):
  78         __pTexture(pTexture),
  79         __stage(stage)
  80 {
  81 }
  82
  83 void
  84 Sampler2dUniform::Apply(Render* pRender)
  85 {
  86         __pTexture->Bind(pRender, __stage);
  87         return;
  88 }
  89
  90 void
  91 Sampler2dAttachmentUniform::Apply(Render* pRender)
  92 {
  93         __pTexture->Bind(pRender, __stage);
  94         return;
  95 }
  96
  97 Sampler2dAttachmentUniform::Sampler2dAttachmentUniform(Texture2dAttachmentCache* pTexture, GLuint stage):
  98         __pTexture(pTexture),
  99         __stage(stage)
 100 {
 101 }
 102
 103 Matrix4fUniform::Matrix4fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Matrix4fProperty* pUniform, GLuint location):
 104         __pUniform(pUniform),
 105         __location(location)
 106 {
 107 }
 108
 109 void
 110 Matrix4fUniform::Apply(Render*)
 111 {
 112         glUniformMatrix4fv(__location, 1, GL_FALSE, __pUniform->Get().data[0].data);
 113         return;
 114 }
 115
 116 IntUniform::IntUniform(Tizen::Ui::Effects::_Renderer::EngineModel::IntProperty* pUniform, GLuint location):
 117         __pUniform(pUniform),
 118         __location(location)
 119 {
 120 }
 121
 122 void
 123 IntUniform::Apply(Render*)
 124 {
 125         glUniform1i(__location, __pUniform->Get());
 126         return;
 127 }
 128
 129 FloatUniform::FloatUniform(Tizen::Ui::Effects::_Renderer::EngineModel::FloatProperty* pUniform, GLuint location):
 130         __pUniform(pUniform),
 131         __location(location)
 132 {
 133 }
 134
 135 void
 136 FloatUniform::Apply(Render*)
 137 {
 138         glUniform1f(__location, __pUniform->Get());
 139         return;
 140 }
 141
 142 FloatArrayUniform::FloatArrayUniform(Tizen::Ui::Effects::_Renderer::EngineModel::FloatArrayProperty* pUniform, GLuint location):
 143         __pUniform(pUniform),
 144         __location(location)
 145 {
 146 }
 147
 148 void
 149 FloatArrayUniform::Apply(Render* pRender)
 150 {
 151         glUniform1fv(__location, __pUniform->GetNumElements(), __pUniform->GetData());
 152         return;
 153 }
 154
 155 Vector2fUniform::Vector2fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Vector2fProperty* pUniform, GLuint location):
 156         __pUniform(pUniform),
 157         __location(location)
 158 {
 159 }
 160
 161 void
 162 Vector2fUniform::Apply(Render*)
 163 {
 164         glUniform2fv(__location, 1, __pUniform->Get().data);
 165         return;
 166 }
 167
 168 Vector3fUniform::Vector3fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Vector3fProperty* pUniform, GLuint location):
 169         __pUniform(pUniform),
 170         __location(location)
 171 {
 172 }
 173
 174 void
 175 Vector3fUniform::Apply(Render*)
 176 {
 177         glUniform3fv(__location, 1, __pUniform->Get().data);
 178         return;
 179 }
 180
 181 Vector4fUniform::Vector4fUniform(Tizen::Ui::Effects::_Renderer::EngineModel::Vector4fProperty* pUniform, GLuint location):
 182         _pUniform(pUniform),
 183         __location(location)
 184 {
 185 }
 186
 187 void
 188 Vector4fUniform::Apply(Render*)
 189 {
 190         glUniform4fv(__location, 1, _pUniform->Get().data);
 191         return;
 192 }
 193
 194 ProgramAttribute::ProgramAttribute(VertexBufferCache* pAttribute, GLuint location):
 195         __pAttribute(pAttribute),
 196         __location(location)
 197 {
 198 }
 199
 200 void
 201 ProgramAttribute::Apply(Render* pRender)
 202 {
 203         __pAttribute->BindToAttrib(pRender, __location);
 204         return;
 205 }
 206
 207 BindBuffer::BindBuffer(CompositeVertexBufferCache* pBuffer):
 208         __pBuffer(pBuffer)
 209 {
 210 }
 211
 212 void
 213 BindBuffer::Apply(Render* pRender)
 214 {
 215         __pBuffer->Bind(pRender);
 216         return;
 217 }
 218
 219 DrawIndexed::DrawIndexed(IndexBufferCache* pBuffer):
 220         __pBuffer(pBuffer)
 221 {
 222 }
 223
 224 void
 225 DrawIndexed::Apply(Render* pRender)
 226 {
 227         __pBuffer->DrawElements(pRender);
 228         return;
 229 }
 230
 231 SetState::SetState(RenderStateCache* pState):
 232         __pState(pState)
 233 {
 234 }
 235
 236 void
 237 SetState::Apply(Render* pRender)
 238 {
 239         __pState->Set(pRender);
 240         return;
 241 }
 242
 243 RenderDrawableCache::RenderDrawableCache(Render* pRender, EngineModel::Drawable* pDrawable) :
 244         RenderCache(pRender),
 245         __pDrawable(pDrawable),
 246         __pAlphaBlend(null)
 247 {
 248 }
 249
 250 RenderDrawableCache::~RenderDrawableCache(void)
 251 {
 252
 253 }
 254
 255 RenderDrawableCache::ExternalTexturesListSizeType
 256 RenderDrawableCache::NumExternalTextures(void)
 257 {
 258         return __externalTextures.size();
 259 }
 260
 261 EngineModel::TextureAttachment*
 262 RenderDrawableCache::GetExternalTexture(ExternalTexturesListSizeType index)
 263 {
 264         if (index < __externalTextures.size())
 265         {
 266                 return __externalTextures[index];
 267         }
 268         return null;
 269 }
 270
 271 const Math::Matrix4f&
 272 RenderDrawableCache::GetWorld(void)
 273 {
 274         return __pDrawable->GetWorld();
 275 }
 276
 277 void
 278 RenderDrawableCache::DropCache(void)
 279 {
 280         __ownCommands.clear();
 281         __commands.clear();
 282         __externalTextures.clear();
 283         return;
 284 }
 285
 286 void
 287 RenderDrawableCache::Die(void)
 288 {
 289         __pDrawable = null;
 290         RenderCache::Die();
 291         return;
 292 }
 293
 294 void
 295 RenderDrawableCache::DestroyCache(void)
 296 {
 297         if (__pDrawable)
 298         {
 299                 __pDrawable->SetCache(RenderDrawableCachePtr());
 300         }
 301         __pDrawable = null;
 302         DropCache();
 303         return;
 304 }
 305
 306 namespace
 307 {
 308         struct ProgramFinder: EngineModel::PropertyVisitor
 309         {
 310                 RenderProgramCache* programCache;
 311                 RenderAlphaBlendCache* alphaBlend;
 312                 Render* render;
 313
 314                 ProgramFinder(Tizen::Ui::Effects::_Renderer::EngineModel::MaterialPtr& material, Render* pRender):
 315                         programCache(null),
 316                         alphaBlend(null),
 317                         render(pRender)
 318                 {
 319                         const size_t len = material->GetNumProperties();
 320                         for (size_t i = 0; len > i; ++i)
 321                         {
 322                                 material->GetProperty(i)->Visit(*this);
 323                         }
 324                 }
 325
 326                 virtual void
 327                 OnProgramProperty(Tizen::Ui::Effects::_Renderer::EngineModel::ProgramProperty& prop)
 328                 {
 329                         programCache = static_cast<RenderProgramCache*>(System::GetImpl(prop.GetCache()));
 330                         if (!programCache)
 331                         {
 332                                 render->BuildCache(prop);
 333                                 programCache = static_cast<RenderProgramCache*>(System::GetImpl(prop.GetCache()));
 334                         }
 335
 336                         return;
 337                 }
 338
 339                 virtual void
 340                 OnAlphaBlendProperty(Tizen::Ui::Effects::_Renderer::EngineModel::AlphaBlendProperty& prop)
 341                 {
 342                         alphaBlend = static_cast<RenderAlphaBlendCache*>(System::GetImpl(prop.GetCache()));
 343                         if (!alphaBlend)
 344                         {
 345                                 render->BuildCache(prop);
 346                                 alphaBlend = static_cast<RenderAlphaBlendCache*>(System::GetImpl(prop.GetCache()));
 347                         }
 348
 349                         return;
 350                 }
 351         };
 352
 353         struct UniformFinder: EngineModel::PropertyVisitor
 354         {
 355                 RenderProgramCache* program;
 356                 EngineModel::MaterialPtr& material;
 357                 RenderDrawableCache::RenderCommandsListType& commands;
 358                 RenderDrawableCache::RenderCommandsListType& ownCommands;
 359                 std::vector<Tizen::Ui::Effects::_Renderer::EngineModel::TextureAttachment*>& externalTextures;
 360                 Render* pRender;
 361
 362                 const RenderProgramCache::UniformListValueType* currentUniformInfo;
 363                 GLuint currentTextureStage;
 364
 365                 UniformFinder(RenderProgramCache* pProgram, EngineModel::MaterialPtr& materialArg, Render* pRenderArg,
 366                                 RenderDrawableCache::RenderCommandsListType& commandsArg, RenderDrawableCache::RenderCommandsListType& ownCommandsArg,
 367                                 std::vector<Tizen::Ui::Effects::_Renderer::EngineModel::TextureAttachment*>& externalTexturesArg):
 368                         program(pProgram),
 369                         material(materialArg),
 370                         commands(commandsArg),
 371                         ownCommands(ownCommandsArg),
 372                         externalTextures(externalTexturesArg),
 373                         pRender(pRenderArg),
 374                         currentUniformInfo(null),
 375                         currentTextureStage(0)
 376                 {
 377                         const RenderProgramCache::UniformListSizeType numUniforms = program->GetNumUniforms();
 378                         for (RenderProgramCache::UniformListSizeType i = 0; numUniforms > i; ++i)
 379                         {
 380                                 const RenderProgramCache::UniformListValueType& uniformInfo = program->GetUniform(i);
 381                                 currentUniformInfo = &uniformInfo;
 382                                 EngineModel::PropertyPtr property = material->GetProperty(uniformInfo.second);
 383                                 if (!property)
 384                                 {
 385                                         RenderCommandPtr renderCommandPtr = pRenderArg->GetDefaultRenderCommand(currentUniformInfo);
 386                                         if (System::GetImpl(renderCommandPtr) != null)
 387                                         {
 388                                                 commands.push_back(renderCommandPtr);
 389                                                 ownCommands.push_back(renderCommandPtr);
 390                                         }
 391                                         continue;
 392                                 }
 393                                 property->Visit(*this);
 394                         }
 395                 }
 396
 397                 void
 398                 OnTexture2DProperty(Tizen::Ui::Effects::_Renderer::EngineModel::Texture2dProperty& prop)
 399                 {
 400                         glUniform1i(currentUniformInfo->first.location, currentTextureStage);
 401
 402                         RenderTexture2dCache* cache = static_cast<RenderTexture2dCache*>(System::GetImpl(prop.GetCache()));
 403                         if (!cache)
 404                         {
 405                                 pRender->BuildCache(prop, currentTextureStage);
 406                                 cache = static_cast<RenderTexture2dCache*>(System::GetImpl(prop.GetCache()));
 407                         }
 408
 409                         RenderCommandPtr renderCommandPtr(new (std::nothrow) Sampler2dUniform(cache, currentTextureStage));
 410                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "Sampler2dUniform = null");
 411
 412                         commands.push_back(renderCommandPtr);
 413                         ownCommands.push_back(renderCommandPtr);
 414                         ++currentTextureStage;
 415                         return;
 416                 }
 417
 418                 void
 419                 OnTexture2DAttachmentProperty(Tizen::Ui::Effects::_Renderer::EngineModel::Texture2dAttachmentProperty& prop)
 420                 {
 421                         glUniform1i(currentUniformInfo->first.location, currentTextureStage);
 422
 423                         Texture2dAttachmentCache* cache = static_cast<Texture2dAttachmentCache*>(System::GetImpl(prop.GetCache()));
 424                         if (!cache)
 425                         {
 426                                 pRender->BuildCache(prop, currentTextureStage);
 427                                 cache = static_cast<Texture2dAttachmentCache*>(System::GetImpl(prop.GetCache()));
 428                         }
 429                         externalTextures.push_back(&prop);
 430                         RenderCommandPtr renderCommandPtr(new (std::nothrow) Sampler2dAttachmentUniform(cache, currentTextureStage));
 431                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "Sampler2dAttachmentUniform = null");
 432
 433                         commands.push_back(renderCommandPtr);
 434                         ownCommands.push_back(renderCommandPtr);
 435                         ++currentTextureStage;
 436                         return;
 437                 }
 438
 439                 void
 440                 OnMatrix4fProperty(Tizen::Ui::Effects::_Renderer::EngineModel::Matrix4fProperty& prop)
 441                 {
 442                         RenderCommandPtr renderCommandPtr(new (std::nothrow) Matrix4fUniform(&prop, currentUniformInfo->first.location));
 443                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "Matrix4fUniform = null");
 444
 445                         commands.push_back(renderCommandPtr);
 446                         ownCommands.push_back(renderCommandPtr);
 447                         return;
 448                 }
 449
 450                 void
 451                 OnVector2fProperty(Tizen::Ui::Effects::_Renderer::EngineModel::Vector2fProperty& prop)
 452                 {
 453                         RenderCommandPtr renderCommandPtr(new (std::nothrow) Vector2fUniform(&prop, currentUniformInfo->first.location));
 454                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "Vector2fUniform = null");
 455
 456                         commands.push_back(renderCommandPtr);
 457                         ownCommands.push_back(renderCommandPtr);
 458                         return;
 459                 }
 460
 461                 void
 462                 OnVector3fProperty(Tizen::Ui::Effects::_Renderer::EngineModel::Vector3fProperty& prop)
 463                 {
 464                         RenderCommandPtr renderCommandPtr(new (std::nothrow) Vector3fUniform(&prop, currentUniformInfo->first.location));
 465                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "Vector3fUniform = null");
 466
 467                         commands.push_back(renderCommandPtr);
 468                         ownCommands.push_back(renderCommandPtr);
 469                         return;
 470                 }
 471
 472                 void
 473                 OnVector4fProperty(Tizen::Ui::Effects::_Renderer::EngineModel::Vector4fProperty& prop)
 474                 {
 475                         RenderCommandPtr renderCommandPtr(new (std::nothrow) Vector4fUniform(&prop, currentUniformInfo->first.location));
 476                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "Vector4fUniform = null");
 477
 478                         commands.push_back(renderCommandPtr);
 479                         ownCommands.push_back(renderCommandPtr);
 480                         return;
 481                 }
 482
 483                 void
 484                 OnIntProperty(Tizen::Ui::Effects::_Renderer::EngineModel::IntProperty& prop)
 485                 {
 486                         RenderCommandPtr renderCommandPtr(new (std::nothrow) IntUniform(&prop, currentUniformInfo->first.location));
 487                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "IntUniform = null");
 488
 489                    commands.push_back(renderCommandPtr);
 490                    ownCommands.push_back(renderCommandPtr);
 491                    return;
 492                 }
 493
 494                 void
 495                 OnFloatProperty(Tizen::Ui::Effects::_Renderer::EngineModel::FloatProperty& prop)
 496                 {
 497                         RenderCommandPtr renderCommandPtr(new (std::nothrow) FloatUniform(&prop, currentUniformInfo->first.location));
 498                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "FloatUniform = null");
 499
 500                         commands.push_back(renderCommandPtr);
 501                         ownCommands.push_back(renderCommandPtr);
 502                         return;
 503                 }
 504
 505                 void
 506                 OnFloatArrayProperty(Tizen::Ui::Effects::_Renderer::EngineModel::FloatArrayProperty& prop)
 507                 {
 508                         RenderCommandPtr renderCommandPtr(new (std::nothrow) FloatArrayUniform(&prop, currentUniformInfo->first.location));
 509                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "FloatArrayUniform = null");
 510
 511                         commands.push_back(renderCommandPtr);
 512                         ownCommands.push_back(renderCommandPtr);
 513                         return;
 514                 }
 515         };
 516
 517
 518         struct GeometryFinder: EngineModel::BufferVisitor
 519         {
 520                 RenderProgramCache* pProgram;
 521                 EngineModel::GeometryPtr& geometry;
 522                 RenderDrawableCache::RenderCommandsListType& commands;
 523                 RenderDrawableCache::RenderCommandsListType& ownCommands;
 524                 Render* pRender;
 525
 526                 const RenderProgramCache::AttribuleListValueType* pCurrentAttributeInfo;
 527
 528                 GeometryFinder(RenderProgramCache* pProgramArg, EngineModel::GeometryPtr& geometryArg, Render* pRenderArg,
 529                                 RenderDrawableCache::RenderCommandsListType& commandsArg, RenderDrawableCache::RenderCommandsListType& ownCommandsArg):
 530                         pProgram(pProgramArg),
 531                         geometry(geometryArg),
 532                         commands(commandsArg),
 533                         ownCommands(ownCommandsArg),
 534                         pRender(pRenderArg),
 535                         pCurrentAttributeInfo(null)
 536                 {
 537                         const RenderProgramCache::AttribuleListSizeType numAttributes = pProgram->GetNumAttributes();
 538                         for (RenderProgramCache::AttribuleListSizeType i = 0; numAttributes > i; ++i)
 539                         {
 540                                 const RenderProgramCache::AttribuleListValueType& attributeInfo = pProgram->GetAttribute(i);
 541                                 pCurrentAttributeInfo = &attributeInfo;
 542                                 EngineModel::BufferPtr buffer = geometry->GetBuffer(attributeInfo.second);
 543                                 if (!buffer)
 544                                 {
 545                                         continue;
 546                                 }
 547                                 buffer->Visit(*this);
 548                         }
 549
 550                         EngineModel::BufferPtr buffer = geometry->GetIndexBuffer();
 551                         if (!buffer)
 552                         {
 553                                 return;
 554                         }
 555                         buffer->Visit(*this);
 556                         return;
 557                 }
 558
 559                 void
 560                 OnVertexBuffer(Tizen::Ui::Effects::_Renderer::EngineModel::VertexBuffer& prop)
 561                 {
 562                         VertexBufferCache* cache = static_cast<VertexBufferCache*>(System::GetImpl(prop.GetCache()));
 563                         if (!cache)
 564                         {
 565                                 pRender->BuildCache(prop);
 566                         }
 567
 568                         RenderCommandPtr renderCommandPtr(new (std::nothrow) ProgramAttribute(static_cast<VertexBufferCache*>(System::GetImpl(prop.GetCache())), pCurrentAttributeInfo->first.location));
 569                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "ProgramAttribute = null");
 570
 571                         commands.push_back(renderCommandPtr);
 572                         ownCommands.push_back(renderCommandPtr);
 573                         return;
 574                 }
 575
 576                 void
 577                 OnCompositeVertexBuffer(Tizen::Ui::Effects::_Renderer::EngineModel::CompositeVertexBuffer& prop)
 578                 {
 579                         CompositeVertexBufferCache* cache = static_cast<CompositeVertexBufferCache*>(System::GetImpl(prop.GetCache()));
 580                         if (!cache)
 581                         {
 582                                 pRender->BuildCache(prop);
 583                         }
 584
 585                         RenderCommandPtr renderCommandPtr(new (std::nothrow) BindBuffer(static_cast<CompositeVertexBufferCache*>(System::GetImpl(prop.GetCache()))));
 586                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "BindBuffer = null");
 587
 588                         commands.push_back(renderCommandPtr);
 589                         ownCommands.push_back(renderCommandPtr);
 590                         return;
 591                 }
 592
 593                 void
 594                 OnPartVertexBuffer(Tizen::Ui::Effects::_Renderer::EngineModel::PartVertexBuffer& prop)
 595                 {
 596                         prop.GetCompositeBuffer()->Visit(*this);
 597
 598                         VertexBufferCache* cache = static_cast<VertexBufferCache*>(System::GetImpl(prop.GetCache()));
 599                         if (!cache)
 600                         {
 601                                 pRender->BuildCache(prop);
 602                         }
 603
 604                         RenderCommandPtr renderCommandPtr(new (std::nothrow) ProgramAttribute(static_cast<VertexBufferCache*>(System::GetImpl(prop.GetCache())), pCurrentAttributeInfo->first.location));
 605                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "ProgramAttribute = null");
 606
 607                         commands.push_back(renderCommandPtr);
 608                         ownCommands.push_back(renderCommandPtr);
 609                         return;
 610                 }
 611
 612                 void
 613                 OnIndexBuffer(Tizen::Ui::Effects::_Renderer::EngineModel::IndexBuffer& prop)
 614                 {
 615                         IndexBufferCache* cache = static_cast<IndexBufferCache*>(System::GetImpl(prop.GetCache()));
 616                         if (!cache)
 617                         {
 618                                 pRender->BuildCache(prop);
 619                         }
 620
 621                         RenderCommandPtr renderCommandPtr(new (std::nothrow) DrawIndexed(static_cast<IndexBufferCache*>(System::GetImpl(prop.GetCache()))));
 622                         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "DrawIndexed = null");
 623
 624                         commands.push_back(renderCommandPtr);
 625                         ownCommands.push_back(renderCommandPtr);
 626                         return;
 627                 }
 628         };
 629 }
 630
 631 void
 632 RenderDrawableCache::Validate(Render* pRender)
 633 {
 634         RenderCommandPtr renderCommandPtr;
 635
 636         if (!_invalid)
 637         {
 638                 return;
 639         }
 640         if (!__pDrawable)
 641         {
 642                 return;
 643         }
 644
 645         __ownCommands.clear();
 646         __commands.clear();
 647         __externalTextures.clear();
 648
 649         EngineModel::MaterialPtr material = __pDrawable->GetMaterial();
 650         if (!material)
 651         {
 652                 return;
 653         }
 654
 655         EngineModel::GeometryPtr geometry = __pDrawable->GetGeometry();
 656         if (!geometry)
 657         {
 658                 return;
 659         }
 660
 661         //find __pProgram
 662         ProgramFinder programFinder(material, pRender);
 663         RenderProgramCache* pProgram = programFinder.programCache;
 664         if (null == pProgram)
 665         {
 666                 return;
 667         }
 668
 669          renderCommandPtr = RenderCommandPtr(new (std::nothrow) UseProgram(pProgram));
 670         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "UseProgram = null");
 671
 672         __commands.push_back(renderCommandPtr);
 673         __ownCommands.push_back(renderCommandPtr);
 674
 675         //Set states
 676         if (programFinder.alphaBlend)
 677         {
 678                 __pAlphaBlend = programFinder.alphaBlend;
 679                 renderCommandPtr = RenderCommandPtr(new (std::nothrow) SetState(__pAlphaBlend));
 680                 _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "SetState = null");
 681
 682                 __commands.push_back(renderCommandPtr);
 683                 __ownCommands.push_back(renderCommandPtr);
 684         }
 685
 686         //parse uniforms
 687         pProgram->UseProgram(pRender);
 688         UniformFinder uniformFinder(pProgram, material, pRender, __commands, __ownCommands, __externalTextures);
 689         glUseProgram(0);
 690
 691         //parse geometry
 692         GeometryFinder geometryFinder(pProgram, geometry, pRender, __commands, __ownCommands);
 693
 694         //DisableAttributes
 695         renderCommandPtr = RenderCommandPtr(new (std::nothrow) DisableProgramAttributers(pProgram));
 696         _TryJmp(System::GetImpl(renderCommandPtr) != null, E_OUT_OF_MEMORY, "DisableProgramAttributers = null");
 697
 698         __commands.push_back(renderCommandPtr);
 699         __ownCommands.push_back(renderCommandPtr);
 700
 701         _invalid = false;
 702         return;
 703 }
 704
 705 void
 706 RenderDrawableCache::Draw(Render* pRender)
 707 {
 708         if (_invalid)
 709         {
 710                 Validate(pRender);
 711         }
 712
 713         const size_t len = __commands.size();
 714         for (size_t i = 0; len > i; ++i)
 715         {
 716                 __commands[i]->Apply(pRender);
 717         }
 718
 719         return;
 720 }
 721
 722 bool
 723 RenderDrawableCache::HasAlphaBlend(Render* pRender)
 724 {
 725         if (!__pAlphaBlend)
 726         {
 727                 return false;
 728         }
 729         return __pAlphaBlend->IsEnable(pRender);
 730 }
 731
 732 }}}}} // Tizen::Ui::Effects::_Renderer::GraphicsEngine