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

   1 /*
   2  * Copyright (c) 2024 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 <dali/internal/update/rendering/scene-graph-renderer.h>
  19
  20 // INTERNAL INCLUDES
  21 #include <dali/internal/common/blending-options.h>
  22 #include <dali/internal/common/internal-constants.h>
  23 #include <dali/internal/common/memory-pool-object-allocator.h>
  24 #include <dali/internal/render/data-providers/node-data-provider.h>
  25 #include <dali/internal/render/data-providers/render-data-provider.h>
  26 #include <dali/internal/render/queue/render-queue.h>
  27 #include <dali/internal/render/renderers/render-geometry.h>
  28 #include <dali/internal/render/shaders/program.h>
  29 #include <dali/internal/render/shaders/render-shader.h>
  30 #include <dali/internal/update/controllers/render-message-dispatcher.h>
  31 #include <dali/internal/update/controllers/scene-controller.h>
  32 #include <dali/internal/update/nodes/node.h>
  33 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
  34
  35 #include <dali/internal/update/common/property-resetter.h>
  36 #include <dali/internal/update/common/resetter-manager.h> ///< For AddInitializeResetter
  37
  38 #include <dali/integration-api/debug.h>
  39
  40 namespace Dali
  41 {
  42 namespace Internal
  43 {
  44 namespace SceneGraph
  45 {
  46 #ifdef DEBUG_ENABLED
  47 Debug::Filter* gSceneGraphRendererLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_SG_RENDERER");
  48 #endif
  49
  50 namespace // unnamed namespace
  51 {
  52 // Memory pool used to allocate new renderers. Memory used by this pool will be released when shutting down DALi
  53 MemoryPoolObjectAllocator<Renderer>& GetRendererMemoryPool()
  54 {
  55   static MemoryPoolObjectAllocator<Renderer> gRendererMemoryPool;
  56   return gRendererMemoryPool;
  57 }
  58
  59 // Flags for re-sending data to renderer.
  60 enum Flags
  61 {
  62   RESEND_GEOMETRY                    = 1 << 0,
  63   RESEND_FACE_CULLING_MODE           = 1 << 1,
  64   RESEND_BLEND_COLOR                 = 1 << 2,
  65   RESEND_BLEND_BIT_MASK              = 1 << 3,
  66   RESEND_PREMULTIPLIED_ALPHA         = 1 << 4,
  67   RESEND_INDEXED_DRAW_FIRST_ELEMENT  = 1 << 5,
  68   RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 6,
  69   RESEND_DEPTH_WRITE_MODE            = 1 << 7,
  70   RESEND_DEPTH_TEST_MODE             = 1 << 8,
  71   RESEND_DEPTH_FUNCTION              = 1 << 9,
  72   RESEND_RENDER_MODE                 = 1 << 10,
  73   RESEND_STENCIL_FUNCTION            = 1 << 11,
  74   RESEND_STENCIL_FUNCTION_MASK       = 1 << 12,
  75   RESEND_STENCIL_FUNCTION_REFERENCE  = 1 << 13,
  76   RESEND_STENCIL_MASK                = 1 << 14,
  77   RESEND_STENCIL_OPERATION_ON_FAIL   = 1 << 15,
  78   RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 16,
  79   RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 17,
  80   RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 18,
  81   RESEND_SHADER                      = 1 << 19,
  82   RESEND_DRAW_COMMANDS               = 1 << 20,
  83   RESEND_SET_RENDER_CALLBACK         = 1 << 21
  84 };
  85
  86 } // Anonymous namespace
  87
  88 RendererKey Renderer::NewKey()
  89 {
  90   void* ptr = GetRendererMemoryPool().AllocateRawThreadSafe();
  91   auto  key = GetRendererMemoryPool().GetKeyFromPtr(static_cast<Renderer*>(ptr));
  92   new(ptr) Renderer();
  93   return RendererKey(key);
  94 }
  95
  96 Renderer::Renderer()
  97 : mSceneController(nullptr),
  98   mRenderer{},
  99   mTextureSet(nullptr),
 100   mGeometry(nullptr),
 101   mShader(nullptr),
 102   mBlendColor(nullptr),
 103   mStencilParameters(RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP),
 104   mIndexedDrawFirstElement(0u),
 105   mIndexedDrawElementsCount(0u),
 106   mBlendBitmask(0u),
 107   mResendFlag(0u),
 108   mDepthFunction(DepthFunction::LESS),
 109   mFaceCullingMode(FaceCullingMode::NONE),
 110   mBlendMode(BlendMode::AUTO),
 111   mDepthWriteMode(DepthWriteMode::AUTO),
 112   mDepthTestMode(DepthTestMode::AUTO),
 113   mRenderingBehavior(DevelRenderer::Rendering::IF_REQUIRED),
 114   mUpdateDecay(Renderer::Decay::INITIAL),
 115   mRegenerateUniformMap(false),
 116   mPremultipledAlphaEnabled(false),
 117   mOpacity(1.0f),
 118   mDepthIndex(0)
 119 {
 120 }
 121
 122 Renderer::~Renderer()
 123 {
 124 }
 125
 126 void Renderer::operator delete(void* ptr)
 127 {
 128   GetRendererMemoryPool().FreeThreadSafe(static_cast<Renderer*>(ptr));
 129 }
 130
 131 Renderer* Renderer::Get(RendererKey::KeyType rendererKey)
 132 {
 133   return GetRendererMemoryPool().GetPtrFromKey(rendererKey);
 134 }
 135
 136 RendererKey Renderer::GetKey(const Renderer& renderer)
 137 {
 138   return RendererKey(GetRendererMemoryPool().GetKeyFromPtr(const_cast<Renderer*>(&renderer)));
 139 }
 140
 141 RendererKey Renderer::GetKey(Renderer* renderer)
 142 {
 143   return RendererKey(GetRendererMemoryPool().GetKeyFromPtr(renderer));
 144 }
 145
 146 bool Renderer::PrepareRender(BufferIndex updateBufferIndex)
 147 {
 148   bool rendererUpdated        = Updated() || mResendFlag || mRenderingBehavior == DevelRenderer::Rendering::CONTINUOUSLY || mUpdateDecay > 0;
 149   auto shaderMapChangeCounter = mShader ? mShader->GetUniformMap().GetChangeCounter() : 0u;
 150   bool shaderMapChanged       = mShader && (mShaderMapChangeCounter != shaderMapChangeCounter);
 151   if(shaderMapChanged)
 152   {
 153     mShaderMapChangeCounter = shaderMapChangeCounter;
 154   }
 155
 156   if(mUniformMapChangeCounter != mUniformMaps.GetChangeCounter() || shaderMapChanged)
 157   {
 158     // The map has changed since the last time we checked.
 159     rendererUpdated       = true;
 160     mRegenerateUniformMap = true;
 161     mUpdateDecay          = Renderer::Decay::INITIAL; // Render at least twice if the map has changed/actor has been added
 162
 163     // Update local counters to identify any future changes to maps
 164     // (unlikely, but allowed by API).
 165     mUniformMapChangeCounter = mUniformMaps.GetChangeCounter();
 166   }
 167   if(mUpdateDecay > 0)
 168   {
 169     mUpdateDecay = static_cast<Renderer::Decay>(static_cast<int>(mUpdateDecay) - 1);
 170   }
 171
 172   if(mResendFlag || mRenderingBehavior == DevelRenderer::Rendering::CONTINUOUSLY) // We don't check mUpdateDecay
 173   {
 174     SetUpdated(true);
 175   }
 176
 177   if(mResendFlag != 0)
 178   {
 179     Render::Renderer* rendererPtr = mRenderer.Get();
 180     if(mResendFlag & RESEND_GEOMETRY)
 181     {
 182       typedef MessageValue1<Render::Renderer, Render::Geometry*> DerivedType;
 183       uint32_t*                                                  slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 184       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetGeometry, mGeometry);
 185     }
 186
 187     if(mResendFlag & RESEND_DRAW_COMMANDS)
 188     {
 189       using DerivedType = MessageValue2<Render::Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
 190       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 191       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDrawCommands, mDrawCommands.data(), mDrawCommands.size());
 192     }
 193
 194     if(mResendFlag & RESEND_FACE_CULLING_MODE)
 195     {
 196       using DerivedType = MessageValue1<Render::Renderer, FaceCullingMode::Type>;
 197       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 198       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode);
 199     }
 200
 201     if(mResendFlag & RESEND_BLEND_BIT_MASK)
 202     {
 203       using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
 204       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 205       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetBlendingBitMask, mBlendBitmask);
 206     }
 207
 208     if(mResendFlag & RESEND_BLEND_COLOR)
 209     {
 210       using DerivedType = MessageValue1<Render::Renderer, Vector4>;
 211       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 212       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetBlendColor, GetBlendColor());
 213     }
 214
 215     if(mResendFlag & RESEND_PREMULTIPLIED_ALPHA)
 216     {
 217       using DerivedType = MessageValue1<Render::Renderer, bool>;
 218       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 219       new(slot) DerivedType(rendererPtr, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled);
 220     }
 221
 222     if(mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT)
 223     {
 224       using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
 225       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 226       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement);
 227     }
 228
 229     if(mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT)
 230     {
 231       using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
 232       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 233       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount);
 234     }
 235
 236     if(mResendFlag & RESEND_DEPTH_WRITE_MODE)
 237     {
 238       using DerivedType = MessageValue1<Render::Renderer, DepthWriteMode::Type>;
 239       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 240       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode);
 241     }
 242
 243     if(mResendFlag & RESEND_DEPTH_TEST_MODE)
 244     {
 245       using DerivedType = MessageValue1<Render::Renderer, DepthTestMode::Type>;
 246       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 247       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDepthTestMode, mDepthTestMode);
 248     }
 249
 250     if(mResendFlag & RESEND_DEPTH_FUNCTION)
 251     {
 252       using DerivedType = MessageValue1<Render::Renderer, DepthFunction::Type>;
 253       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 254       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDepthFunction, mDepthFunction);
 255     }
 256
 257     if(mResendFlag & RESEND_RENDER_MODE)
 258     {
 259       using DerivedType = MessageValue1<Render::Renderer, RenderMode::Type>;
 260       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 261       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode);
 262     }
 263
 264     if(mResendFlag & RESEND_STENCIL_FUNCTION)
 265     {
 266       using DerivedType = MessageValue1<Render::Renderer, StencilFunction::Type>;
 267       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 268       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction);
 269     }
 270
 271     if(mResendFlag & RESEND_STENCIL_FUNCTION_MASK)
 272     {
 273       using DerivedType = MessageValue1<Render::Renderer, int>;
 274       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 275       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask);
 276     }
 277
 278     if(mResendFlag & RESEND_STENCIL_FUNCTION_REFERENCE)
 279     {
 280       using DerivedType = MessageValue1<Render::Renderer, int>;
 281       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 282       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference);
 283     }
 284
 285     if(mResendFlag & RESEND_STENCIL_MASK)
 286     {
 287       using DerivedType = MessageValue1<Render::Renderer, int>;
 288       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 289       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask);
 290     }
 291
 292     if(mResendFlag & RESEND_STENCIL_OPERATION_ON_FAIL)
 293     {
 294       using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
 295       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 296       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail);
 297     }
 298
 299     if(mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_FAIL)
 300     {
 301       using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
 302       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 303       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail);
 304     }
 305
 306     if(mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_PASS)
 307     {
 308       using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
 309       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 310       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass);
 311     }
 312
 313     if(mResendFlag & RESEND_SHADER)
 314     {
 315       using DerivedType = MessageValue1<Render::Renderer, bool>;
 316       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 317       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetShaderChanged, true);
 318     }
 319
 320     if(mResendFlag & RESEND_SET_RENDER_CALLBACK)
 321     {
 322       using DerivedType = MessageValue1<Render::Renderer, Dali::RenderCallback*>;
 323       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
 324       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetRenderCallback, mRenderCallback);
 325     }
 326     mResendFlag = 0;
 327   }
 328
 329   // Ensure collected map is up to date
 330   UpdateUniformMap(updateBufferIndex);
 331
 332   return rendererUpdated;
 333 }
 334
 335 void Renderer::SetTextures(TextureSet* textureSet)
 336 {
 337   DALI_ASSERT_DEBUG(textureSet != NULL && "Texture set pointer is NULL");
 338
 339   if(mTextureSet != textureSet)
 340   {
 341     mTextureSet = textureSet;
 342
 343     SetUpdated(true);
 344   }
 345 }
 346
 347 const Vector<Render::TextureKey>* Renderer::GetTextures() const
 348 {
 349   return mTextureSet ? &(mTextureSet->GetTextures()) : nullptr;
 350 }
 351
 352 const Vector<Render::Sampler*>* Renderer::GetSamplers() const
 353 {
 354   return mTextureSet ? &(mTextureSet->GetSamplers()) : nullptr;
 355 }
 356
 357 void Renderer::SetShader(Shader* shader)
 358 {
 359   DALI_ASSERT_DEBUG(shader != NULL && "Shader pointer is NULL");
 360
 361   if(mShader != shader)
 362   {
 363     mShader                 = shader;
 364     mShaderMapChangeCounter = 0u;
 365     mRegenerateUniformMap   = true;
 366     mResendFlag |= RESEND_GEOMETRY | RESEND_SHADER;
 367
 368     SetUpdated(true);
 369   }
 370 }
 371
 372 void Renderer::SetGeometry(Render::Geometry* geometry)
 373 {
 374   DALI_ASSERT_DEBUG(geometry != NULL && "Geometry pointer is NULL");
 375   if(mGeometry != geometry)
 376   {
 377     mGeometry = geometry;
 378
 379     if(mRenderer)
 380     {
 381       mResendFlag |= RESEND_GEOMETRY;
 382     }
 383     SetUpdated(true);
 384   }
 385 }
 386
 387 void Renderer::SetDepthIndex(int depthIndex)
 388 {
 389   if(mDepthIndex != depthIndex)
 390   {
 391     mDepthIndex = depthIndex;
 392
 393     SetUpdated(true);
 394   }
 395 }
 396
 397 void Renderer::SetFaceCullingMode(FaceCullingMode::Type faceCullingMode)
 398 {
 399   if(mFaceCullingMode != faceCullingMode)
 400   {
 401     mFaceCullingMode = faceCullingMode;
 402     mResendFlag |= RESEND_FACE_CULLING_MODE;
 403
 404     SetUpdated(true);
 405   }
 406 }
 407
 408 FaceCullingMode::Type Renderer::GetFaceCullingMode() const
 409 {
 410   return mFaceCullingMode;
 411 }
 412
 413 void Renderer::SetBlendMode(BlendMode::Type blendingMode)
 414 {
 415   if(mBlendMode != blendingMode)
 416   {
 417     mBlendMode = blendingMode;
 418
 419     SetUpdated(true);
 420   }
 421 }
 422
 423 BlendMode::Type Renderer::GetBlendMode() const
 424 {
 425   return mBlendMode;
 426 }
 427
 428 void Renderer::SetBlendingOptions(uint32_t options)
 429 {
 430   if(mBlendBitmask != options)
 431   {
 432     mBlendBitmask = options;
 433     mResendFlag |= RESEND_BLEND_BIT_MASK;
 434
 435     SetUpdated(true);
 436   }
 437 }
 438
 439 uint32_t Renderer::GetBlendingOptions() const
 440 {
 441   return mBlendBitmask;
 442 }
 443
 444 void Renderer::SetBlendColor(const Vector4& blendColor)
 445 {
 446   if(blendColor == Color::TRANSPARENT)
 447   {
 448     mBlendColor = nullptr;
 449   }
 450   else
 451   {
 452     if(!mBlendColor)
 453     {
 454       mBlendColor = new Vector4(blendColor);
 455     }
 456     else
 457     {
 458       *mBlendColor = blendColor;
 459     }
 460   }
 461
 462   mResendFlag |= RESEND_BLEND_COLOR;
 463
 464   SetUpdated(true);
 465 }
 466
 467 Vector4 Renderer::GetBlendColor() const
 468 {
 469   if(mBlendColor)
 470   {
 471     return *mBlendColor;
 472   }
 473   return Color::TRANSPARENT;
 474 }
 475
 476 void Renderer::SetIndexedDrawFirstElement(uint32_t firstElement)
 477 {
 478   if(mIndexedDrawFirstElement != firstElement)
 479   {
 480     mIndexedDrawFirstElement = firstElement;
 481     mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
 482
 483     SetUpdated(true);
 484   }
 485 }
 486
 487 uint32_t Renderer::GetIndexedDrawFirstElement() const
 488 {
 489   return mIndexedDrawFirstElement;
 490 }
 491
 492 void Renderer::SetIndexedDrawElementsCount(uint32_t elementsCount)
 493 {
 494   if(mIndexedDrawElementsCount != elementsCount)
 495   {
 496     mIndexedDrawElementsCount = elementsCount;
 497     mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
 498
 499     SetUpdated(true);
 500   }
 501 }
 502
 503 uint32_t Renderer::GetIndexedDrawElementsCount() const
 504 {
 505   return mIndexedDrawElementsCount;
 506 }
 507
 508 void Renderer::EnablePreMultipliedAlpha(bool preMultipled)
 509 {
 510   if(mPremultipledAlphaEnabled != preMultipled)
 511   {
 512     mPremultipledAlphaEnabled = preMultipled;
 513     mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
 514
 515     SetUpdated(true);
 516   }
 517 }
 518
 519 bool Renderer::IsPreMultipliedAlphaEnabled() const
 520 {
 521   return mPremultipledAlphaEnabled;
 522 }
 523
 524 void Renderer::SetDepthWriteMode(DepthWriteMode::Type depthWriteMode)
 525 {
 526   mDepthWriteMode = depthWriteMode;
 527   mResendFlag |= RESEND_DEPTH_WRITE_MODE;
 528 }
 529
 530 DepthWriteMode::Type Renderer::GetDepthWriteMode() const
 531 {
 532   return mDepthWriteMode;
 533 }
 534
 535 void Renderer::SetDepthTestMode(DepthTestMode::Type depthTestMode)
 536 {
 537   mDepthTestMode = depthTestMode;
 538   mResendFlag |= RESEND_DEPTH_TEST_MODE;
 539 }
 540
 541 DepthTestMode::Type Renderer::GetDepthTestMode() const
 542 {
 543   return mDepthTestMode;
 544 }
 545
 546 void Renderer::SetDepthFunction(DepthFunction::Type depthFunction)
 547 {
 548   mDepthFunction = depthFunction;
 549   mResendFlag |= RESEND_DEPTH_FUNCTION;
 550 }
 551
 552 DepthFunction::Type Renderer::GetDepthFunction() const
 553 {
 554   return mDepthFunction;
 555 }
 556
 557 void Renderer::SetRenderMode(RenderMode::Type mode)
 558 {
 559   mStencilParameters.renderMode = mode;
 560   mResendFlag |= RESEND_RENDER_MODE;
 561 }
 562
 563 void Renderer::SetStencilFunction(StencilFunction::Type stencilFunction)
 564 {
 565   mStencilParameters.stencilFunction = stencilFunction;
 566   mResendFlag |= RESEND_STENCIL_FUNCTION;
 567 }
 568
 569 void Renderer::SetStencilFunctionMask(int stencilFunctionMask)
 570 {
 571   mStencilParameters.stencilFunctionMask = stencilFunctionMask;
 572   mResendFlag |= RESEND_STENCIL_FUNCTION_MASK;
 573 }
 574
 575 void Renderer::SetStencilFunctionReference(int stencilFunctionReference)
 576 {
 577   mStencilParameters.stencilFunctionReference = stencilFunctionReference;
 578   mResendFlag |= RESEND_STENCIL_FUNCTION_REFERENCE;
 579 }
 580
 581 void Renderer::SetStencilMask(int stencilMask)
 582 {
 583   mStencilParameters.stencilMask = stencilMask;
 584   mResendFlag |= RESEND_STENCIL_MASK;
 585 }
 586
 587 void Renderer::SetStencilOperationOnFail(StencilOperation::Type stencilOperationOnFail)
 588 {
 589   mStencilParameters.stencilOperationOnFail = stencilOperationOnFail;
 590   mResendFlag |= RESEND_STENCIL_OPERATION_ON_FAIL;
 591 }
 592
 593 void Renderer::SetStencilOperationOnZFail(StencilOperation::Type stencilOperationOnZFail)
 594 {
 595   mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail;
 596   mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_FAIL;
 597 }
 598
 599 void Renderer::SetStencilOperationOnZPass(StencilOperation::Type stencilOperationOnZPass)
 600 {
 601   mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass;
 602   mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_PASS;
 603 }
 604
 605 void Renderer::SetRenderCallback(RenderCallback* callback)
 606 {
 607   if(mRenderCallback != callback)
 608   {
 609     mRenderCallback = callback;
 610     mResendFlag |= RESEND_SET_RENDER_CALLBACK;
 611
 612     SetUpdated(true);
 613   }
 614 }
 615
 616 const Render::Renderer::StencilParameters& Renderer::GetStencilParameters() const
 617 {
 618   return mStencilParameters;
 619 }
 620
 621 void Renderer::BakeOpacity(BufferIndex updateBufferIndex, float opacity)
 622 {
 623   mOpacity.Bake(updateBufferIndex, opacity);
 624
 625   SetUpdated(true);
 626 }
 627
 628 float Renderer::GetOpacity(BufferIndex updateBufferIndex) const
 629 {
 630   return mOpacity[updateBufferIndex];
 631 }
 632
 633 void Renderer::SetRenderingBehavior(DevelRenderer::Rendering::Type renderingBehavior)
 634 {
 635   if(mRenderingBehavior != renderingBehavior)
 636   {
 637     mRenderingBehavior = renderingBehavior;
 638
 639     SetUpdated(true);
 640   }
 641 }
 642
 643 DevelRenderer::Rendering::Type Renderer::GetRenderingBehavior() const
 644 {
 645   return mRenderingBehavior;
 646 }
 647
 648 void Renderer::DetachFromNodeDataProvider(const NodeDataProvider& node)
 649 {
 650   // TODO : Can we send this by Resend flag, or message?
 651   // Currently, we call DetachFromNodeDataProvider function even if Renderer is destroyed case.
 652   // We don't need to call that function if mRenderer is destroyed.
 653   //
 654   // But also, there is no way to validate node's lifecycle. So just detach synchronously.
 655   if(mRenderer)
 656   {
 657     Render::Renderer* rendererPtr = mRenderer.Get();
 658     rendererPtr->DetachFromNodeDataProvider(node);
 659   }
 660 }
 661
 662 // Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created )
 663 void Renderer::ConnectToSceneGraph(SceneController& sceneController, BufferIndex bufferIndex)
 664 {
 665   mRegenerateUniformMap = true;
 666   mSceneController      = &sceneController;
 667
 668   mRenderer = Render::Renderer::NewKey(this, mGeometry, mBlendBitmask, GetBlendColor(), static_cast<FaceCullingMode::Type>(mFaceCullingMode), mPremultipledAlphaEnabled, mDepthWriteMode, mDepthTestMode, mDepthFunction, mStencilParameters);
 669
 670   mSceneController->GetRenderMessageDispatcher().AddRenderer(mRenderer);
 671 }
 672
 673 // Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
 674 void Renderer::DisconnectFromSceneGraph(SceneController& sceneController, BufferIndex bufferIndex)
 675 {
 676   // Remove renderer from RenderManager
 677   if(mRenderer)
 678   {
 679     mSceneController->GetRenderMessageDispatcher().RemoveRenderer(mRenderer);
 680     mRenderer = Render::RendererKey{};
 681   }
 682   mSceneController = nullptr;
 683 }
 684
 685 Render::RendererKey Renderer::GetRenderer() const
 686 {
 687   return mRenderer;
 688 }
 689
 690 Renderer::OpacityType Renderer::GetOpacityType(BufferIndex updateBufferIndex, uint32_t renderPass, const Node& node) const
 691 {
 692   Renderer::OpacityType opacityType = Renderer::OPAQUE;
 693
 694   if(node.IsTransparent())
 695   {
 696     return Renderer::TRANSPARENT;
 697   }
 698
 699   switch(mBlendMode)
 700   {
 701     case BlendMode::ON_WITHOUT_CULL: // If the renderer should always be use blending and never want to be transparent by alpha.
 702     {
 703       opacityType = Renderer::TRANSLUCENT;
 704       break;
 705     }
 706     case BlendMode::ON: // If the renderer should always be use blending
 707     {
 708       float alpha = node.GetWorldColor(updateBufferIndex).a * mOpacity[updateBufferIndex];
 709       if(alpha <= FULLY_TRANSPARENT)
 710       {
 711         opacityType = Renderer::TRANSPARENT;
 712       }
 713       else
 714       {
 715         opacityType = Renderer::TRANSLUCENT;
 716       }
 717       break;
 718     }
 719     case BlendMode::AUTO:
 720     {
 721       if(BlendingOptions::IsAdvancedBlendEquationIncluded(mBlendBitmask))
 722       {
 723         opacityType = Renderer::TRANSLUCENT;
 724         break;
 725       }
 726
 727       if(mTextureSet && mTextureSet->HasAlpha())
 728       {
 729         opacityType = Renderer::TRANSLUCENT;
 730       }
 731       else
 732       {
 733         const auto& shaderData = mShader->GetShaderData(renderPass);
 734         if(shaderData && shaderData->HintEnabled(Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT))
 735         {
 736           opacityType = Renderer::TRANSLUCENT;
 737         }
 738       }
 739
 740       // renderer should determine opacity using the actor color
 741       float alpha = node.GetWorldColor(updateBufferIndex).a * mOpacity[updateBufferIndex];
 742       if(alpha <= FULLY_TRANSPARENT)
 743       {
 744         opacityType = Renderer::TRANSPARENT;
 745       }
 746       else if(alpha <= FULLY_OPAQUE)
 747       {
 748         opacityType = Renderer::TRANSLUCENT;
 749       }
 750
 751       break;
 752     }
 753     case BlendMode::USE_ACTOR_OPACITY: // the renderer should never use blending
 754     {
 755       // renderer should determine opacity using the actor color
 756       float alpha = node.GetWorldColor(updateBufferIndex).a;
 757       if(alpha <= FULLY_TRANSPARENT)
 758       {
 759         opacityType = Renderer::TRANSPARENT;
 760       }
 761       else if(alpha < FULLY_OPAQUE)
 762       {
 763         opacityType = Renderer::TRANSLUCENT;
 764       }
 765       else
 766       {
 767         opacityType = Renderer::OPAQUE;
 768       }
 769       break;
 770     }
 771     case BlendMode::OFF: // the renderer should never use blending
 772     default:
 773     {
 774       opacityType = Renderer::OPAQUE;
 775       break;
 776     }
 777   }
 778
 779   return opacityType;
 780 }
 781
 782 void Renderer::UpdateUniformMap(BufferIndex updateBufferIndex)
 783 {
 784   if(mRegenerateUniformMap)
 785   {
 786     CollectedUniformMap& localMap = mCollectedUniformMap;
 787     localMap.Clear();
 788
 789     const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
 790
 791     auto size = rendererUniformMap.Count();
 792     if(mShader)
 793     {
 794       size += mShader->GetUniformMap().Count();
 795     }
 796
 797     localMap.Reserve(size);
 798     localMap.AddMappings(rendererUniformMap);
 799     if(mShader)
 800     {
 801       localMap.AddMappings(mShader->GetUniformMap());
 802     }
 803     localMap.UpdateChangeCounter();
 804
 805     mRegenerateUniformMap = false;
 806     SetUpdated(true);
 807   }
 808 }
 809
 810 void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size)
 811 {
 812   mDrawCommands.clear();
 813   mDrawCommands.insert(mDrawCommands.end(), pDrawCommands, pDrawCommands + size);
 814   mResendFlag |= RESEND_DRAW_COMMANDS;
 815 }
 816
 817 bool Renderer::IsDirty() const
 818 {
 819   // Check whether the opacity property has changed
 820   return (Updated() || !mOpacity.IsClean());
 821 }
 822
 823 void Renderer::ResetToBaseValues(BufferIndex updateBufferIndex)
 824 {
 825   mOpacity.ResetToBaseValue(updateBufferIndex);
 826   if(mVisualProperties)
 827   {
 828     mVisualProperties->ResetToBaseValues(updateBufferIndex);
 829   }
 830 }
 831
 832 void Renderer::MarkAsDirty()
 833 {
 834   mOpacity.MarkAsDirty();
 835   if(mVisualProperties)
 836   {
 837     mVisualProperties->MarkAsDirty();
 838   }
 839 }
 840
 841 uint32_t Renderer::GetMemoryPoolCapacity()
 842 {
 843   return GetRendererMemoryPool().GetCapacity();
 844 }
 845
 846 void Renderer::OnMappingChanged()
 847 {
 848   // Properties have been registered on the base class.
 849   mRegenerateUniformMap = true; // Should remain true until this renderer is added to a RenderList.
 850 }
 851
 852 void Renderer::AddInitializeResetter(ResetterManager& manager) const
 853 {
 854   manager.AddRendererResetter(*this);
 855 }
 856
 857 const CollectedUniformMap& Renderer::GetCollectedUniformMap() const
 858 {
 859   return mCollectedUniformMap;
 860 }
 861
 862 bool Renderer::IsUpdated() const
 863 {
 864   if(Updated() || (mShader && mShader->Updated()))
 865   {
 866     return true;
 867   }
 868   return false;
 869 }
 870
 871 Vector4 Renderer::GetVisualTransformedUpdateArea(BufferIndex updateBufferIndex, const Vector4& originalUpdateArea) noexcept
 872 {
 873   if(mVisualProperties)
 874   {
 875     return mVisualProperties->GetVisualTransformedUpdateArea(updateBufferIndex, originalUpdateArea);
 876   }
 877   return originalUpdateArea;
 878 }
 879
 880 } // namespace SceneGraph
 881 } // namespace Internal
 882 } // namespace Dali