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