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

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