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

   1 /*
   2  * Copyright (c) 2016 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     renderersAdded( 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                          renderersAdded;
 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( 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 );
 238
 239   if( !mImpl->renderersAdded )
 240   {
 241     mImpl->renderersAdded = true;
 242   }
 243 }
 244
 245 void RenderManager::RemoveRenderer( Render::Renderer* renderer )
 246 {
 247   mImpl->rendererContainer.EraseObject( renderer );
 248 }
 249
 250 void RenderManager::AddSampler( Render::Sampler* sampler )
 251 {
 252   mImpl->samplerContainer.PushBack( sampler );
 253 }
 254
 255 void RenderManager::RemoveSampler( Render::Sampler* sampler )
 256 {
 257   mImpl->samplerContainer.EraseObject( sampler );
 258 }
 259
 260 void RenderManager::AddTexture( Render::Texture* texture )
 261 {
 262   mImpl->textureContainer.PushBack( texture );
 263   texture->Initialize(mImpl->context);
 264 }
 265
 266 void RenderManager::RemoveTexture( Render::Texture* texture )
 267 {
 268   DALI_ASSERT_DEBUG( NULL != texture );
 269
 270   TextureOwnerContainer& textures = mImpl->textureContainer;
 271
 272   // Find the texture
 273   for ( TextureOwnerIter iter = textures.Begin(); iter != textures.End(); ++iter )
 274   {
 275     if ( *iter == texture )
 276     {
 277       texture->Destroy( mImpl->context );
 278       textures.Erase( iter ); // Texture found; now destroy it
 279       break;
 280     }
 281   }
 282 }
 283
 284 void RenderManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
 285 {
 286   texture->Upload( mImpl->context, pixelData, params );
 287 }
 288
 289 void RenderManager::GenerateMipmaps( Render::Texture* texture )
 290 {
 291   texture->GenerateMipmaps( mImpl->context );
 292 }
 293
 294 void RenderManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
 295 {
 296   sampler->mMinificationFilter = static_cast<Dali::FilterMode::Type>(minFilterMode);
 297   sampler->mMagnificationFilter = static_cast<Dali::FilterMode::Type>(magFilterMode );
 298 }
 299
 300 void RenderManager::SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
 301 {
 302   sampler->mRWrapMode = static_cast<Dali::WrapMode::Type>(rWrapMode);
 303   sampler->mSWrapMode = static_cast<Dali::WrapMode::Type>(sWrapMode);
 304   sampler->mTWrapMode = static_cast<Dali::WrapMode::Type>(tWrapMode);
 305 }
 306
 307 void RenderManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
 308 {
 309   mImpl->frameBufferContainer.PushBack( frameBuffer );
 310   frameBuffer->Initialize(mImpl->context);
 311 }
 312
 313 void RenderManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer )
 314 {
 315   DALI_ASSERT_DEBUG( NULL != frameBuffer );
 316
 317   FrameBufferOwnerContainer& framebuffers = mImpl->frameBufferContainer;
 318
 319   // Find the sampler
 320   for ( FrameBufferOwnerIter iter = framebuffers.Begin(); iter != framebuffers.End(); ++iter )
 321   {
 322     if ( *iter == frameBuffer )
 323     {
 324       frameBuffer->Destroy( mImpl->context );
 325       framebuffers.Erase( iter ); // frameBuffer found; now destroy it
 326       break;
 327     }
 328   }
 329 }
 330
 331 void RenderManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
 332 {
 333   frameBuffer->AttachColorTexture( mImpl->context, texture, mipmapLevel, layer );
 334 }
 335
 336 void RenderManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
 337 {
 338   mImpl->propertyBufferContainer.PushBack( propertyBuffer );
 339 }
 340
 341 void RenderManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
 342 {
 343   mImpl->propertyBufferContainer.EraseObject( propertyBuffer );
 344 }
 345
 346 void RenderManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
 347 {
 348   propertyBuffer->SetFormat( format );
 349 }
 350
 351 void RenderManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
 352 {
 353   propertyBuffer->SetData( data, size );
 354 }
 355
 356 void RenderManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
 357 {
 358   geometry->SetIndexBuffer( indices );
 359 }
 360
 361 void RenderManager::AddGeometry( Render::Geometry* geometry )
 362 {
 363   mImpl->geometryContainer.PushBack( geometry );
 364 }
 365
 366 void RenderManager::RemoveGeometry( Render::Geometry* geometry )
 367 {
 368   mImpl->geometryContainer.EraseObject( geometry );
 369 }
 370
 371 void RenderManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
 372 {
 373   DALI_ASSERT_DEBUG( NULL != geometry );
 374
 375   GeometryOwnerContainer& geometries = mImpl->geometryContainer;
 376
 377   // Find the renderer
 378   for ( GeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
 379   {
 380     if ( *iter == geometry )
 381     {
 382       (*iter)->AddPropertyBuffer( propertyBuffer );
 383       break;
 384     }
 385   }
 386 }
 387
 388 void RenderManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
 389 {
 390   DALI_ASSERT_DEBUG( NULL != geometry );
 391
 392   GeometryOwnerContainer& geometries = mImpl->geometryContainer;
 393
 394   // Find the renderer
 395   for ( GeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
 396   {
 397     if ( *iter == geometry )
 398     {
 399       (*iter)->RemovePropertyBuffer( propertyBuffer );
 400       break;
 401     }
 402   }
 403 }
 404
 405 void RenderManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
 406 {
 407   geometry->SetType( Render::Geometry::Type(geometryType) );
 408 }
 409
 410 void RenderManager::AddRenderTracker( Render::RenderTracker* renderTracker )
 411 {
 412   mImpl->AddRenderTracker(renderTracker);
 413 }
 414
 415 void RenderManager::RemoveRenderTracker( Render::RenderTracker* renderTracker )
 416 {
 417   mImpl->RemoveRenderTracker(renderTracker);
 418 }
 419
 420 ProgramCache* RenderManager::GetProgramCache()
 421 {
 422   return &(mImpl->programController);
 423 }
 424
 425 void RenderManager::Render( Integration::RenderStatus& status )
 426 {
 427   DALI_PRINT_RENDER_START( mImpl->renderBufferIndex );
 428
 429   // Core::Render documents that GL context must be current before calling Render
 430   DALI_ASSERT_DEBUG( mImpl->context.IsGlContextCreated() );
 431
 432   // Increment the frame count at the beginning of each frame
 433   ++(mImpl->frameCount);
 434
 435   // Process messages queued during previous update
 436   mImpl->renderQueue.ProcessMessages( mImpl->renderBufferIndex );
 437
 438   // switch rendering to adaptor provided (default) buffer
 439   mImpl->context.BindFramebuffer( GL_FRAMEBUFFER, 0 );
 440
 441   mImpl->context.Viewport( mImpl->defaultSurfaceRect.x,
 442                            mImpl->defaultSurfaceRect.y,
 443                            mImpl->defaultSurfaceRect.width,
 444                            mImpl->defaultSurfaceRect.height );
 445
 446   mImpl->context.ClearColor( mImpl->backgroundColor.r,
 447                              mImpl->backgroundColor.g,
 448                              mImpl->backgroundColor.b,
 449                              mImpl->backgroundColor.a );
 450
 451   mImpl->context.ClearStencil( 0 );
 452
 453   // Clear the entire color, depth and stencil buffers for the default framebuffer.
 454   // It is important to clear all 3 buffers, for performance on deferred renderers like Mali
 455   // e.g. previously when the depth & stencil buffers were NOT cleared, it caused the DDK to exceed a "vertex count limit",
 456   // and then stall. That problem is only noticeable when rendering a large number of vertices per frame.
 457   mImpl->context.SetScissorTest( false );
 458   mImpl->context.ColorMask( true );
 459   mImpl->context.DepthMask( true );
 460   mImpl->context.StencilMask( 0xFF ); // 8 bit stencil mask, all 1's
 461   mImpl->context.Clear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT,  Context::FORCE_CLEAR );
 462
 463   // reset the program matrices for all programs once per frame
 464   // this ensures we will set view and projection matrix once per program per camera
 465   mImpl->programController.ResetProgramMatrices();
 466
 467   size_t count = mImpl->instructions.Count( mImpl->renderBufferIndex );
 468   for ( size_t i = 0; i < count; ++i )
 469   {
 470     RenderInstruction& instruction = mImpl->instructions.At( mImpl->renderBufferIndex, i );
 471
 472     DoRender( instruction );
 473   }
 474   GLenum attachments[] = { GL_DEPTH, GL_STENCIL };
 475   mImpl->context.InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
 476
 477   mImpl->UpdateTrackers();
 478
 479   //Notify RenderGeometries that rendering has finished
 480   for ( GeometryOwnerIter iter = mImpl->geometryContainer.Begin(); iter != mImpl->geometryContainer.End(); ++iter )
 481   {
 482     (*iter)->OnRenderFinished();
 483   }
 484
 485   /**
 486    * The rendering has finished; swap to the next buffer.
 487    * Ideally the update has just finished using this buffer; otherwise the render thread
 488    * should block until the update has finished.
 489    */
 490   mImpl->renderBufferIndex = (0 != mImpl->renderBufferIndex) ? 0 : 1;
 491
 492   DALI_PRINT_RENDER_END();
 493 }
 494
 495 void RenderManager::DoRender( RenderInstruction& instruction )
 496 {
 497   Rect<int> viewportRect;
 498   Vector4   clearColor;
 499
 500   if ( instruction.mIsClearColorSet )
 501   {
 502     clearColor = instruction.mClearColor;
 503   }
 504   else
 505   {
 506     clearColor = Dali::RenderTask::DEFAULT_CLEAR_COLOR;
 507   }
 508
 509   if( instruction.mFrameBuffer != 0 )
 510   {
 511     instruction.mFrameBuffer->Bind( mImpl->context );
 512     if ( instruction.mIsViewportSet )
 513     {
 514       // For glViewport the lower-left corner is (0,0)
 515       const int y = ( instruction.mFrameBuffer->GetHeight() - instruction.mViewport.height ) - instruction.mViewport.y;
 516       viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 517     }
 518     else
 519     {
 520       viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
 521     }
 522   }
 523   else // !(instruction.mOffscreenTexture)
 524   {
 525     // switch rendering to adaptor provided (default) buffer
 526     mImpl->context.BindFramebuffer( GL_FRAMEBUFFER, 0 );
 527
 528     // Check whether a viewport is specified, otherwise the full surface size is used
 529     if ( instruction.mIsViewportSet )
 530     {
 531       // For glViewport the lower-left corner is (0,0)
 532       const int y = ( mImpl->defaultSurfaceRect.height - instruction.mViewport.height ) - instruction.mViewport.y;
 533       viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
 534     }
 535     else
 536     {
 537       viewportRect = mImpl->defaultSurfaceRect;
 538     }
 539   }
 540
 541   mImpl->context.Viewport(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
 542
 543   if ( instruction.mIsClearColorSet )
 544   {
 545     mImpl->context.ClearColor( clearColor.r,
 546                                clearColor.g,
 547                                clearColor.b,
 548                                clearColor.a );
 549
 550     // Clear the viewport area only
 551     mImpl->context.SetScissorTest( true );
 552     mImpl->context.Scissor( viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height );
 553     mImpl->context.ColorMask( true );
 554     mImpl->context.Clear( GL_COLOR_BUFFER_BIT , Context::CHECK_CACHED_VALUES );
 555     mImpl->context.SetScissorTest( false );
 556   }
 557
 558   Render::ProcessRenderInstruction( instruction,
 559                                     mImpl->context,
 560                                     mImpl->renderBufferIndex );
 561
 562   if( instruction.mRenderTracker && ( instruction.mFrameBuffer != NULL ) )
 563   {
 564     // This will create a sync object every frame this render tracker
 565     // is alive (though it should be now be created only for
 566     // render-once render tasks)
 567     instruction.mRenderTracker->CreateSyncObject( mImpl->glSyncAbstraction );
 568     instruction.mRenderTracker = NULL; // Only create once.
 569   }
 570 }
 571
 572 } // namespace SceneGraph
 573
 574 } // namespace Internal
 575
 576 } // namespace Dali