dali/internal/update/rendering/scene-graph-renderer.cpp

   1 /*
   2  * Copyright (c) 2018 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 // CLASS HEADER
  18 #include "scene-graph-renderer.h"
  19
  20 // INTERNAL INCLUDES
  21 #include <dali/internal/common/internal-constants.h>
  22 #include <dali/internal/common/memory-pool-object-allocator.h>
  23 #include <dali/internal/update/controllers/render-message-dispatcher.h>
  24 #include <dali/internal/update/controllers/scene-controller.h>
  25 #include <dali/internal/update/nodes/node.h>
  26 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
  27 #include <dali/internal/render/data-providers/node-data-provider.h>
  28 #include <dali/internal/render/queue/render-queue.h>
  29 #include <dali/internal/render/renderers/render-geometry.h>
  30 #include <dali/internal/render/shaders/program.h>
  31 #include <dali/internal/render/shaders/scene-graph-shader.h>
  32
  33 namespace Dali
  34 {
  35 namespace Internal
  36 {
  37 namespace SceneGraph
  38 {
  39 namespace // unnamed namespace
  40 {
  41
  42 const uint32_t UNIFORM_MAP_READY      = 0;
  43 const uint32_t COPY_UNIFORM_MAP       = 1;
  44 const uint32_t REGENERATE_UNIFORM_MAP = 2;
  45
  46 //Memory pool used to allocate new renderers. Memory used by this pool will be released when shutting down DALi
  47 MemoryPoolObjectAllocator<Renderer> gRendererMemoryPool;
  48
  49 void AddMappings( CollectedUniformMap& localMap, const UniformMap& uniformMap )
  50 {
  51   // Iterate thru uniformMap.
  52   //   Any maps that aren't in localMap should be added in a single step
  53   CollectedUniformMap newUniformMappings;
  54
  55   for( UniformMap::SizeType i = 0, count=uniformMap.Count(); i<count; ++i )
  56   {
  57     UniformPropertyMapping::Hash nameHash = uniformMap[i].uniformNameHash;
  58     bool found = false;
  59
  60     for( CollectedUniformMap::Iterator iter = localMap.Begin() ; iter != localMap.End() ; ++iter )
  61     {
  62       const UniformPropertyMapping* map = (*iter);
  63       if( map->uniformNameHash == nameHash )
  64       {
  65         if( map->uniformName == uniformMap[i].uniformName )
  66         {
  67           found = true;
  68           break;
  69         }
  70       }
  71     }
  72     if( !found )
  73     {
  74       // it's a new mapping. Add raw ptr to temporary list
  75       newUniformMappings.PushBack( &uniformMap[i] );
  76     }
  77   }
  78
  79   if( newUniformMappings.Count() > 0 )
  80   {
  81     localMap.Reserve( localMap.Count() + newUniformMappings.Count() );
  82
  83     for( CollectedUniformMap::Iterator iter = newUniformMappings.Begin(),
  84            end = newUniformMappings.End() ;
  85          iter != end ;
  86          ++iter )
  87     {
  88       const UniformPropertyMapping* map = (*iter);
  89       localMap.PushBack( map );
  90     }
  91   }
  92 }
  93
  94 // Flags for re-sending data to renderer.
  95 enum Flags
  96 {
  97   RESEND_GEOMETRY                    = 1 << 0,
  98   RESEND_FACE_CULLING_MODE           = 1 << 1,
  99   RESEND_BLEND_COLOR                 = 1 << 2,
 100   RESEND_BLEND_BIT_MASK              = 1 << 3,
 101   RESEND_PREMULTIPLIED_ALPHA         = 1 << 4,
 102   RESEND_INDEXED_DRAW_FIRST_ELEMENT  = 1 << 5,
 103   RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 6,
 104   RESEND_DEPTH_WRITE_MODE            = 1 << 7,
 105   RESEND_DEPTH_TEST_MODE             = 1 << 8,
 106   RESEND_DEPTH_FUNCTION              = 1 << 9,
 107   RESEND_RENDER_MODE                 = 1 << 10,
 108   RESEND_STENCIL_FUNCTION            = 1 << 11,
 109   RESEND_STENCIL_FUNCTION_MASK       = 1 << 12,
 110   RESEND_STENCIL_FUNCTION_REFERENCE  = 1 << 13,
 111   RESEND_STENCIL_MASK                = 1 << 14,
 112   RESEND_STENCIL_OPERATION_ON_FAIL   = 1 << 15,
 113   RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 16,
 114   RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 17,
 115   RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 18
 116 };
 117
 118 } // Anonymous namespace
 119
 120 Renderer* Renderer::New()
 121 {
 122   return new ( gRendererMemoryPool.AllocateRawThreadSafe() ) Renderer();
 123 }
 124
 125 Renderer::Renderer()
 126 : mSceneController( 0 ),
 127   mRenderer( NULL ),
 128   mTextureSet( NULL ),
 129   mGeometry( NULL ),
 130   mShader( NULL ),
 131   mRenderDataProvider( NULL ),
 132   mBlendColor( NULL ),
 133   mStencilParameters( RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP ),
 134   mIndexedDrawFirstElement( 0u ),
 135   mIndexedDrawElementsCount( 0u ),
 136   mBlendBitmask( 0u ),
 137   mRegenerateUniformMap( 0u ),
 138   mResendFlag( 0u ),
 139   mDepthFunction( DepthFunction::LESS ),
 140   mFaceCullingMode( FaceCullingMode::NONE ),
 141   mBlendMode( BlendMode::AUTO ),
 142   mDepthWriteMode( DepthWriteMode::AUTO ),
 143   mDepthTestMode( DepthTestMode::AUTO ),
 144   mRenderingBehavior( DevelRenderer::Rendering::IF_REQUIRED ),
 145   mPremultipledAlphaEnabled( false ),
 146   mDirty( false ),
 147   mOpacity( 1.0f ),
 148   mDepthIndex( 0 )
 149 {
 150   mUniformMapChanged[0] = false;
 151   mUniformMapChanged[1] = false;
 152
 153   // Observe our own PropertyOwner's uniform map
 154   AddUniformMapObserver( *this );
 155 }
 156
 157 Renderer::~Renderer()
 158 {
 159   if( mTextureSet )
 160   {
 161     mTextureSet->RemoveObserver( this );
 162     mTextureSet = NULL;
 163   }
 164   if( mShader )
 165   {
 166     mShader->RemoveConnectionObserver( *this );
 167     mShader = NULL;
 168   }
 169 }
 170
 171 void Renderer::operator delete( void* ptr )
 172 {
 173   gRendererMemoryPool.FreeThreadSafe( static_cast<Renderer*>( ptr ) );
 174 }
 175
 176
 177 void Renderer::PrepareRender( BufferIndex updateBufferIndex )
 178 {
 179   if( mRegenerateUniformMap == UNIFORM_MAP_READY )
 180   {
 181     mUniformMapChanged[updateBufferIndex] = false;
 182   }
 183   else
 184   {
 185     mDirty = true;
 186     if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
 187     {
 188       CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
 189       localMap.Resize(0);
 190
 191       const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
 192       AddMappings( localMap, rendererUniformMap );
 193
 194       if( mShader )
 195       {
 196         AddMappings( localMap, mShader->GetUniformMap() );
 197       }
 198     }
 199     else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
 200     {
 201       // Copy old map into current map
 202       CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
 203       CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
 204
 205       localMap.Resize( oldMap.Count() );
 206
 207       uint32_t index=0;
 208       for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
 209       {
 210         localMap[index] = *iter;
 211       }
 212     }
 213
 214     mUniformMapChanged[updateBufferIndex] = true;
 215     mRegenerateUniformMap--;
 216   }
 217
 218   if( mResendFlag != 0 )
 219   {
 220     mDirty = true;
 221     if( mResendFlag & RESEND_GEOMETRY )
 222     {
 223       typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType;
 224       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 225       new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry );
 226     }
 227
 228     if( mResendFlag & RESEND_FACE_CULLING_MODE )
 229     {
 230       typedef MessageValue1< Render::Renderer, FaceCullingMode::Type > DerivedType;
 231       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 232       new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
 233     }
 234
 235     if( mResendFlag & RESEND_BLEND_BIT_MASK )
 236     {
 237       typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
 238       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 239       new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
 240     }
 241
 242     if( mResendFlag & RESEND_BLEND_COLOR )
 243     {
 244       typedef MessageValue1< Render::Renderer, Vector4 > DerivedType;
 245       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 246       new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, GetBlendColor() );
 247     }
 248
 249     if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA  )
 250     {
 251       typedef MessageValue1< Render::Renderer, bool > DerivedType;
 252       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 253       new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
 254     }
 255
 256     if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT )
 257     {
 258       typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
 259       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 260       new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement );
 261     }
 262
 263     if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
 264     {
 265       typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
 266       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 267       new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
 268     }
 269
 270     if( mResendFlag & RESEND_DEPTH_WRITE_MODE )
 271     {
 272       typedef MessageValue1< Render::Renderer, DepthWriteMode::Type > DerivedType;
 273       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 274       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode );
 275     }
 276
 277     if( mResendFlag & RESEND_DEPTH_TEST_MODE )
 278     {
 279       typedef MessageValue1< Render::Renderer, DepthTestMode::Type > DerivedType;
 280       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 281       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode );
 282     }
 283
 284     if( mResendFlag & RESEND_DEPTH_FUNCTION )
 285     {
 286       typedef MessageValue1< Render::Renderer, DepthFunction::Type > DerivedType;
 287       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 288       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction );
 289     }
 290
 291     if( mResendFlag & RESEND_RENDER_MODE )
 292     {
 293       typedef MessageValue1< Render::Renderer, RenderMode::Type > DerivedType;
 294       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 295       new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode );
 296     }
 297
 298     if( mResendFlag & RESEND_STENCIL_FUNCTION )
 299     {
 300       typedef MessageValue1< Render::Renderer, StencilFunction::Type > DerivedType;
 301       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 302       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction );
 303     }
 304
 305     if( mResendFlag & RESEND_STENCIL_FUNCTION_MASK )
 306     {
 307       typedef MessageValue1< Render::Renderer, int > DerivedType;
 308       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 309       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask );
 310     }
 311
 312     if( mResendFlag & RESEND_STENCIL_FUNCTION_REFERENCE )
 313     {
 314       typedef MessageValue1< Render::Renderer, int > DerivedType;
 315       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 316       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference );
 317     }
 318
 319     if( mResendFlag & RESEND_STENCIL_MASK )
 320     {
 321       typedef MessageValue1< Render::Renderer, int > DerivedType;
 322       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 323       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask );
 324     }
 325
 326     if( mResendFlag & RESEND_STENCIL_OPERATION_ON_FAIL )
 327     {
 328       typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
 329       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 330       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail );
 331     }
 332
 333     if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_FAIL )
 334     {
 335       typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
 336       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 337       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail );
 338     }
 339
 340     if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_PASS )
 341     {
 342       typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
 343       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 344       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass );
 345     }
 346
 347     mResendFlag = 0;
 348   }
 349 }
 350
 351 void Renderer::SetTextures( TextureSet* textureSet )
 352 {
 353   DALI_ASSERT_DEBUG( textureSet != NULL && "Texture set pointer is NULL" );
 354
 355   if( mTextureSet )
 356   {
 357     mTextureSet->RemoveObserver(this);
 358   }
 359
 360   mTextureSet = textureSet;
 361   mTextureSet->AddObserver( this );
 362   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 363
 364   UpdateTextureSet();
 365 }
 366
 367 void Renderer::SetShader( Shader* shader )
 368 {
 369   DALI_ASSERT_DEBUG( shader != NULL && "Shader pointer is NULL" );
 370
 371   if( mShader )
 372   {
 373     mShader->RemoveConnectionObserver(*this);
 374   }
 375
 376   mShader = shader;
 377   mShader->AddConnectionObserver( *this );
 378   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 379   mResendFlag |= RESEND_GEOMETRY;
 380
 381   if( mRenderDataProvider )
 382   {
 383     mRenderDataProvider->mShader = mShader;
 384   }
 385 }
 386
 387 void Renderer::SetGeometry( Render::Geometry* geometry )
 388 {
 389   DALI_ASSERT_DEBUG( geometry != NULL && "Geometry pointer is NULL");
 390   mGeometry = geometry;
 391
 392   if( mRenderer )
 393   {
 394     mResendFlag |= RESEND_GEOMETRY;
 395   }
 396 }
 397
 398 void Renderer::SetDepthIndex( int depthIndex )
 399 {
 400   mDepthIndex = depthIndex;
 401   mDirty = true;
 402 }
 403
 404 void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode )
 405 {
 406   mFaceCullingMode = faceCullingMode;
 407   mResendFlag |= RESEND_FACE_CULLING_MODE;
 408 }
 409
 410 FaceCullingMode::Type Renderer::GetFaceCullingMode() const
 411 {
 412   return mFaceCullingMode;
 413 }
 414
 415 void Renderer::SetBlendMode( BlendMode::Type blendingMode )
 416 {
 417   mBlendMode = blendingMode;
 418   mDirty = true;
 419 }
 420
 421 BlendMode::Type Renderer::GetBlendMode() const
 422 {
 423   return mBlendMode;
 424 }
 425
 426 void Renderer::SetBlendingOptions( uint32_t options )
 427 {
 428   if( mBlendBitmask != options)
 429   {
 430     mBlendBitmask = options;
 431     mResendFlag |= RESEND_BLEND_BIT_MASK;
 432   }
 433 }
 434
 435 uint32_t Renderer::GetBlendingOptions() const
 436 {
 437   return mBlendBitmask;
 438 }
 439
 440 void Renderer::SetBlendColor( const Vector4& blendColor )
 441 {
 442   if( blendColor == Color::TRANSPARENT )
 443   {
 444     mBlendColor = NULL;
 445   }
 446   else
 447   {
 448     if( !mBlendColor )
 449     {
 450       mBlendColor = new Vector4( blendColor );
 451     }
 452     else
 453     {
 454       *mBlendColor = blendColor;
 455     }
 456   }
 457
 458   mResendFlag |= RESEND_BLEND_COLOR;
 459 }
 460
 461 Vector4 Renderer::GetBlendColor() const
 462 {
 463   if( mBlendColor )
 464   {
 465     return *mBlendColor;
 466   }
 467   return Color::TRANSPARENT;
 468 }
 469
 470 void Renderer::SetIndexedDrawFirstElement( uint32_t firstElement )
 471 {
 472   mIndexedDrawFirstElement = firstElement;
 473   mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
 474 }
 475
 476 uint32_t Renderer::GetIndexedDrawFirstElement() const
 477 {
 478   return mIndexedDrawFirstElement;
 479 }
 480
 481 void Renderer::SetIndexedDrawElementsCount( uint32_t elementsCount )
 482 {
 483   mIndexedDrawElementsCount = elementsCount;
 484   mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
 485 }
 486
 487 uint32_t Renderer::GetIndexedDrawElementsCount() const
 488 {
 489   return mIndexedDrawElementsCount;
 490 }
 491
 492 void Renderer::EnablePreMultipliedAlpha( bool preMultipled )
 493 {
 494   mPremultipledAlphaEnabled = preMultipled;
 495   mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
 496 }
 497
 498 bool Renderer::IsPreMultipliedAlphaEnabled() const
 499 {
 500   return mPremultipledAlphaEnabled;
 501 }
 502
 503 void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode )
 504 {
 505   mDepthWriteMode = depthWriteMode;
 506   mResendFlag |= RESEND_DEPTH_WRITE_MODE;
 507 }
 508
 509 DepthWriteMode::Type Renderer::GetDepthWriteMode() const
 510 {
 511   return mDepthWriteMode;
 512 }
 513
 514 void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode )
 515 {
 516   mDepthTestMode = depthTestMode;
 517   mResendFlag |= RESEND_DEPTH_TEST_MODE;
 518 }
 519
 520 DepthTestMode::Type Renderer::GetDepthTestMode() const
 521 {
 522   return mDepthTestMode;
 523 }
 524
 525 void Renderer::SetDepthFunction( DepthFunction::Type depthFunction )
 526 {
 527   mDepthFunction = depthFunction;
 528   mResendFlag |= RESEND_DEPTH_FUNCTION;
 529 }
 530
 531 DepthFunction::Type Renderer::GetDepthFunction() const
 532 {
 533   return mDepthFunction;
 534 }
 535
 536 void Renderer::SetRenderMode( RenderMode::Type mode )
 537 {
 538   mStencilParameters.renderMode = mode;
 539   mResendFlag |= RESEND_RENDER_MODE;
 540 }
 541
 542 void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction )
 543 {
 544   mStencilParameters.stencilFunction = stencilFunction;
 545   mResendFlag |= RESEND_STENCIL_FUNCTION;
 546 }
 547
 548 void Renderer::SetStencilFunctionMask( int stencilFunctionMask )
 549 {
 550   mStencilParameters.stencilFunctionMask = stencilFunctionMask;
 551   mResendFlag |= RESEND_STENCIL_FUNCTION_MASK;
 552 }
 553
 554 void Renderer::SetStencilFunctionReference( int stencilFunctionReference )
 555 {
 556   mStencilParameters.stencilFunctionReference = stencilFunctionReference;
 557   mResendFlag |= RESEND_STENCIL_FUNCTION_REFERENCE;
 558 }
 559
 560 void Renderer::SetStencilMask( int stencilMask )
 561 {
 562   mStencilParameters.stencilMask = stencilMask;
 563   mResendFlag |= RESEND_STENCIL_MASK;
 564 }
 565
 566 void Renderer::SetStencilOperationOnFail( StencilOperation::Type stencilOperationOnFail )
 567 {
 568   mStencilParameters.stencilOperationOnFail = stencilOperationOnFail;
 569   mResendFlag |= RESEND_STENCIL_OPERATION_ON_FAIL;
 570 }
 571
 572 void Renderer::SetStencilOperationOnZFail( StencilOperation::Type stencilOperationOnZFail )
 573 {
 574   mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail;
 575   mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_FAIL;
 576 }
 577
 578 void Renderer::SetStencilOperationOnZPass( StencilOperation::Type stencilOperationOnZPass )
 579 {
 580   mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass;
 581   mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_PASS;
 582 }
 583
 584 const Render::Renderer::StencilParameters& Renderer::GetStencilParameters() const
 585 {
 586   return mStencilParameters;
 587 }
 588
 589 void Renderer::BakeOpacity( BufferIndex updateBufferIndex, float opacity )
 590 {
 591   mDirty = true;
 592   mOpacity.Bake( updateBufferIndex, opacity );
 593 }
 594
 595 float Renderer::GetOpacity( BufferIndex updateBufferIndex ) const
 596 {
 597   return mOpacity[updateBufferIndex];
 598 }
 599
 600 void Renderer::SetRenderingBehavior( DevelRenderer::Rendering::Type renderingBehavior )
 601 {
 602   mRenderingBehavior = renderingBehavior;
 603   mDirty = true;
 604 }
 605
 606 DevelRenderer::Rendering::Type Renderer::GetRenderingBehavior() const
 607 {
 608   return mRenderingBehavior;
 609 }
 610
 611 //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created )
 612 void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
 613 {
 614   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 615   mSceneController = &sceneController;
 616
 617   mRenderDataProvider = new RenderDataProvider( mOpacity );
 618   mRenderDataProvider->mUniformMapDataProvider = this;
 619
 620   mRenderer = Render::Renderer::New( mRenderDataProvider, mGeometry, mBlendBitmask, GetBlendColor(), static_cast< FaceCullingMode::Type >( mFaceCullingMode ),
 621                                          mPremultipledAlphaEnabled, mDepthWriteMode, mDepthTestMode, mDepthFunction, mStencilParameters );
 622   OwnerPointer< Render::Renderer > transferOwnership( mRenderer );
 623   mSceneController->GetRenderMessageDispatcher().AddRenderer( transferOwnership );
 624 }
 625
 626 //Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
 627 void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
 628 {
 629   //Remove renderer from RenderManager
 630   if( mRenderer )
 631   {
 632     mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
 633     mRenderer = NULL;
 634   }
 635   mSceneController = NULL;
 636   mRenderDataProvider = NULL;
 637 }
 638
 639 void Renderer::UpdateTextureSet()
 640 {
 641   if( mRenderDataProvider )
 642   {
 643     if( mTextureSet )
 644     {
 645       uint32_t textureCount = mTextureSet->GetTextureCount();
 646       mRenderDataProvider->mTextures.resize( textureCount );
 647       mRenderDataProvider->mSamplers.resize( textureCount );
 648       for( uint32_t i = 0; i<textureCount; ++i )
 649       {
 650         mRenderDataProvider->mTextures[i] = mTextureSet->GetTexture(i);
 651         mRenderDataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i);
 652       }
 653     }
 654     else
 655     {
 656       mRenderDataProvider->mTextures.clear();
 657       mRenderDataProvider->mSamplers.clear();
 658     }
 659     mDirty = true;
 660   }
 661 }
 662
 663 Render::Renderer& Renderer::GetRenderer()
 664 {
 665   return *mRenderer;
 666 }
 667
 668 const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) const
 669 {
 670   return mCollectedUniformMap[bufferIndex];
 671 }
 672
 673 Renderer::OpacityType Renderer::GetOpacityType( BufferIndex updateBufferIndex, const Node& node ) const
 674 {
 675   Renderer::OpacityType opacityType = Renderer::OPAQUE;
 676
 677   switch( mBlendMode )
 678   {
 679     case BlendMode::ON: // If the renderer should always be use blending
 680     {
 681       float alpha = node.GetWorldColor( updateBufferIndex ).a * mOpacity[updateBufferIndex];
 682       if( alpha <= FULLY_TRANSPARENT )
 683       {
 684         opacityType = Renderer::TRANSPARENT;
 685       }
 686       else
 687       {
 688         opacityType = Renderer::TRANSLUCENT;
 689       }
 690       break;
 691     }
 692     case BlendMode::AUTO:
 693     {
 694       bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT ) );
 695       if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
 696       {
 697         opacityType = Renderer::TRANSLUCENT;
 698       }
 699
 700       // renderer should determine opacity using the actor color
 701       float alpha = node.GetWorldColor( updateBufferIndex ).a * mOpacity[updateBufferIndex];
 702       if( alpha <= FULLY_TRANSPARENT )
 703       {
 704         opacityType = Renderer::TRANSPARENT;
 705       }
 706       else if( alpha <= FULLY_OPAQUE )
 707       {
 708         opacityType = Renderer::TRANSLUCENT;
 709       }
 710       break;
 711     }
 712     case BlendMode::OFF: // the renderer should never use blending
 713     default:
 714     {
 715       opacityType = Renderer::OPAQUE;
 716       break;
 717     }
 718   }
 719
 720   return opacityType;
 721 }
 722
 723 void Renderer::TextureSetChanged()
 724 {
 725   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 726
 727   UpdateTextureSet();
 728 }
 729
 730 void Renderer::TextureSetDeleted()
 731 {
 732   mTextureSet = NULL;
 733
 734   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 735
 736   UpdateTextureSet();
 737 }
 738
 739 void Renderer::ConnectionsChanged( PropertyOwner& object )
 740 {
 741   // One of our child objects has changed it's connections. Ensure the uniform
 742   // map gets regenerated during PrepareRender
 743   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 744 }
 745
 746 void Renderer::ConnectedUniformMapChanged()
 747 {
 748   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 749 }
 750
 751 void Renderer::UniformMappingsChanged( const UniformMap& mappings )
 752 {
 753   // The mappings are either from PropertyOwner base class, or the Actor
 754   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 755 }
 756
 757 void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
 758 {
 759   if( reinterpret_cast<PropertyOwner*>(mShader) == &owner )
 760   {
 761     mShader = NULL;
 762   }
 763 }
 764
 765 void Renderer::SetDirty( bool value )
 766 {
 767   mDirty = value;
 768   if( mShader )
 769   {
 770     mShader->SetPropertyDirty( value );
 771   }
 772 }
 773
 774 bool Renderer::IsDirty() const
 775 {
 776   bool ret = false;
 777   if( mShader )
 778   {
 779     ret = mShader->IsPropertyDirty();
 780   }
 781
 782   // check native image
 783   if( mTextureSet )
 784   {
 785     uint32_t textureCount = mTextureSet->GetTextureCount();
 786
 787     if(textureCount > 0)
 788     {
 789       Dali::Internal::Render::Texture* texture;
 790       for( uint32_t i = 0; i<textureCount; ++i )
 791       {
 792         texture = const_cast<Dali::Internal::SceneGraph::TextureSet *>(mTextureSet)->GetTexture(i);
 793         if( texture && texture->IsNativeImage() )
 794         {
 795           ret = true;
 796           break;
 797         }
 798       }
 799     }
 800   }
 801
 802   return ret | mDirty;
 803 }
 804
 805 } // namespace SceneGraph
 806 } // namespace Internal
 807 } // namespace Dali