dali/internal/render/common/render-manager.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/render/common/render-manager.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <memory.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/devel-api/threading/thread-pool.h>
  26 #include <dali/integration-api/core.h>
  27 #include <dali/integration-api/gl-context-helper-abstraction.h>
  28 #include <dali/internal/event/common/scene-impl.h>
  29 #include <dali/internal/render/common/render-algorithms.h>
  30 #include <dali/internal/render/common/render-debug.h>
  31 #include <dali/internal/render/common/render-tracker.h>
  32 #include <dali/internal/render/queue/render-queue.h>
  33 #include <dali/internal/render/shaders/program-controller.h>
  34
  35 namespace Dali
  36 {
  37
  38 namespace Internal
  39 {
  40
  41 namespace SceneGraph
  42 {
  43
  44 #if defined(DEBUG_ENABLED)
  45 namespace
  46 {
  47 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RENDER_MANAGER" );
  48 } // unnamed namespace
  49 #endif
  50
  51 /**
  52  * Structure to contain internal data
  53  */
  54 struct RenderManager::Impl
  55 {
  56   Impl( Integration::GlAbstraction& glAbstraction,
  57         Integration::GlSyncAbstraction& glSyncAbstraction,
  58         Integration::GlContextHelperAbstraction& glContextHelperAbstraction,
  59         Integration::DepthBufferAvailable depthBufferAvailableParam,
  60         Integration::StencilBufferAvailable stencilBufferAvailableParam,
  61         Integration::PartialUpdateAvailable partialUpdateAvailableParam )
  62   : context( glAbstraction, &sceneContextContainer ),
  63     currentContext( &context ),
  64     glAbstraction( glAbstraction ),
  65     glSyncAbstraction( glSyncAbstraction ),
  66     glContextHelperAbstraction( glContextHelperAbstraction ),
  67     renderQueue(),
  68     renderAlgorithms(),
  69     frameCount( 0u ),
  70     renderBufferIndex( SceneGraphBuffers::INITIAL_UPDATE_BUFFER_INDEX ),
  71     defaultSurfaceRect(),
  72     rendererContainer(),
  73     samplerContainer(),
  74     textureContainer(),
  75     frameBufferContainer(),
  76     lastFrameWasRendered( false ),
  77     programController( glAbstraction ),
  78     depthBufferAvailable( depthBufferAvailableParam ),
  79     stencilBufferAvailable( stencilBufferAvailableParam ),
  80     partialUpdateAvailable( partialUpdateAvailableParam )
  81   {
  82      // Create thread pool with just one thread ( there may be a need to create more threads in the future ).
  83     threadPool = std::unique_ptr<Dali::ThreadPool>( new Dali::ThreadPool() );
  84     threadPool->Initialize( 1u );
  85   }
  86
  87   ~Impl()
  88   {
  89     threadPool.reset( nullptr ); // reset now to maintain correct destruction order
  90   }
  91
  92   void AddRenderTracker( Render::RenderTracker* renderTracker )
  93   {
  94     DALI_ASSERT_DEBUG( renderTracker != NULL );
  95     mRenderTrackers.PushBack( renderTracker );
  96   }
  97
  98   void RemoveRenderTracker( Render::RenderTracker* renderTracker )
  99   {
 100     mRenderTrackers.EraseObject( renderTracker );
 101   }
 102
 103   Context* CreateSceneContext()
 104   {
 105     Context* context = new Context( glAbstraction );
 106     sceneContextContainer.PushBack( context );
 107     return context;
 108   }
 109
 110   void DestroySceneContext( Context* sceneContext )
 111   {
 112     auto iter = std::find( sceneContextContainer.Begin(), sceneContextContainer.End(), sceneContext );
 113     if( iter != sceneContextContainer.End() )
 114     {
 115       ( *iter )->GlContextDestroyed();
 116       sceneContextContainer.Erase( iter );
 117     }
 118   }
 119
 120   Context* ReplaceSceneContext( Context* oldSceneContext )
 121   {
 122     Context* newContext = new Context( glAbstraction );
 123
 124     oldSceneContext->GlContextDestroyed();
 125
 126     std::replace( sceneContextContainer.begin(), sceneContextContainer.end(), oldSceneContext, newContext );
 127     return newContext;
 128   }
 129
 130   void UpdateTrackers()
 131   {
 132     for( auto&& iter : mRenderTrackers )
 133     {
 134       iter->PollSyncObject();
 135     }
 136   }
 137
 138   // the order is important for destruction,
 139   // programs are owned by context at the moment.
 140   Context                                   context;                 ///< Holds the GL state of the share resource context
 141   Context*                                  currentContext;          ///< Holds the GL state of the current context for rendering
 142   OwnerContainer< Context* >                sceneContextContainer;   ///< List of owned contexts holding the GL state per scene
 143   Integration::GlAbstraction&               glAbstraction;           ///< GL abstraction
 144   Integration::GlSyncAbstraction&           glSyncAbstraction;       ///< GL sync abstraction
 145   Integration::GlContextHelperAbstraction&  glContextHelperAbstraction; ///< GL context helper abstraction
 146   RenderQueue                               renderQueue;             ///< A message queue for receiving messages from the update-thread.
 147
 148   std::vector< SceneGraph::Scene* >         sceneContainer;          ///< List of pointers to the scene graph objects of the scenes
 149
 150   Render::RenderAlgorithms                  renderAlgorithms;        ///< The RenderAlgorithms object is used to action the renders required by a RenderInstruction
 151
 152   uint32_t                                  frameCount;              ///< The current frame count
 153   BufferIndex                               renderBufferIndex;       ///< The index of the buffer to read from; this is opposite of the "update" buffer
 154
 155   Rect<int32_t>                             defaultSurfaceRect;      ///< Rectangle for the default surface we are rendering to
 156
 157   OwnerContainer< Render::Renderer* >       rendererContainer;       ///< List of owned renderers
 158   OwnerContainer< Render::Sampler* >        samplerContainer;        ///< List of owned samplers
 159   OwnerContainer< Render::Texture* >        textureContainer;        ///< List of owned textures
 160   OwnerContainer< Render::FrameBuffer* >    frameBufferContainer;    ///< List of owned framebuffers
 161   OwnerContainer< Render::VertexBuffer* >   vertexBufferContainer;   ///< List of owned vertex buffers
 162   OwnerContainer< Render::Geometry* >       geometryContainer;       ///< List of owned Geometries
 163
 164   bool                                      lastFrameWasRendered;    ///< Keeps track of the last frame being rendered due to having render instructions
 165
 166   OwnerContainer< Render::RenderTracker* >  mRenderTrackers;         ///< List of render trackers
 167
 168   ProgramController                         programController;        ///< Owner of the GL programs
 169
 170   Integration::DepthBufferAvailable         depthBufferAvailable;     ///< Whether the depth buffer is available
 171   Integration::StencilBufferAvailable       stencilBufferAvailable;   ///< Whether the stencil buffer is available
 172   Integration::PartialUpdateAvailable       partialUpdateAvailable;   ///< Whether the partial update is available
 173
 174   std::unique_ptr<Dali::ThreadPool>         threadPool;               ///< The thread pool
 175   Vector<GLuint>                            boundTextures;            ///< The textures bound for rendering
 176   Vector<GLuint>                            textureDependencyList;    ///< The dependency list of binded textures
 177 };
 178
 179 RenderManager* RenderManager::New( Integration::GlAbstraction& glAbstraction,
 180                                    Integration::GlSyncAbstraction& glSyncAbstraction,
 181                                    Integration::GlContextHelperAbstraction& glContextHelperAbstraction,
 182                                    Integration::DepthBufferAvailable depthBufferAvailable,
 183                                    Integration::StencilBufferAvailable stencilBufferAvailable,
 184                                    Integration::PartialUpdateAvailable partialUpdateAvailable )
 185 {
 186   RenderManager* manager = new RenderManager;
 187   manager->mImpl = new Impl( glAbstraction,
 188                              glSyncAbstraction,
 189                              glContextHelperAbstraction,
 190                              depthBufferAvailable,
 191                              stencilBufferAvailable,
 192                              partialUpdateAvailable );
 193   return manager;
 194 }
 195
 196 RenderManager::RenderManager()
 197 : mImpl(nullptr)
 198 {
 199 }
 200
 201 RenderManager::~RenderManager()
 202 {
 203   delete mImpl;
 204 }
 205
 206 RenderQueue& RenderManager::GetRenderQueue()
 207 {
 208   return mImpl->renderQueue;
 209 }
 210
 211 void RenderManager::ContextCreated()
 212 {
 213   mImpl->context.GlContextCreated();
 214   mImpl->programController.GlContextCreated();
 215
 216   // renderers, textures and gpu buffers cannot reinitialize themselves
 217   // so they rely on someone reloading the data for them
 218 }
 219
 220 void RenderManager::ContextDestroyed()
 221 {
 222   mImpl->context.GlContextDestroyed();
 223   mImpl->programController.GlContextDestroyed();
 224
 225   //Inform textures
 226   for( auto&& texture : mImpl->textureContainer )
 227   {
 228     texture->GlContextDestroyed();
 229   }
 230
 231   //Inform framebuffers
 232   for( auto&& framebuffer : mImpl->frameBufferContainer )
 233   {
 234     framebuffer->GlContextDestroyed();
 235   }
 236
 237   // inform renderers
 238   for( auto&& renderer : mImpl->rendererContainer )
 239   {
 240     renderer->GlContextDestroyed();
 241   }
 242
 243   // inform context
 244   for( auto&& context : mImpl->sceneContextContainer )
 245   {
 246     context->GlContextDestroyed();
 247   }
 248 }
 249
 250 void RenderManager::SetShaderSaver( ShaderSaver& upstream )
 251 {
 252   mImpl->programController.SetShaderSaver( upstream );
 253 }
 254
 255 void RenderManager::SetDefaultSurfaceRect(const Rect<int32_t>& rect)
 256 {
 257   mImpl->defaultSurfaceRect = rect;
 258 }
 259
 260 void RenderManager::AddRenderer( OwnerPointer< Render::Renderer >& renderer )
 261 {
 262   // Initialize the renderer as we are now in render thread
 263   renderer->Initialize( mImpl->context );
 264
 265   mImpl->rendererContainer.PushBack( renderer.Release() );
 266 }
 267
 268 void RenderManager::RemoveRenderer( Render::Renderer* renderer )
 269 {
 270   mImpl->rendererContainer.EraseObject( renderer );
 271 }
 272
 273 void RenderManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
 274 {
 275   mImpl->samplerContainer.PushBack( sampler.Release() );
 276 }
 277
 278 void RenderManager::RemoveSampler( Render::Sampler* sampler )
 279 {
 280   mImpl->samplerContainer.EraseObject( sampler );
 281 }
 282
 283 void RenderManager::AddTexture( OwnerPointer< Render::Texture >& texture )
 284 {
 285   texture->Initialize( mImpl->context );
 286   mImpl->textureContainer.PushBack( texture.Release() );
 287 }
 288
 289 void RenderManager::RemoveTexture( Render::Texture* texture )
 290 {
 291   DALI_ASSERT_DEBUG( NULL != texture );
 292
 293   // Find the texture, use reference to pointer so we can do the erase safely
 294   for ( auto&& iter : mImpl->textureContainer )
 295   {
 296     if ( iter == texture )
 297     {
 298       texture->Destroy( mImpl->context );
 299       mImpl->textureContainer.Erase( &iter ); // Texture found; now destroy it
 300       return;
 301     }
 302   }
 303 }
 304
 305 void RenderManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
 306 {
 307   texture->Upload( mImpl->context, pixelData, params );
 308 }
 309
 310 void RenderManager::GenerateMipmaps( Render::Texture* texture )
 311 {
 312   texture->GenerateMipmaps( mImpl->context );
 313 }
 314
 315 void RenderManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
 316 {
 317   sampler->mMinificationFilter = static_cast<Dali::FilterMode::Type>(minFilterMode);
 318   sampler->mMagnificationFilter = static_cast<Dali::FilterMode::Type>(magFilterMode );
 319 }
 320
 321 void RenderManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
 322 {
 323   sampler->mRWrapMode = static_cast<Dali::WrapMode::Type>(rWrapMode);
 324   sampler->mSWrapMode = static_cast<Dali::WrapMode::Type>(sWrapMode);
 325   sampler->mTWrapMode = static_cast<Dali::WrapMode::Type>(tWrapMode);
 326 }
 327
 328 void RenderManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
 329 {
 330   Render::FrameBuffer* frameBufferPtr = frameBuffer.Release();
 331   mImpl->frameBufferContainer.PushBack( frameBufferPtr );
 332   frameBufferPtr->Initialize( mImpl->context );
 333 }
 334
 335 void RenderManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer )
 336 {
 337   DALI_ASSERT_DEBUG( NULL != frameBuffer );
 338
 339   // Find the sampler, use reference so we can safely do the erase
 340   for ( auto&& iter : mImpl->frameBufferContainer )
 341   {
 342     if ( iter == frameBuffer )
 343     {
 344       frameBuffer->Destroy( mImpl->context );
 345       mImpl->frameBufferContainer.Erase( &iter ); // frameBuffer found; now destroy it
 346
 347       break;
 348     }
 349   }
 350 }
 351 void RenderManager::InitializeScene( SceneGraph::Scene* scene )
 352 {
 353   scene->Initialize( *mImpl->CreateSceneContext() );
 354   mImpl->sceneContainer.push_back( scene );
 355 }
 356
 357 void RenderManager::UninitializeScene( SceneGraph::Scene* scene )
 358 {
 359   mImpl->DestroySceneContext( scene->GetContext() );
 360
 361   auto iter = std::find( mImpl->sceneContainer.begin(), mImpl->sceneContainer.end(), scene );
 362   if( iter != mImpl->sceneContainer.end() )
 363   {
 364     mImpl->sceneContainer.erase( iter );
 365   }
 366 }
 367
 368 void RenderManager::SurfaceReplaced( SceneGraph::Scene* scene )
 369 {
 370   Context* newContext = mImpl->ReplaceSceneContext( scene->GetContext() );
 371   scene->Initialize( *newContext );
 372 }
 373
 374 void RenderManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
 375 {
 376   frameBuffer->AttachColorTexture( mImpl->context, texture, mipmapLevel, layer );
 377 }
 378
 379 void RenderManager::AttachDepthTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
 380 {
 381   frameBuffer->AttachDepthTexture( mImpl->context, texture, mipmapLevel );
 382 }
 383
 384 void RenderManager::AttachDepthStencilTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
 385 {
 386   frameBuffer->AttachDepthStencilTexture( mImpl->context, texture, mipmapLevel );
 387 }
 388
 389 void RenderManager::AddVertexBuffer( OwnerPointer< Render::VertexBuffer >& vertexBuffer )
 390 {
 391   mImpl->vertexBufferContainer.PushBack( vertexBuffer.Release() );
 392 }
 393
 394 void RenderManager::RemoveVertexBuffer( Render::VertexBuffer* vertexBuffer )
 395 {
 396   mImpl->vertexBufferContainer.EraseObject( vertexBuffer );
 397 }
 398
 399 void RenderManager::SetVertexBufferFormat( Render::VertexBuffer* vertexBuffer, OwnerPointer< Render::VertexBuffer::Format>& format )
 400 {
 401   vertexBuffer->SetFormat( format.Release() );
 402 }
 403
 404 void RenderManager::SetVertexBufferData( Render::VertexBuffer* vertexBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
 405 {
 406   vertexBuffer->SetData( data.Release(), size );
 407 }
 408
 409 void RenderManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
 410 {
 411   geometry->SetIndexBuffer( indices );
 412 }
 413
 414 void RenderManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
 415 {
 416   mImpl->geometryContainer.PushBack( geometry.Release() );
 417 }
 418
 419 void RenderManager::RemoveGeometry( Render::Geometry* geometry )
 420 {
 421   mImpl->geometryContainer.EraseObject( geometry );
 422 }
 423
 424 void RenderManager::AttachVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
 425 {
 426   DALI_ASSERT_DEBUG( NULL != geometry );
 427
 428   // Find the geometry
 429   for ( auto&& iter : mImpl->geometryContainer )
 430   {
 431     if ( iter == geometry )
 432     {
 433       iter->AddVertexBuffer( vertexBuffer );
 434       break;
 435     }
 436   }
 437 }
 438
 439 void RenderManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
 440 {
 441   DALI_ASSERT_DEBUG( NULL != geometry );
 442
 443   // Find the geometry
 444   for ( auto&& iter : mImpl->geometryContainer )
 445   {
 446     if ( iter == geometry )
 447     {
 448       iter->RemoveVertexBuffer( vertexBuffer );
 449       break;
 450     }
 451   }
 452 }
 453
 454 void RenderManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
 455 {
 456   geometry->SetType( Render::Geometry::Type(geometryType) );
 457 }
 458
 459 void RenderManager::AddRenderTracker( Render::RenderTracker* renderTracker )
 460 {
 461   mImpl->AddRenderTracker(renderTracker);
 462 }
 463
 464 void RenderManager::RemoveRenderTracker( Render::RenderTracker* renderTracker )
 465 {
 466   mImpl->RemoveRenderTracker(renderTracker);
 467 }
 468
 469 ProgramCache* RenderManager::GetProgramCache()
 470 {
 471   return &(mImpl->programController);
 472 }
 473
 474 void RenderManager::PreRender( Integration::RenderStatus& status, bool forceClear, bool uploadOnly )
 475 {
 476   DALI_PRINT_RENDER_START( mImpl->renderBufferIndex );
 477
 478   // Core::Render documents that GL context must be current before calling Render
 479   DALI_ASSERT_DEBUG( mImpl->context.IsGlContextCreated() );
 480
 481   // Increment the frame count at the beginning of each frame
 482   ++mImpl->frameCount;
 483
 484   // Process messages queued during previous update
 485   mImpl->renderQueue.ProcessMessages( mImpl->renderBufferIndex );
 486
 487   uint32_t count = 0u;
 488   for( uint32_t i = 0; i < mImpl->sceneContainer.size(); ++i )
 489   {
 490     count += mImpl->sceneContainer[i]->GetRenderInstructions().Count( mImpl->renderBufferIndex );
 491   }
 492
 493   const bool haveInstructions = count > 0u;
 494
 495   DALI_LOG_INFO( gLogFilter, Debug::General,
 496                  "Render: haveInstructions(%s) || mImpl->lastFrameWasRendered(%s) || forceClear(%s)\n",
 497                  haveInstructions ? "true" : "false",
 498                  mImpl->lastFrameWasRendered ? "true" : "false",
 499                  forceClear ? "true" : "false" );
 500
 501   // Only render if we have instructions to render, or the last frame was rendered (and therefore a clear is required).
 502   if( haveInstructions || mImpl->lastFrameWasRendered || forceClear )
 503   {
 504     DALI_LOG_INFO( gLogFilter, Debug::General, "Render: Processing\n" );
 505
 506     // Switch to the shared context
 507     if ( mImpl->currentContext != &mImpl->context )
 508     {
 509       mImpl->currentContext = &mImpl->context;
 510
 511       if ( mImpl->currentContext->IsSurfacelessContextSupported() )
 512       {
 513         mImpl->glContextHelperAbstraction.MakeSurfacelessContextCurrent();
 514       }
 515
 516       // Clear the current cached program when the context is switched
 517       mImpl->programController.ClearCurrentProgram();
 518     }
 519
 520     // Upload the geometries
 521     for( uint32_t i = 0; i < mImpl->sceneContainer.size(); ++i )
 522     {
 523       RenderInstructionContainer& instructions = mImpl->sceneContainer[i]->GetRenderInstructions();
 524       for ( uint32_t j = 0; j < instructions.Count( mImpl->renderBufferIndex ); ++j )
 525       {
 526         RenderInstruction& instruction = instructions.At( mImpl->renderBufferIndex, j );
 527
 528         const Matrix* viewMatrix       = instruction.GetViewMatrix( mImpl->renderBufferIndex );
 529         const Matrix* projectionMatrix = instruction.GetProjectionMatrix( mImpl->renderBufferIndex );
 530
 531         DALI_ASSERT_DEBUG( viewMatrix );
 532         DALI_ASSERT_DEBUG( projectionMatrix );
 533
 534         if( viewMatrix && projectionMatrix )
 535         {
 536           const RenderListContainer::SizeType renderListCount = instruction.RenderListCount();
 537
 538           // Iterate through each render list.
 539           for( RenderListContainer::SizeType index = 0; index < renderListCount; ++index )
 540           {
 541             const RenderList* renderList = instruction.GetRenderList( index );
 542
 543             if( renderList && !renderList->IsEmpty() )
 544             {
 545               const std::size_t itemCount = renderList->Count();
 546               for( uint32_t itemIndex = 0u; itemIndex < itemCount; ++itemIndex )
 547               {
 548                 const RenderItem& item = renderList->GetItem( itemIndex );
 549                 if( DALI_LIKELY( item.mRenderer ) )
 550                 {
 551                   item.mRenderer->Upload( *mImpl->currentContext );
 552                 }
 553               }
 554             }
 555           }
 556         }
 557       }
 558     }
 559   }
 560 }
 561
 562 void RenderManager::PreRender( Integration::Scene& scene, std::vector<Rect<int>>& damagedRects )
 563 {
 564   if (mImpl->partialUpdateAvailable != Integration::PartialUpdateAvailable::TRUE)
 565   {
 566     return;
 567   }
 568
 569   class DamagedRectsCleaner
 570   {
 571   public:
 572     DamagedRectsCleaner(std::vector<Rect<int>>& damagedRects)
 573     : mDamagedRects(damagedRects),
 574       mCleanOnReturn(true)
 575     {
 576     }
 577
 578     void SetCleanOnReturn(bool cleanOnReturn)
 579     {
 580       mCleanOnReturn = cleanOnReturn;
 581     }
 582
 583     ~DamagedRectsCleaner()
 584     {
 585       if (mCleanOnReturn)
 586       {
 587         mDamagedRects.clear();
 588       }
 589     }
 590
 591   private:
 592     std::vector<Rect<int>>& mDamagedRects;
 593     bool mCleanOnReturn;
 594   };
 595
 596   Rect<int32_t> surfaceRect = Rect<int32_t>(0, 0, static_cast<int32_t>( scene.GetSize().width ), static_cast<int32_t>( scene.GetSize().height ));
 597
 598   // Clean collected dirty/damaged rects on exit if 3d layer or 3d node or other conditions.
 599   DamagedRectsCleaner damagedRectCleaner(damagedRects);
 600
 601
 602
 603   Internal::Scene& sceneInternal = GetImplementation(scene);
 604   SceneGraph::Scene* sceneObject = sceneInternal.GetSceneObject();
 605
 606   // Mark previous dirty rects in the sorted array. The array is already sorted by node and renderer, frame number.
 607   // so you don't need to sort: std::stable_sort(itemsDirtyRects.begin(), itemsDirtyRects.end());
 608   std::vector<DirtyRect>& itemsDirtyRects = sceneInternal.GetItemsDirtyRects();
 609   for (DirtyRect& dirtyRect : itemsDirtyRects)
 610   {
 611     dirtyRect.visited = false;
 612   }
 613
 614   uint32_t count = sceneObject->GetRenderInstructions().Count( mImpl->renderBufferIndex );
 615   for (uint32_t i = 0; i < count; ++i)
 616   {
 617     RenderInstruction& instruction = sceneObject->GetRenderInstructions().At( mImpl->renderBufferIndex, i );
 618
 619     if (instruction.mFrameBuffer)
 620     {
 621       return; // TODO: reset, we don't deal with render tasks with framebuffers (for now)
 622     }
 623
 624     const Camera* camera = instruction.GetCamera();
 625     if (camera->mType == Camera::DEFAULT_TYPE && camera->mTargetPosition == Camera::DEFAULT_TARGET_POSITION)
 626     {
 627       const Node* node = instruction.GetCamera()->GetNode();
 628       if (node)
 629       {
 630         Vector3 position;
 631         Vector3 scale;
 632         Quaternion orientation;
 633         node->GetWorldMatrix(mImpl->renderBufferIndex).GetTransformComponents(position, orientation, scale);
 634
 635         Vector3 orientationAxis;
 636         Radian orientationAngle;
 637         orientation.ToAxisAngle( orientationAxis, orientationAngle );
 638
 639         if (position.x > Math::MACHINE_EPSILON_10000 ||
 640             position.y > Math::MACHINE_EPSILON_10000 ||
 641             orientationAxis != Vector3(0.0f, 1.0f, 0.0f) ||
 642             orientationAngle != ANGLE_180 ||
 643             scale != Vector3(1.0f, 1.0f, 1.0f))
 644         {
 645           return;
 646         }
 647       }
 648     }
 649     else
 650     {
 651       return;
 652     }
 653
 654     Rect<int32_t> viewportRect;
 655     if (instruction.mIsViewportSet)
 656     {
 657       const int32_t y = (surfaceRect.height - instruction.mViewport.height) - instruction.mViewport.y;
 658       viewportRect.Set(instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height);
 659       if (viewportRect.IsEmpty() || !viewportRect.IsValid())
 660       {
 661         return; // just skip funny use cases for now, empty viewport means it is set somewhere else
 662       }
 663     }
 664     else
 665     {
 666       viewportRect = surfaceRect;
 667     }
 668
 669     const Matrix* viewMatrix       = instruction.GetViewMatrix(mImpl->renderBufferIndex);
 670     const Matrix* projectionMatrix = instruction.GetProjectionMatrix(mImpl->renderBufferIndex);
 671     if (viewMatrix && projectionMatrix)
 672     {
 673       const RenderListContainer::SizeType count = instruction.RenderListCount();
 674       for (RenderListContainer::SizeType index = 0u; index < count; ++index)
 675       {
 676         const RenderList* renderList = instruction.GetRenderList( index );
 677         if (renderList && !renderList->IsEmpty())
 678         {
 679           const std::size_t count = renderList->Count();
 680           for (uint32_t index = 0u; index < count; ++index)
 681           {
 682             RenderItem& item = renderList->GetItem( index );
 683             // If the item does 3D transformation, do early exit and clean the damaged rect array
 684             if (item.mUpdateSize == Vector3::ZERO)
 685             {
 686               return;
 687             }
 688
 689             Rect<int> rect;
 690             DirtyRect dirtyRect(item.mNode, item.mRenderer, mImpl->frameCount, rect);
 691             // If the item refers to updated node or renderer.
 692             if (item.mIsUpdated ||
 693                 (item.mNode &&
 694                 (item.mNode->Updated() || (item.mRenderer && item.mRenderer->Updated(mImpl->renderBufferIndex, item.mNode)))))
 695             {
 696               item.mIsUpdated = false;
 697               item.mNode->SetUpdated(false);
 698
 699               rect = item.CalculateViewportSpaceAABB(item.mUpdateSize, viewportRect.width, viewportRect.height);
 700               if (rect.IsValid() && rect.Intersect(viewportRect) && !rect.IsEmpty())
 701               {
 702                 const int left = rect.x;
 703                 const int top = rect.y;
 704                 const int right = rect.x + rect.width;
 705                 const int bottom = rect.y + rect.height;
 706                 rect.x = (left / 16) * 16;
 707                 rect.y = (top / 16) * 16;
 708                 rect.width = ((right + 16) / 16) * 16 - rect.x;
 709                 rect.height = ((bottom + 16) / 16) * 16 - rect.y;
 710
 711                 // Found valid dirty rect.
 712                 // 1. Insert it in the sorted array of the dirty rects.
 713                 // 2. Mark the related dirty rects as visited so they will not be removed below.
 714                 // 3. Keep only last 3 dirty rects for the same node and renderer (Tizen uses 3 back buffers, Ubuntu 1).
 715                 dirtyRect.rect = rect;
 716                 auto dirtyRectPos = std::lower_bound(itemsDirtyRects.begin(), itemsDirtyRects.end(), dirtyRect);
 717                 dirtyRectPos = itemsDirtyRects.insert(dirtyRectPos, dirtyRect);
 718
 719                 int c = 1;
 720                 while (++dirtyRectPos != itemsDirtyRects.end())
 721                 {
 722                   if (dirtyRectPos->node != item.mNode || dirtyRectPos->renderer != item.mRenderer)
 723                   {
 724                     break;
 725                   }
 726
 727                   dirtyRectPos->visited = true;
 728                   Rect<int>& dirtRect = dirtyRectPos->rect;
 729                   rect.Merge(dirtRect);
 730
 731                   c++;
 732                   if (c > 3) // no more then 3 previous rects
 733                   {
 734                     itemsDirtyRects.erase(dirtyRectPos);
 735                     break;
 736                   }
 737                 }
 738
 739                 damagedRects.push_back(rect);
 740               }
 741             }
 742             else
 743             {
 744               // 1. The item is not dirty, the node and renderer referenced by the item are still exist.
 745               // 2. Mark the related dirty rects as visited so they will not be removed below.
 746               auto dirtyRectPos = std::lower_bound(itemsDirtyRects.begin(), itemsDirtyRects.end(), dirtyRect);
 747               while (dirtyRectPos != itemsDirtyRects.end())
 748               {
 749                 if (dirtyRectPos->node != item.mNode || dirtyRectPos->renderer != item.mRenderer)
 750                 {
 751                   break;
 752                 }
 753
 754                 dirtyRectPos->visited = true;
 755                 dirtyRectPos++;
 756               }
 757             }
 758           }
 759         }
 760       }
 761     }
 762   }
 763
 764   // Check removed nodes or removed renderers dirty rects
 765   auto i = itemsDirtyRects.begin();
 766   auto j = itemsDirtyRects.begin();
 767   while (i != itemsDirtyRects.end())
 768   {
 769     if (i->visited)
 770     {
 771       *j++ = *i;
 772     }
 773     else
 774     {
 775       Rect<int>& dirtRect = i->rect;
 776       damagedRects.push_back(dirtRect);
 777     }
 778     i++;
 779   }
 780
 781   itemsDirtyRects.resize(j - itemsDirtyRects.begin());
 782   damagedRectCleaner.SetCleanOnReturn(false);
 783 }
 784
 785 void RenderManager::RenderScene( Integration::RenderStatus& status, Integration::Scene& scene, bool renderToFbo )
 786 {
 787   Rect<int> clippingRect;
 788   RenderScene( status, scene, renderToFbo, clippingRect);
 789 }
 790
 791 void RenderManager::RenderScene( Integration::RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect )
 792 {
 793   Internal::Scene& sceneInternal = GetImplementation( scene );
 794   SceneGraph::Scene* sceneObject = sceneInternal.GetSceneObject();
 795
 796   uint32_t count = sceneObject->GetRenderInstructions().Count( mImpl->renderBufferIndex );
 797
 798   for( uint32_t i = 0; i < count; ++i )
 799   {
 800     RenderInstruction& instruction = sceneObject->GetRenderInstructions().At( mImpl->renderBufferIndex, i );
 801
 802     if ( ( renderToFbo && !instruction.mFrameBuffer ) || ( !renderToFbo && instruction.mFrameBuffer ) )
 803     {
 804       continue; // skip
 805     }
 806
 807     // Mark that we will require a post-render step to be performed (includes swap-buffers).
 808     status.SetNeedsPostRender( true );
 809
 810     Rect<int32_t> viewportRect;
 811     Vector4   clearColor;
 812
 813     if ( instruction.mIsClearColorSet )
 814     {
 815       clearColor = instruction.mClearColor;
 816     }
 817     else
 818     {
 819       clearColor = Dali::RenderTask::DEFAULT_CLEAR_COLOR;
 820     }
 821
 822     Rect<int32_t> surfaceRect = mImpl->defaultSurfaceRect;
 823     Integration::DepthBufferAvailable depthBufferAvailable = mImpl->depthBufferAvailable;
 824     Integration::StencilBufferAvailable stencilBufferAvailable = mImpl->stencilBufferAvailable;
 825
 826     if ( instruction.mFrameBuffer )
 827     {
 828       // offscreen buffer
 829       if ( mImpl->currentContext != &mImpl->context )
 830       {
 831         // Switch to shared context for off-screen buffer
 832         mImpl->currentContext = &mImpl->context;
 833
 834         if ( mImpl->currentContext->IsSurfacelessContextSupported() )
 835         {
 836           mImpl->glContextHelperAbstraction.MakeSurfacelessContextCurrent();
 837         }
 838
 839         // Clear the current cached program when the context is switched
 840         mImpl->programController.ClearCurrentProgram();
 841       }
 842     }
 843     else
 844     {
 845       if ( mImpl->currentContext->IsSurfacelessContextSupported() )
 846       {
 847         if ( mImpl->currentContext != sceneObject->GetContext() )
 848         {
 849           // Switch the correct context if rendering to a surface
 850           mImpl->currentContext = sceneObject->GetContext();
 851
 852           // Clear the current cached program when the context is switched
 853           mImpl->programController.ClearCurrentProgram();
 854         }
 855       }
 856
 857       surfaceRect = Rect<int32_t>( 0, 0, static_cast<int32_t>( scene.GetSize().width ), static_cast<int32_t>( scene.GetSize().height ) );
 858     }
 859
 860     // Make sure that GL context must be created
 861      mImpl->currentContext->GlContextCreated();
 862
 863     // reset the program matrices for all programs once per frame
 864     // this ensures we will set view and projection matrix once per program per camera
 865     mImpl->programController.ResetProgramMatrices();
 866
 867     if( instruction.mFrameBuffer )
 868     {
 869       instruction.mFrameBuffer->Bind( *mImpl->currentContext );
 870
 871       // For each offscreen buffer, update the dependency list with the new texture id used by this frame buffer.
 872       for (unsigned int i0 = 0, i1 = instruction.mFrameBuffer->GetColorAttachmentCount(); i0 < i1; ++i0)
 873       {
 874         mImpl->textureDependencyList.PushBack( instruction.mFrameBuffer->GetTextureId(i0) );
 875       }
 876     }
 877     else
 878     {
 879       mImpl->currentContext->BindFramebuffer( GL_FRAMEBUFFER, 0u );
 880     }
 881
 882     if ( !instruction.mFrameBuffer )
 883     {
 884       mImpl->currentContext->Viewport( surfaceRect.x,
 885                                        surfaceRect.y,
 886                                        surfaceRect.width,
 887                                        surfaceRect.height );
 888     }
 889
 890     // Clear the entire color, depth and stencil buffers for the default framebuffer, if required.
 891     // It is important to clear all 3 buffers when they are being used, for performance on deferred renderers
 892     // e.g. previously when the depth & stencil buffers were NOT cleared, it caused the DDK to exceed a "vertex count limit",
 893     // and then stall. That problem is only noticeable when rendering a large number of vertices per frame.
 894     GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
 895
 896     mImpl->currentContext->ColorMask( true );
 897
 898     if( depthBufferAvailable == Integration::DepthBufferAvailable::TRUE )
 899     {
 900       mImpl->currentContext->DepthMask( true );
 901       clearMask |= GL_DEPTH_BUFFER_BIT;
 902     }
 903
 904     if( stencilBufferAvailable == Integration::StencilBufferAvailable::TRUE)
 905     {
 906       mImpl->currentContext->ClearStencil( 0 );
 907       mImpl->currentContext->StencilMask( 0xFF ); // 8 bit stencil mask, all 1's
 908       clearMask |= GL_STENCIL_BUFFER_BIT;
 909     }
 910
 911     if( !instruction.mIgnoreRenderToFbo && ( instruction.mFrameBuffer != nullptr ) )
 912     {
 913       // Offscreen buffer rendering
 914       if ( instruction.mIsViewportSet )
 915       {
 916         // For glViewport the lower-left corner is (0,0)
 917         const int32_t y = ( instruction.mFrameBuffer->GetHeight() - instruction.mViewport.height ) - instruction.mViewport.y;
 918         viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 919       }
 920       else
 921       {
 922         viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
 923       }
 924     }
 925     else // No Offscreen frame buffer rendering
 926     {
 927       // Check whether a viewport is specified, otherwise the full surface size is used
 928       if ( instruction.mIsViewportSet )
 929       {
 930         // For glViewport the lower-left corner is (0,0)
 931         const int32_t y = ( surfaceRect.height - instruction.mViewport.height ) - instruction.mViewport.y;
 932         viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 933       }
 934       else
 935       {
 936         viewportRect = surfaceRect;
 937       }
 938     }
 939
 940     bool clearFullFrameRect = true;
 941     if( instruction.mFrameBuffer != nullptr )
 942     {
 943       Viewport frameRect( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
 944       clearFullFrameRect = ( frameRect == viewportRect );
 945     }
 946     else
 947     {
 948       clearFullFrameRect = ( surfaceRect == viewportRect );
 949     }
 950
 951     if (!clippingRect.IsEmpty())
 952     {
 953       if (!clippingRect.Intersect(viewportRect))
 954       {
 955         DALI_LOG_ERROR("Invalid clipping rect %d %d %d %d\n", clippingRect.x, clippingRect.y, clippingRect.width, clippingRect.height);
 956         clippingRect = Rect<int>();
 957       }
 958       clearFullFrameRect = false;
 959     }
 960
 961     mImpl->currentContext->Viewport(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
 962
 963     if (instruction.mIsClearColorSet)
 964     {
 965       mImpl->currentContext->ClearColor(clearColor.r,
 966                                         clearColor.g,
 967                                         clearColor.b,
 968                                         clearColor.a);
 969       if (!clearFullFrameRect)
 970       {
 971         if (!clippingRect.IsEmpty())
 972         {
 973           mImpl->currentContext->SetScissorTest(true);
 974           mImpl->currentContext->Scissor(clippingRect.x, clippingRect.y, clippingRect.width, clippingRect.height);
 975           mImpl->currentContext->Clear(clearMask, Context::FORCE_CLEAR);
 976           mImpl->currentContext->SetScissorTest(false);
 977         }
 978         else
 979         {
 980           mImpl->currentContext->SetScissorTest(true);
 981           mImpl->currentContext->Scissor(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
 982           mImpl->currentContext->Clear(clearMask, Context::FORCE_CLEAR);
 983           mImpl->currentContext->SetScissorTest(false);
 984         }
 985       }
 986       else
 987       {
 988         mImpl->currentContext->SetScissorTest(false);
 989         mImpl->currentContext->Clear(clearMask, Context::FORCE_CLEAR);
 990       }
 991     }
 992
 993     // Clear the list of bound textures
 994     mImpl->boundTextures.Clear();
 995
 996     mImpl->renderAlgorithms.ProcessRenderInstruction(
 997         instruction,
 998         *mImpl->currentContext,
 999         mImpl->renderBufferIndex,
1000         depthBufferAvailable,
1001         stencilBufferAvailable,
1002         mImpl->boundTextures,
1003         clippingRect );
1004
1005     // Synchronise the FBO/Texture access when there are multiple contexts
1006     if ( mImpl->currentContext->IsSurfacelessContextSupported() )
1007     {
1008       // Check whether any binded texture is in the dependency list
1009       bool textureFound = false;
1010
1011       if ( mImpl->boundTextures.Count() > 0u && mImpl->textureDependencyList.Count() > 0u )
1012       {
1013         for ( auto textureId : mImpl->textureDependencyList )
1014         {
1015
1016           textureFound = std::find_if( mImpl->boundTextures.Begin(), mImpl->boundTextures.End(),
1017                                        [textureId]( GLuint id )
1018                                        {
1019                                          return textureId == id;
1020                                        } ) != mImpl->boundTextures.End();
1021         }
1022       }
1023
1024       if ( textureFound )
1025       {
1026         if ( instruction.mFrameBuffer )
1027         {
1028           // For off-screen buffer
1029
1030           // Wait until all rendering calls for the currently context are executed
1031           mImpl->glContextHelperAbstraction.WaitClient();
1032
1033           // Clear the dependency list
1034           mImpl->textureDependencyList.Clear();
1035         }
1036         else
1037         {
1038           // Worker thread lambda function
1039           auto& glContextHelperAbstraction = mImpl->glContextHelperAbstraction;
1040           auto workerFunction = [&glContextHelperAbstraction]( int workerThread )
1041           {
1042             // Switch to the shared context in the worker thread
1043             glContextHelperAbstraction.MakeSurfacelessContextCurrent();
1044
1045             // Wait until all rendering calls for the shared context are executed
1046             glContextHelperAbstraction.WaitClient();
1047
1048             // Must clear the context in the worker thread
1049             // Otherwise the shared context cannot be switched to from the render thread
1050             glContextHelperAbstraction.MakeContextNull();
1051           };
1052
1053           auto future = mImpl->threadPool->SubmitTask( 0u, workerFunction );
1054           if ( future )
1055           {
1056             mImpl->threadPool->Wait();
1057
1058             // Clear the dependency list
1059             mImpl->textureDependencyList.Clear();
1060           }
1061         }
1062       }
1063     }
1064
1065     if( instruction.mRenderTracker && instruction.mFrameBuffer )
1066     {
1067       // This will create a sync object every frame this render tracker
1068       // is alive (though it should be now be created only for
1069       // render-once render tasks)
1070       instruction.mRenderTracker->CreateSyncObject( mImpl->glSyncAbstraction );
1071       instruction.mRenderTracker = nullptr; // Only create once.
1072     }
1073
1074     if ( renderToFbo )
1075     {
1076       mImpl->currentContext->Flush();
1077     }
1078   }
1079
1080   GLenum attachments[] = { GL_DEPTH, GL_STENCIL };
1081   mImpl->currentContext->InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
1082 }
1083
1084 void RenderManager::PostRender( bool uploadOnly )
1085 {
1086   if ( !uploadOnly )
1087   {
1088     if ( mImpl->currentContext->IsSurfacelessContextSupported() )
1089     {
1090       mImpl->glContextHelperAbstraction.MakeSurfacelessContextCurrent();
1091     }
1092
1093     GLenum attachments[] = { GL_DEPTH, GL_STENCIL };
1094     mImpl->context.InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
1095   }
1096
1097   //Notify RenderGeometries that rendering has finished
1098   for ( auto&& iter : mImpl->geometryContainer )
1099   {
1100     iter->OnRenderFinished();
1101   }
1102
1103   mImpl->UpdateTrackers();
1104
1105
1106   uint32_t count = 0u;
1107   for( uint32_t i = 0; i < mImpl->sceneContainer.size(); ++i )
1108   {
1109     count += mImpl->sceneContainer[i]->GetRenderInstructions().Count( mImpl->renderBufferIndex );
1110   }
1111
1112   const bool haveInstructions = count > 0u;
1113
1114   // If this frame was rendered due to instructions existing, we mark this so we know to clear the next frame.
1115   mImpl->lastFrameWasRendered = haveInstructions;
1116
1117   /**
1118    * The rendering has finished; swap to the next buffer.
1119    * Ideally the update has just finished using this buffer; otherwise the render thread
1120    * should block until the update has finished.
1121    */
1122   mImpl->renderBufferIndex = (0 != mImpl->renderBufferIndex) ? 0 : 1;
1123
1124   DALI_PRINT_RENDER_END();
1125 }
1126
1127 } // namespace SceneGraph
1128
1129 } // namespace Internal
1130
1131 } // namespace Dali