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

   1 /*
   2  * Copyright (c) 2017 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 // INTERNAL INCLUDES
  22 #include <dali/public-api/actors/sampling.h>
  23 #include <dali/public-api/common/dali-common.h>
  24 #include <dali/public-api/common/stage.h>
  25 #include <dali/public-api/render-tasks/render-task.h>
  26 #include <dali/integration-api/debug.h>
  27 #include <dali/integration-api/core.h>
  28 #include <dali/internal/common/owner-pointer.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/common/render-instruction-container.h>
  33 #include <dali/internal/render/common/render-instruction.h>
  34 #include <dali/internal/render/gl-resources/context.h>
  35 #include <dali/internal/render/queue/render-queue.h>
  36 #include <dali/internal/render/renderers/render-frame-buffer.h>
  37 #include <dali/internal/render/renderers/render-geometry.h>
  38 #include <dali/internal/render/renderers/render-renderer.h>
  39 #include <dali/internal/render/renderers/render-sampler.h>
  40 #include <dali/internal/render/shaders/program-controller.h>
  41
  42 namespace Dali
  43 {
  44
  45 namespace Internal
  46 {
  47
  48 namespace SceneGraph
  49 {
  50
  51 typedef OwnerContainer< Render::Renderer* >    RendererOwnerContainer;
  52 typedef RendererOwnerContainer::Iterator       RendererOwnerIter;
  53
  54 typedef OwnerContainer< Render::Geometry* >    GeometryOwnerContainer;
  55 typedef GeometryOwnerContainer::Iterator       GeometryOwnerIter;
  56
  57 typedef OwnerContainer< Render::Sampler* >    SamplerOwnerContainer;
  58 typedef SamplerOwnerContainer::Iterator       SamplerOwnerIter;
  59
  60 typedef OwnerContainer< Render::Texture* >   TextureOwnerContainer;
  61 typedef TextureOwnerContainer::Iterator         TextureOwnerIter;
  62
  63 typedef OwnerContainer< Render::FrameBuffer* >  FrameBufferOwnerContainer;
  64 typedef FrameBufferOwnerContainer::Iterator     FrameBufferOwnerIter;
  65
  66 typedef OwnerContainer< Render::PropertyBuffer* > PropertyBufferOwnerContainer;
  67 typedef PropertyBufferOwnerContainer::Iterator    PropertyBufferOwnerIter;
  68
  69 typedef OwnerContainer< Render::RenderTracker* > RenderTrackerContainer;
  70 typedef RenderTrackerContainer::Iterator         RenderTrackerIter;
  71 typedef RenderTrackerContainer::ConstIterator    RenderTrackerConstIter;
  72
  73 /**
  74  * Structure to contain internal data
  75  */
  76 struct RenderManager::Impl
  77 {
  78   Impl( Integration::GlAbstraction& glAbstraction,
  79         Integration::GlSyncAbstraction& glSyncAbstraction )
  80   : context( glAbstraction ),
  81     glSyncAbstraction( glSyncAbstraction ),
  82     renderQueue(),
  83     instructions(),
  84     backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
  85     frameCount( 0 ),
  86     renderBufferIndex( SceneGraphBuffers::INITIAL_UPDATE_BUFFER_INDEX ),
  87     defaultSurfaceRect(),
  88     rendererContainer(),
  89     samplerContainer(),
  90     textureContainer(),
  91     frameBufferContainer(),
  92     lastFrameWasRendered( false ),
  93     programController( glAbstraction )
  94   {
  95   }
  96
  97   ~Impl()
  98   {
  99   }
 100
 101   void AddRenderTracker( Render::RenderTracker* renderTracker )
 102   {
 103     DALI_ASSERT_DEBUG( renderTracker != NULL );
 104     mRenderTrackers.PushBack( renderTracker );
 105   }
 106
 107   void RemoveRenderTracker( Render::RenderTracker* renderTracker )
 108   {
 109     mRenderTrackers.EraseObject( renderTracker );
 110   }
 111
 112   void UpdateTrackers()
 113   {
 114     for(RenderTrackerIter iter = mRenderTrackers.Begin(), end = mRenderTrackers.End(); iter != end; ++iter)
 115     {
 116       (*iter)->PollSyncObject();
 117     }
 118   }
 119
 120   // the order is important for destruction,
 121   // programs are owned by context at the moment.
 122   Context                       context;                  ///< holds the GL state
 123   Integration::GlSyncAbstraction& glSyncAbstraction;      ///< GL sync abstraction
 124   RenderQueue                   renderQueue;              ///< A message queue for receiving messages from the update-thread.
 125
 126   // Render instructions describe what should be rendered during RenderManager::Render()
 127   // Owned by RenderManager. Update manager updates instructions for the next frame while we render the current one
 128   RenderInstructionContainer    instructions;
 129
 130   Vector4                       backgroundColor;          ///< The glClear color used at the beginning of each frame.
 131
 132   unsigned int                  frameCount;               ///< The current frame count
 133   BufferIndex                   renderBufferIndex;        ///< The index of the buffer to read from; this is opposite of the "update" buffer
 134
 135   Rect<int>                     defaultSurfaceRect;       ///< Rectangle for the default surface we are rendering to
 136
 137   RendererOwnerContainer        rendererContainer;        ///< List of owned renderers
 138   SamplerOwnerContainer         samplerContainer;         ///< List of owned samplers
 139   TextureOwnerContainer         textureContainer;         ///< List of owned textures
 140   FrameBufferOwnerContainer     frameBufferContainer;     ///< List of owned framebuffers
 141   PropertyBufferOwnerContainer  propertyBufferContainer;  ///< List of owned property buffers
 142   GeometryOwnerContainer        geometryContainer;        ///< List of owned Geometries
 143
 144   bool                          lastFrameWasRendered;     ///< Keeps track of the last frame being rendered due to having render instructions
 145
 146   RenderTrackerContainer        mRenderTrackers;          ///< List of render trackers
 147
 148   ProgramController             programController;        ///< Owner of the GL programs
 149
 150 };
 151
 152 RenderManager* RenderManager::New( Integration::GlAbstraction& glAbstraction,
 153                                    Integration::GlSyncAbstraction& glSyncAbstraction )
 154 {
 155   RenderManager* manager = new RenderManager;
 156   manager->mImpl = new Impl( glAbstraction,
 157                              glSyncAbstraction );
 158   return manager;
 159 }
 160
 161 RenderManager::RenderManager()
 162 : mImpl(NULL)
 163 {
 164 }
 165
 166 RenderManager::~RenderManager()
 167 {
 168   delete mImpl;
 169 }
 170
 171 RenderQueue& RenderManager::GetRenderQueue()
 172 {
 173   return mImpl->renderQueue;
 174 }
 175
 176 void RenderManager::ContextCreated()
 177 {
 178   mImpl->context.GlContextCreated();
 179   mImpl->programController.GlContextCreated();
 180
 181   // renderers, textures and gpu buffers cannot reinitialize themselves
 182   // so they rely on someone reloading the data for them
 183 }
 184
 185 void RenderManager::ContextDestroyed()
 186 {
 187   mImpl->context.GlContextDestroyed();
 188   mImpl->programController.GlContextDestroyed();
 189
 190   //Inform textures
 191   for( TextureOwnerIter iter = mImpl->textureContainer.Begin(); iter != mImpl->textureContainer.End(); ++iter )
 192   {
 193     (*iter)->GlContextDestroyed();
 194   }
 195
 196   //Inform framebuffers
 197   for( FrameBufferOwnerIter iter = mImpl->frameBufferContainer.Begin(); iter != mImpl->frameBufferContainer.End(); ++iter )
 198   {
 199     (*iter)->GlContextDestroyed();
 200   }
 201
 202   // inform renderers
 203   RendererOwnerContainer::Iterator end = mImpl->rendererContainer.End();
 204   RendererOwnerContainer::Iterator iter = mImpl->rendererContainer.Begin();
 205   for( ; iter != end; ++iter )
 206   {
 207     GlResourceOwner* renderer = *iter;
 208     renderer->GlContextDestroyed(); // Clear up vertex buffers
 209   }
 210 }
 211
 212 void RenderManager::SetShaderSaver( ShaderSaver& upstream )
 213 {
 214   mImpl->programController.SetShaderSaver( upstream );
 215 }
 216
 217 RenderInstructionContainer& RenderManager::GetRenderInstructionContainer()
 218 {
 219   return mImpl->instructions;
 220 }
 221
 222 void RenderManager::SetBackgroundColor( const Vector4& color )
 223 {
 224   mImpl->backgroundColor = color;
 225 }
 226
 227 void RenderManager::SetDefaultSurfaceRect(const Rect<int>& rect)
 228 {
 229   mImpl->defaultSurfaceRect = rect;
 230 }
 231
 232 void RenderManager::AddRenderer( OwnerPointer< Render::Renderer >& renderer )
 233 {
 234   // Initialize the renderer as we are now in render thread
 235   renderer->Initialize( mImpl->context );
 236
 237   mImpl->rendererContainer.PushBack( renderer.Release() );
 238 }
 239
 240 void RenderManager::RemoveRenderer( Render::Renderer* renderer )
 241 {
 242   mImpl->rendererContainer.EraseObject( renderer );
 243 }
 244
 245 void RenderManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
 246 {
 247   mImpl->samplerContainer.PushBack( sampler.Release() );
 248 }
 249
 250 void RenderManager::RemoveSampler( Render::Sampler* sampler )
 251 {
 252   mImpl->samplerContainer.EraseObject( sampler );
 253 }
 254
 255 void RenderManager::AddTexture( OwnerPointer< Render::Texture >& texture )
 256 {
 257   texture->Initialize( mImpl->context );
 258   mImpl->textureContainer.PushBack( texture.Release() );
 259 }
 260
 261 void RenderManager::RemoveTexture( Render::Texture* texture )
 262 {
 263   DALI_ASSERT_DEBUG( NULL != texture );
 264
 265   TextureOwnerContainer& textures = mImpl->textureContainer;
 266
 267   // Find the texture
 268   for ( TextureOwnerIter iter = textures.Begin(); iter != textures.End(); ++iter )
 269   {
 270     if ( *iter == texture )
 271     {
 272       texture->Destroy( mImpl->context );
 273       textures.Erase( iter ); // Texture found; now destroy it
 274       break;
 275     }
 276   }
 277 }
 278
 279 void RenderManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
 280 {
 281   texture->Upload( mImpl->context, pixelData, params );
 282 }
 283
 284 void RenderManager::GenerateMipmaps( Render::Texture* texture )
 285 {
 286   texture->GenerateMipmaps( mImpl->context );
 287 }
 288
 289 void RenderManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
 290 {
 291   sampler->mMinificationFilter = static_cast<Dali::FilterMode::Type>(minFilterMode);
 292   sampler->mMagnificationFilter = static_cast<Dali::FilterMode::Type>(magFilterMode );
 293 }
 294
 295 void RenderManager::SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
 296 {
 297   sampler->mRWrapMode = static_cast<Dali::WrapMode::Type>(rWrapMode);
 298   sampler->mSWrapMode = static_cast<Dali::WrapMode::Type>(sWrapMode);
 299   sampler->mTWrapMode = static_cast<Dali::WrapMode::Type>(tWrapMode);
 300 }
 301
 302 void RenderManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
 303 {
 304   mImpl->frameBufferContainer.PushBack( frameBuffer );
 305   frameBuffer->Initialize(mImpl->context);
 306 }
 307
 308 void RenderManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer )
 309 {
 310   DALI_ASSERT_DEBUG( NULL != frameBuffer );
 311
 312   FrameBufferOwnerContainer& framebuffers = mImpl->frameBufferContainer;
 313
 314   // Find the sampler
 315   for ( FrameBufferOwnerIter iter = framebuffers.Begin(); iter != framebuffers.End(); ++iter )
 316   {
 317     if ( *iter == frameBuffer )
 318     {
 319       frameBuffer->Destroy( mImpl->context );
 320       framebuffers.Erase( iter ); // frameBuffer found; now destroy it
 321       break;
 322     }
 323   }
 324 }
 325
 326 void RenderManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
 327 {
 328   frameBuffer->AttachColorTexture( mImpl->context, texture, mipmapLevel, layer );
 329 }
 330
 331 void RenderManager::AddPropertyBuffer( OwnerPointer< Render::PropertyBuffer >& propertyBuffer )
 332 {
 333   mImpl->propertyBufferContainer.PushBack( propertyBuffer.Release() );
 334 }
 335
 336 void RenderManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
 337 {
 338   mImpl->propertyBufferContainer.EraseObject( propertyBuffer );
 339 }
 340
 341 void RenderManager::SetPropertyBufferFormat( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Render::PropertyBuffer::Format>& format )
 342 {
 343   propertyBuffer->SetFormat( format.Release() );
 344 }
 345
 346 void RenderManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Vector<char> >& data, size_t size )
 347 {
 348   propertyBuffer->SetData( data.Release(), size );
 349 }
 350
 351 void RenderManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
 352 {
 353   geometry->SetIndexBuffer( indices );
 354 }
 355
 356 void RenderManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
 357 {
 358   mImpl->geometryContainer.PushBack( geometry.Release() );
 359 }
 360
 361 void RenderManager::RemoveGeometry( Render::Geometry* geometry )
 362 {
 363   mImpl->geometryContainer.EraseObject( geometry );
 364 }
 365
 366 void RenderManager::AttachVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
 367 {
 368   DALI_ASSERT_DEBUG( NULL != geometry );
 369
 370   GeometryOwnerContainer& geometries = mImpl->geometryContainer;
 371
 372   // Find the renderer
 373   for ( GeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
 374   {
 375     if ( *iter == geometry )
 376     {
 377       (*iter)->AddPropertyBuffer( propertyBuffer );
 378       break;
 379     }
 380   }
 381 }
 382
 383 void RenderManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
 384 {
 385   DALI_ASSERT_DEBUG( NULL != geometry );
 386
 387   GeometryOwnerContainer& geometries = mImpl->geometryContainer;
 388
 389   // Find the renderer
 390   for ( GeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
 391   {
 392     if ( *iter == geometry )
 393     {
 394       (*iter)->RemovePropertyBuffer( propertyBuffer );
 395       break;
 396     }
 397   }
 398 }
 399
 400 void RenderManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
 401 {
 402   geometry->SetType( Render::Geometry::Type(geometryType) );
 403 }
 404
 405 void RenderManager::AddRenderTracker( Render::RenderTracker* renderTracker )
 406 {
 407   mImpl->AddRenderTracker(renderTracker);
 408 }
 409
 410 void RenderManager::RemoveRenderTracker( Render::RenderTracker* renderTracker )
 411 {
 412   mImpl->RemoveRenderTracker(renderTracker);
 413 }
 414
 415 ProgramCache* RenderManager::GetProgramCache()
 416 {
 417   return &(mImpl->programController);
 418 }
 419
 420 void RenderManager::Render( Integration::RenderStatus& status )
 421 {
 422   DALI_PRINT_RENDER_START( mImpl->renderBufferIndex );
 423
 424   // Core::Render documents that GL context must be current before calling Render
 425   DALI_ASSERT_DEBUG( mImpl->context.IsGlContextCreated() );
 426
 427   // Increment the frame count at the beginning of each frame
 428   ++(mImpl->frameCount);
 429
 430   // Process messages queued during previous update
 431   mImpl->renderQueue.ProcessMessages( mImpl->renderBufferIndex );
 432
 433   const size_t count = mImpl->instructions.Count( mImpl->renderBufferIndex );
 434   const bool haveInstructions = count > 0u;
 435
 436   // Only render if we have instructions to render, or the last frame was rendered (and therefore a clear is required).
 437   if( haveInstructions || mImpl->lastFrameWasRendered )
 438   {
 439     // Mark that we will require a post-render step to be performed (includes swap-buffers).
 440     status.SetNeedsPostRender( true );
 441
 442     // switch rendering to adaptor provided (default) buffer
 443     mImpl->context.BindFramebuffer( GL_FRAMEBUFFER, 0 );
 444
 445     mImpl->context.Viewport( mImpl->defaultSurfaceRect.x,
 446                              mImpl->defaultSurfaceRect.y,
 447                              mImpl->defaultSurfaceRect.width,
 448                              mImpl->defaultSurfaceRect.height );
 449
 450     mImpl->context.ClearColor( mImpl->backgroundColor.r,
 451                                mImpl->backgroundColor.g,
 452                                mImpl->backgroundColor.b,
 453                                mImpl->backgroundColor.a );
 454
 455     mImpl->context.ClearStencil( 0 );
 456
 457     // Clear the entire color, depth and stencil buffers for the default framebuffer.
 458     // It is important to clear all 3 buffers, for performance on deferred renderers like Mali
 459     // e.g. previously when the depth & stencil buffers were NOT cleared, it caused the DDK to exceed a "vertex count limit",
 460     // and then stall. That problem is only noticeable when rendering a large number of vertices per frame.
 461     mImpl->context.SetScissorTest( false );
 462     mImpl->context.ColorMask( true );
 463     mImpl->context.DepthMask( true );
 464     mImpl->context.StencilMask( 0xFF ); // 8 bit stencil mask, all 1's
 465     mImpl->context.Clear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, Context::FORCE_CLEAR );
 466
 467     // reset the program matrices for all programs once per frame
 468     // this ensures we will set view and projection matrix once per program per camera
 469     mImpl->programController.ResetProgramMatrices();
 470
 471     for( size_t i = 0; i < count; ++i )
 472     {
 473       RenderInstruction& instruction = mImpl->instructions.At( mImpl->renderBufferIndex, i );
 474
 475       DoRender( instruction );
 476     }
 477
 478     GLenum attachments[] = { GL_DEPTH, GL_STENCIL };
 479     mImpl->context.InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
 480
 481     mImpl->UpdateTrackers();
 482
 483     //Notify RenderGeometries that rendering has finished
 484     for ( GeometryOwnerIter iter = mImpl->geometryContainer.Begin(); iter != mImpl->geometryContainer.End(); ++iter )
 485     {
 486       (*iter)->OnRenderFinished();
 487     }
 488   }
 489
 490   // If this frame was rendered due to instructions existing, we mark this so we know to clear the next frame.
 491   mImpl->lastFrameWasRendered = haveInstructions;
 492
 493   /**
 494    * The rendering has finished; swap to the next buffer.
 495    * Ideally the update has just finished using this buffer; otherwise the render thread
 496    * should block until the update has finished.
 497    */
 498   mImpl->renderBufferIndex = (0 != mImpl->renderBufferIndex) ? 0 : 1;
 499
 500   DALI_PRINT_RENDER_END();
 501 }
 502
 503 void RenderManager::DoRender( RenderInstruction& instruction )
 504 {
 505   Rect<int> viewportRect;
 506   Vector4   clearColor;
 507
 508   if ( instruction.mIsClearColorSet )
 509   {
 510     clearColor = instruction.mClearColor;
 511   }
 512   else
 513   {
 514     clearColor = Dali::RenderTask::DEFAULT_CLEAR_COLOR;
 515   }
 516
 517   if( instruction.mFrameBuffer != 0 )
 518   {
 519     instruction.mFrameBuffer->Bind( mImpl->context );
 520     if ( instruction.mIsViewportSet )
 521     {
 522       // For glViewport the lower-left corner is (0,0)
 523       const int y = ( instruction.mFrameBuffer->GetHeight() - instruction.mViewport.height ) - instruction.mViewport.y;
 524       viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 525     }
 526     else
 527     {
 528       viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
 529     }
 530   }
 531   else // !(instruction.mOffscreenTexture)
 532   {
 533     // switch rendering to adaptor provided (default) buffer
 534     mImpl->context.BindFramebuffer( GL_FRAMEBUFFER, 0 );
 535
 536     // Check whether a viewport is specified, otherwise the full surface size is used
 537     if ( instruction.mIsViewportSet )
 538     {
 539       // For glViewport the lower-left corner is (0,0)
 540       const int y = ( mImpl->defaultSurfaceRect.height - instruction.mViewport.height ) - instruction.mViewport.y;
 541       viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 542     }
 543     else
 544     {
 545       viewportRect = mImpl->defaultSurfaceRect;
 546     }
 547   }
 548
 549   mImpl->context.Viewport(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
 550
 551   if ( instruction.mIsClearColorSet )
 552   {
 553     mImpl->context.ClearColor( clearColor.r,
 554                                clearColor.g,
 555                                clearColor.b,
 556                                clearColor.a );
 557
 558     // Clear the viewport area only
 559     mImpl->context.SetScissorTest( true );
 560     mImpl->context.Scissor( viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height );
 561     mImpl->context.ColorMask( true );
 562     mImpl->context.Clear( GL_COLOR_BUFFER_BIT , Context::CHECK_CACHED_VALUES );
 563     mImpl->context.SetScissorTest( false );
 564   }
 565
 566   Render::ProcessRenderInstruction( instruction,
 567                                     mImpl->context,
 568                                     mImpl->renderBufferIndex );
 569
 570   if( instruction.mRenderTracker && ( instruction.mFrameBuffer != NULL ) )
 571   {
 572     // This will create a sync object every frame this render tracker
 573     // is alive (though it should be now be created only for
 574     // render-once render tasks)
 575     instruction.mRenderTracker->CreateSyncObject( mImpl->glSyncAbstraction );
 576     instruction.mRenderTracker = NULL; // Only create once.
 577   }
 578 }
 579
 580 } // namespace SceneGraph
 581
 582 } // namespace Internal
 583
 584 } // namespace Dali