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   class DamagedRectsCleaner
 579   {
 580   public:
 581     DamagedRectsCleaner(std::vector<Rect<int>>& damagedRects)
 582     : mDamagedRects(damagedRects),
 583       mCleanOnReturn(true)
 584     {
 585     }
 586
 587     void SetCleanOnReturn(bool cleanOnReturn)
 588     {
 589       mCleanOnReturn = cleanOnReturn;
 590     }
 591
 592     ~DamagedRectsCleaner()
 593     {
 594       if (mCleanOnReturn)
 595       {
 596         mDamagedRects.clear();
 597       }
 598     }
 599
 600   private:
 601     std::vector<Rect<int>>& mDamagedRects;
 602     bool mCleanOnReturn;
 603   };
 604
 605   Rect<int32_t> surfaceRect = Rect<int32_t>(0, 0, static_cast<int32_t>( scene.GetSize().width ), static_cast<int32_t>( scene.GetSize().height ));
 606
 607   // Clean collected dirty/damaged rects on exit if 3d layer or 3d node or other conditions.
 608   DamagedRectsCleaner damagedRectCleaner(damagedRects);
 609
 610
 611
 612   Internal::Scene& sceneInternal = GetImplementation(scene);
 613   SceneGraph::Scene* sceneObject = sceneInternal.GetSceneObject();
 614
 615   // Mark previous dirty rects in the sorted array. The array is already sorted by node and renderer, frame number.
 616   // so you don't need to sort: std::stable_sort(itemsDirtyRects.begin(), itemsDirtyRects.end());
 617   std::vector<DirtyRect>& itemsDirtyRects = sceneInternal.GetItemsDirtyRects();
 618   for (DirtyRect& dirtyRect : itemsDirtyRects)
 619   {
 620     dirtyRect.visited = false;
 621   }
 622
 623   uint32_t count = sceneObject->GetRenderInstructions().Count( mImpl->renderBufferIndex );
 624   for (uint32_t i = 0; i < count; ++i)
 625   {
 626     RenderInstruction& instruction = sceneObject->GetRenderInstructions().At( mImpl->renderBufferIndex, i );
 627
 628     if (instruction.mFrameBuffer)
 629     {
 630       return; // TODO: reset, we don't deal with render tasks with framebuffers (for now)
 631     }
 632
 633     const Camera* camera = instruction.GetCamera();
 634     if (camera->mType == Camera::DEFAULT_TYPE && camera->mTargetPosition == Camera::DEFAULT_TARGET_POSITION)
 635     {
 636       const Node* node = instruction.GetCamera()->GetNode();
 637       if (node)
 638       {
 639         Vector3 position;
 640         Vector3 scale;
 641         Quaternion orientation;
 642         node->GetWorldMatrix(mImpl->renderBufferIndex).GetTransformComponents(position, orientation, scale);
 643
 644         Vector3 orientationAxis;
 645         Radian orientationAngle;
 646         orientation.ToAxisAngle( orientationAxis, orientationAngle );
 647
 648         if (position.x > Math::MACHINE_EPSILON_10000 ||
 649             position.y > Math::MACHINE_EPSILON_10000 ||
 650             orientationAxis != Vector3(0.0f, 1.0f, 0.0f) ||
 651             orientationAngle != ANGLE_180 ||
 652             scale != Vector3(1.0f, 1.0f, 1.0f))
 653         {
 654           return;
 655         }
 656       }
 657     }
 658     else
 659     {
 660       return;
 661     }
 662
 663     Rect<int32_t> viewportRect;
 664     if (instruction.mIsViewportSet)
 665     {
 666       const int32_t y = (surfaceRect.height - instruction.mViewport.height) - instruction.mViewport.y;
 667       viewportRect.Set(instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height);
 668       if (viewportRect.IsEmpty() || !viewportRect.IsValid())
 669       {
 670         return; // just skip funny use cases for now, empty viewport means it is set somewhere else
 671       }
 672     }
 673     else
 674     {
 675       viewportRect = surfaceRect;
 676     }
 677
 678     const Matrix* viewMatrix       = instruction.GetViewMatrix(mImpl->renderBufferIndex);
 679     const Matrix* projectionMatrix = instruction.GetProjectionMatrix(mImpl->renderBufferIndex);
 680     if (viewMatrix && projectionMatrix)
 681     {
 682       const RenderListContainer::SizeType count = instruction.RenderListCount();
 683       for (RenderListContainer::SizeType index = 0u; index < count; ++index)
 684       {
 685         const RenderList* renderList = instruction.GetRenderList( index );
 686         if (renderList && !renderList->IsEmpty())
 687         {
 688           const std::size_t count = renderList->Count();
 689           for (uint32_t index = 0u; index < count; ++index)
 690           {
 691             RenderItem& item = renderList->GetItem( index );
 692             // If the item does 3D transformation, do early exit and clean the damaged rect array
 693             if (item.mUpdateSize == Vector3::ZERO)
 694             {
 695               return;
 696             }
 697
 698             Rect<int> rect;
 699             DirtyRect dirtyRect(item.mNode, item.mRenderer, mImpl->frameCount, rect);
 700             // If the item refers to updated node or renderer.
 701             if (item.mIsUpdated ||
 702                 (item.mNode &&
 703                 (item.mNode->Updated() || (item.mRenderer && item.mRenderer->Updated(mImpl->renderBufferIndex, item.mNode)))))
 704             {
 705               item.mIsUpdated = false;
 706               item.mNode->SetUpdated(false);
 707
 708               rect = item.CalculateViewportSpaceAABB(item.mUpdateSize, viewportRect.width, viewportRect.height);
 709               if (rect.IsValid() && rect.Intersect(viewportRect) && !rect.IsEmpty())
 710               {
 711                 const int left = rect.x;
 712                 const int top = rect.y;
 713                 const int right = rect.x + rect.width;
 714                 const int bottom = rect.y + rect.height;
 715                 rect.x = (left / 16) * 16;
 716                 rect.y = (top / 16) * 16;
 717                 rect.width = ((right + 16) / 16) * 16 - rect.x;
 718                 rect.height = ((bottom + 16) / 16) * 16 - rect.y;
 719
 720                 // Found valid dirty rect.
 721                 // 1. Insert it in the sorted array of the dirty rects.
 722                 // 2. Mark the related dirty rects as visited so they will not be removed below.
 723                 // 3. Keep only last 3 dirty rects for the same node and renderer (Tizen uses 3 back buffers, Ubuntu 1).
 724                 dirtyRect.rect = rect;
 725                 auto dirtyRectPos = std::lower_bound(itemsDirtyRects.begin(), itemsDirtyRects.end(), dirtyRect);
 726                 dirtyRectPos = itemsDirtyRects.insert(dirtyRectPos, dirtyRect);
 727
 728                 int c = 1;
 729                 while (++dirtyRectPos != itemsDirtyRects.end())
 730                 {
 731                   if (dirtyRectPos->node != item.mNode || dirtyRectPos->renderer != item.mRenderer)
 732                   {
 733                     break;
 734                   }
 735
 736                   dirtyRectPos->visited = true;
 737                   Rect<int>& dirtRect = dirtyRectPos->rect;
 738                   rect.Merge(dirtRect);
 739
 740                   c++;
 741                   if (c > 3) // no more then 3 previous rects
 742                   {
 743                     itemsDirtyRects.erase(dirtyRectPos);
 744                     break;
 745                   }
 746                 }
 747
 748                 damagedRects.push_back(rect);
 749               }
 750             }
 751             else
 752             {
 753               // 1. The item is not dirty, the node and renderer referenced by the item are still exist.
 754               // 2. Mark the related dirty rects as visited so they will not be removed below.
 755               auto dirtyRectPos = std::lower_bound(itemsDirtyRects.begin(), itemsDirtyRects.end(), dirtyRect);
 756               while (dirtyRectPos != itemsDirtyRects.end())
 757               {
 758                 if (dirtyRectPos->node != item.mNode || dirtyRectPos->renderer != item.mRenderer)
 759                 {
 760                   break;
 761                 }
 762
 763                 dirtyRectPos->visited = true;
 764                 dirtyRectPos++;
 765               }
 766             }
 767           }
 768         }
 769       }
 770     }
 771   }
 772
 773   // Check removed nodes or removed renderers dirty rects
 774   auto i = itemsDirtyRects.begin();
 775   auto j = itemsDirtyRects.begin();
 776   while (i != itemsDirtyRects.end())
 777   {
 778     if (i->visited)
 779     {
 780       *j++ = *i;
 781     }
 782     else
 783     {
 784       Rect<int>& dirtRect = i->rect;
 785       damagedRects.push_back(dirtRect);
 786     }
 787     i++;
 788   }
 789
 790   itemsDirtyRects.resize(j - itemsDirtyRects.begin());
 791   damagedRectCleaner.SetCleanOnReturn(false);
 792 }
 793
 794 void RenderManager::RenderScene( Integration::RenderStatus& status, Integration::Scene& scene, bool renderToFbo )
 795 {
 796   Rect<int> clippingRect;
 797   RenderScene( status, scene, renderToFbo, clippingRect);
 798 }
 799
 800 void RenderManager::RenderScene( Integration::RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect )
 801 {
 802   Internal::Scene& sceneInternal = GetImplementation( scene );
 803   SceneGraph::Scene* sceneObject = sceneInternal.GetSceneObject();
 804
 805   uint32_t count = sceneObject->GetRenderInstructions().Count( mImpl->renderBufferIndex );
 806
 807   for( uint32_t i = 0; i < count; ++i )
 808   {
 809     RenderInstruction& instruction = sceneObject->GetRenderInstructions().At( mImpl->renderBufferIndex, i );
 810
 811     if ( ( renderToFbo && !instruction.mFrameBuffer ) || ( !renderToFbo && instruction.mFrameBuffer ) )
 812     {
 813       continue; // skip
 814     }
 815
 816     // Mark that we will require a post-render step to be performed (includes swap-buffers).
 817     status.SetNeedsPostRender( true );
 818
 819     Rect<int32_t> viewportRect;
 820     Vector4   clearColor;
 821
 822     if ( instruction.mIsClearColorSet )
 823     {
 824       clearColor = instruction.mClearColor;
 825     }
 826     else
 827     {
 828       clearColor = Dali::RenderTask::DEFAULT_CLEAR_COLOR;
 829     }
 830
 831     Rect<int32_t> surfaceRect = mImpl->defaultSurfaceRect;
 832     Integration::DepthBufferAvailable depthBufferAvailable = mImpl->depthBufferAvailable;
 833     Integration::StencilBufferAvailable stencilBufferAvailable = mImpl->stencilBufferAvailable;
 834     int surfaceOrientation = sceneInternal.GetSurfaceOrientation();
 835
 836     if ( instruction.mFrameBuffer )
 837     {
 838       // offscreen buffer
 839       if ( mImpl->currentContext != &mImpl->context )
 840       {
 841         // Switch to shared context for off-screen buffer
 842         mImpl->currentContext = &mImpl->context;
 843
 844         if ( mImpl->currentContext->IsSurfacelessContextSupported() )
 845         {
 846           mImpl->glContextHelperAbstraction.MakeSurfacelessContextCurrent();
 847         }
 848
 849         // Clear the current cached program when the context is switched
 850         mImpl->programController.ClearCurrentProgram();
 851       }
 852     }
 853     else
 854     {
 855       if ( mImpl->currentContext->IsSurfacelessContextSupported() )
 856       {
 857         if ( mImpl->currentContext != sceneObject->GetContext() )
 858         {
 859           // Switch the correct context if rendering to a surface
 860           mImpl->currentContext = sceneObject->GetContext();
 861
 862           // Clear the current cached program when the context is switched
 863           mImpl->programController.ClearCurrentProgram();
 864         }
 865       }
 866
 867       surfaceRect = Rect<int32_t>( 0, 0, static_cast<int32_t>( scene.GetSize().width ), static_cast<int32_t>( scene.GetSize().height ) );
 868     }
 869
 870     // Make sure that GL context must be created
 871      mImpl->currentContext->GlContextCreated();
 872
 873     // reset the program matrices for all programs once per frame
 874     // this ensures we will set view and projection matrix once per program per camera
 875     mImpl->programController.ResetProgramMatrices();
 876
 877     if( instruction.mFrameBuffer )
 878     {
 879       instruction.mFrameBuffer->Bind( *mImpl->currentContext );
 880
 881       // For each offscreen buffer, update the dependency list with the new texture id used by this frame buffer.
 882       for (unsigned int i0 = 0, i1 = instruction.mFrameBuffer->GetColorAttachmentCount(); i0 < i1; ++i0)
 883       {
 884         mImpl->textureDependencyList.PushBack( instruction.mFrameBuffer->GetTextureId(i0) );
 885       }
 886     }
 887     else
 888     {
 889       mImpl->currentContext->BindFramebuffer( GL_FRAMEBUFFER, 0u );
 890     }
 891
 892     if ( !instruction.mFrameBuffer )
 893     {
 894       mImpl->currentContext->Viewport( surfaceRect.x,
 895                                        surfaceRect.y,
 896                                        surfaceRect.width,
 897                                        surfaceRect.height );
 898     }
 899
 900     // Clear the entire color, depth and stencil buffers for the default framebuffer, if required.
 901     // It is important to clear all 3 buffers when they are being used, for performance on deferred renderers
 902     // e.g. previously when the depth & stencil buffers were NOT cleared, it caused the DDK to exceed a "vertex count limit",
 903     // and then stall. That problem is only noticeable when rendering a large number of vertices per frame.
 904     GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
 905
 906     mImpl->currentContext->ColorMask( true );
 907
 908     if( depthBufferAvailable == Integration::DepthBufferAvailable::TRUE )
 909     {
 910       mImpl->currentContext->DepthMask( true );
 911       clearMask |= GL_DEPTH_BUFFER_BIT;
 912     }
 913
 914     if( stencilBufferAvailable == Integration::StencilBufferAvailable::TRUE)
 915     {
 916       mImpl->currentContext->ClearStencil( 0 );
 917       mImpl->currentContext->StencilMask( 0xFF ); // 8 bit stencil mask, all 1's
 918       clearMask |= GL_STENCIL_BUFFER_BIT;
 919     }
 920
 921     if( !instruction.mIgnoreRenderToFbo && ( instruction.mFrameBuffer != nullptr ) )
 922     {
 923       // Offscreen buffer rendering
 924       if ( instruction.mIsViewportSet )
 925       {
 926         // For glViewport the lower-left corner is (0,0)
 927         const int32_t y = ( instruction.mFrameBuffer->GetHeight() - instruction.mViewport.height ) - instruction.mViewport.y;
 928         viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 929       }
 930       else
 931       {
 932         viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
 933       }
 934       surfaceOrientation = 0;
 935     }
 936     else // No Offscreen frame buffer rendering
 937     {
 938       // Check whether a viewport is specified, otherwise the full surface size is used
 939       if ( instruction.mIsViewportSet )
 940       {
 941         // For glViewport the lower-left corner is (0,0)
 942         const int32_t y = ( surfaceRect.height - instruction.mViewport.height ) - instruction.mViewport.y;
 943         viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 944       }
 945       else
 946       {
 947         viewportRect = surfaceRect;
 948       }
 949     }
 950
 951     // Set surface orientation
 952     mImpl->currentContext->SetSurfaceOrientation(surfaceOrientation);
 953
 954     bool clearFullFrameRect = true;
 955     if( instruction.mFrameBuffer != nullptr )
 956     {
 957       Viewport frameRect( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
 958       clearFullFrameRect = ( frameRect == viewportRect );
 959     }
 960     else
 961     {
 962       clearFullFrameRect = ( surfaceRect == viewportRect );
 963     }
 964
 965     if (!clippingRect.IsEmpty())
 966     {
 967       if (!clippingRect.Intersect(viewportRect))
 968       {
 969         DALI_LOG_ERROR("Invalid clipping rect %d %d %d %d\n", clippingRect.x, clippingRect.y, clippingRect.width, clippingRect.height);
 970         clippingRect = Rect<int>();
 971       }
 972       clearFullFrameRect = false;
 973     }
 974
 975     mImpl->currentContext->Viewport(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
 976
 977     if (instruction.mIsClearColorSet)
 978     {
 979       mImpl->currentContext->ClearColor(clearColor.r,
 980                                         clearColor.g,
 981                                         clearColor.b,
 982                                         clearColor.a);
 983       if (!clearFullFrameRect)
 984       {
 985         if (!clippingRect.IsEmpty())
 986         {
 987           mImpl->currentContext->SetScissorTest(true);
 988           mImpl->currentContext->Scissor(clippingRect.x, clippingRect.y, clippingRect.width, clippingRect.height);
 989           mImpl->currentContext->Clear(clearMask, Context::FORCE_CLEAR);
 990           mImpl->currentContext->SetScissorTest(false);
 991         }
 992         else
 993         {
 994           mImpl->currentContext->SetScissorTest(true);
 995           mImpl->currentContext->Scissor(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
 996           mImpl->currentContext->Clear(clearMask, Context::FORCE_CLEAR);
 997           mImpl->currentContext->SetScissorTest(false);
 998         }
 999       }
1000       else
1001       {
1002         mImpl->currentContext->SetScissorTest(false);
1003         mImpl->currentContext->Clear(clearMask, Context::FORCE_CLEAR);
1004       }
1005     }
1006
1007     // Clear the list of bound textures
1008     mImpl->boundTextures.Clear();
1009
1010     mImpl->renderAlgorithms.ProcessRenderInstruction(
1011         instruction,
1012         *mImpl->currentContext,
1013         mImpl->renderBufferIndex,
1014         depthBufferAvailable,
1015         stencilBufferAvailable,
1016         mImpl->boundTextures,
1017         clippingRect );
1018
1019     // Synchronise the FBO/Texture access when there are multiple contexts
1020     if ( mImpl->currentContext->IsSurfacelessContextSupported() )
1021     {
1022       // Check whether any binded texture is in the dependency list
1023       bool textureFound = false;
1024
1025       if ( mImpl->boundTextures.Count() > 0u && mImpl->textureDependencyList.Count() > 0u )
1026       {
1027         for ( auto textureId : mImpl->textureDependencyList )
1028         {
1029
1030           textureFound = std::find_if( mImpl->boundTextures.Begin(), mImpl->boundTextures.End(),
1031                                        [textureId]( GLuint id )
1032                                        {
1033                                          return textureId == id;
1034                                        } ) != mImpl->boundTextures.End();
1035         }
1036       }
1037
1038       if ( textureFound )
1039       {
1040         if ( instruction.mFrameBuffer )
1041         {
1042           // For off-screen buffer
1043
1044           // Wait until all rendering calls for the currently context are executed
1045           mImpl->glContextHelperAbstraction.WaitClient();
1046
1047           // Clear the dependency list
1048           mImpl->textureDependencyList.Clear();
1049         }
1050         else
1051         {
1052           // Worker thread lambda function
1053           auto& glContextHelperAbstraction = mImpl->glContextHelperAbstraction;
1054           auto workerFunction = [&glContextHelperAbstraction]( int workerThread )
1055           {
1056             // Switch to the shared context in the worker thread
1057             glContextHelperAbstraction.MakeSurfacelessContextCurrent();
1058
1059             // Wait until all rendering calls for the shared context are executed
1060             glContextHelperAbstraction.WaitClient();
1061
1062             // Must clear the context in the worker thread
1063             // Otherwise the shared context cannot be switched to from the render thread
1064             glContextHelperAbstraction.MakeContextNull();
1065           };
1066
1067           auto future = mImpl->threadPool->SubmitTask( 0u, workerFunction );
1068           if ( future )
1069           {
1070             mImpl->threadPool->Wait();
1071
1072             // Clear the dependency list
1073             mImpl->textureDependencyList.Clear();
1074           }
1075         }
1076       }
1077     }
1078
1079     if( instruction.mRenderTracker && instruction.mFrameBuffer )
1080     {
1081       // This will create a sync object every frame this render tracker
1082       // is alive (though it should be now be created only for
1083       // render-once render tasks)
1084       instruction.mRenderTracker->CreateSyncObject( mImpl->glSyncAbstraction );
1085       instruction.mRenderTracker = nullptr; // Only create once.
1086     }
1087
1088     if ( renderToFbo )
1089     {
1090       mImpl->currentContext->Flush();
1091     }
1092   }
1093
1094   GLenum attachments[] = { GL_DEPTH, GL_STENCIL };
1095   mImpl->currentContext->InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
1096
1097 }
1098
1099 void RenderManager::PostRender( bool uploadOnly )
1100 {
1101   if ( !uploadOnly )
1102   {
1103     if ( mImpl->currentContext->IsSurfacelessContextSupported() )
1104     {
1105       mImpl->glContextHelperAbstraction.MakeSurfacelessContextCurrent();
1106     }
1107
1108     GLenum attachments[] = { GL_DEPTH, GL_STENCIL };
1109     mImpl->context.InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
1110   }
1111
1112   //Notify RenderGeometries that rendering has finished
1113   for ( auto&& iter : mImpl->geometryContainer )
1114   {
1115     iter->OnRenderFinished();
1116   }
1117
1118   mImpl->UpdateTrackers();
1119
1120
1121   uint32_t count = 0u;
1122   for( uint32_t i = 0; i < mImpl->sceneContainer.size(); ++i )
1123   {
1124     count += mImpl->sceneContainer[i]->GetRenderInstructions().Count( mImpl->renderBufferIndex );
1125   }
1126
1127   const bool haveInstructions = count > 0u;
1128
1129   // If this frame was rendered due to instructions existing, we mark this so we know to clear the next frame.
1130   mImpl->lastFrameWasRendered = haveInstructions;
1131
1132   /**
1133    * The rendering has finished; swap to the next buffer.
1134    * Ideally the update has just finished using this buffer; otherwise the render thread
1135    * should block until the update has finished.
1136    */
1137   mImpl->renderBufferIndex = (0 != mImpl->renderBufferIndex) ? 0 : 1;
1138
1139   DALI_PRINT_RENDER_END();
1140 }
1141
1142 } // namespace SceneGraph
1143
1144 } // namespace Internal
1145
1146 } // namespace Dali