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