dali/internal/update/manager/render-instruction-processor.cpp

   1 /*
   2  * Copyright (c) 2020 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/update/manager/render-instruction-processor.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/actors/layer.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/internal/event/actors/layer-impl.h> // for the default sorting function
  25 #include <dali/internal/update/manager/sorted-layers.h>
  26 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
  27 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
  28 #include <dali/internal/render/common/render-item.h>
  29 #include <dali/internal/render/common/render-tracker.h>
  30 #include <dali/internal/render/common/render-instruction.h>
  31 #include <dali/internal/render/common/render-instruction-container.h>
  32 #include <dali/internal/render/shaders/scene-graph-shader.h>
  33 #include <dali/internal/render/renderers/render-renderer.h>
  34 #include <dali/internal/render/renderers/render-property-buffer.h>
  35 #include <dali/internal/update/nodes/scene-graph-layer.h>
  36
  37 namespace
  38 {
  39 #if defined(DEBUG_ENABLED)
  40 Debug::Filter* gRenderListLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RENDER_LISTS");
  41 #endif
  42 }
  43
  44 namespace Dali
  45 {
  46
  47 namespace Internal
  48 {
  49
  50 namespace SceneGraph
  51 {
  52
  53 namespace
  54 {
  55
  56 /**
  57  * Function which compares render items by shader/textureSet/geometry
  58  * @param[in] lhs Left hand side item
  59  * @param[in] rhs Right hand side item
  60  * @return True if left item is greater than right
  61  */
  62 inline bool PartialCompareItems( const RenderInstructionProcessor::SortAttributes& lhs,
  63                                  const RenderInstructionProcessor::SortAttributes& rhs )
  64 {
  65   if( lhs.shader == rhs.shader )
  66   {
  67     if( lhs.textureSet == rhs.textureSet )
  68     {
  69       return lhs.geometry < rhs.geometry;
  70     }
  71     return lhs.textureSet < rhs.textureSet;
  72   }
  73   return lhs.shader < rhs.shader;
  74 }
  75
  76 /**
  77  * Function which sorts render items by depth index then by instance
  78  * ptrs of shader/textureSet/geometry.
  79  * @param[in] lhs Left hand side item
  80  * @param[in] rhs Right hand side item
  81  * @return True if left item is greater than right
  82  */
  83 bool CompareItems( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
  84 {
  85   // @todo Consider replacing all these sortAttributes with a single long int that
  86   // encapsulates the same data (e.g. the middle-order bits of the ptrs).
  87   if( lhs.renderItem->mDepthIndex == rhs.renderItem->mDepthIndex )
  88   {
  89     return PartialCompareItems( lhs, rhs );
  90   }
  91   return lhs.renderItem->mDepthIndex < rhs.renderItem->mDepthIndex;
  92 }
  93
  94 /**
  95  * Function which sorts the render items by Z function, then
  96  * by instance ptrs of shader / geometry / material.
  97  * @param[in] lhs Left hand side item
  98  * @param[in] rhs Right hand side item
  99  * @return True if left item is greater than right
 100  */
 101 bool CompareItems3D( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
 102 {
 103   const bool lhsIsOpaque = lhs.renderItem->mIsOpaque;
 104   if( lhsIsOpaque == rhs.renderItem->mIsOpaque )
 105   {
 106     if( lhsIsOpaque )
 107     {
 108       // If both RenderItems are opaque, sort using shader, then material then geometry.
 109       return PartialCompareItems( lhs, rhs );
 110     }
 111     else
 112     {
 113       // If both RenderItems are transparent, sort using Z, then shader, then material, then geometry.
 114       if( Equals( lhs.zValue, rhs.zValue ) )
 115       {
 116         return PartialCompareItems( lhs, rhs );
 117       }
 118       return lhs.zValue > rhs.zValue;
 119     }
 120   }
 121   else
 122   {
 123     return lhsIsOpaque;
 124   }
 125 }
 126
 127 /**
 128  * Function which sorts render items by clipping hierarchy, then Z function and instance ptrs of shader / geometry / material.
 129  * @param[in] lhs Left hand side item
 130  * @param[in] rhs Right hand side item
 131  * @return True if left item is greater than right
 132  */
 133 bool CompareItems3DWithClipping( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
 134 {
 135   // Items must be sorted in order of clipping first, otherwise incorrect clipping regions could be used.
 136   if( lhs.renderItem->mNode->mClippingSortModifier == rhs.renderItem->mNode->mClippingSortModifier )
 137   {
 138     return CompareItems3D( lhs, rhs );
 139   }
 140
 141   return lhs.renderItem->mNode->mClippingSortModifier < rhs.renderItem->mNode->mClippingSortModifier;
 142 }
 143
 144 /**
 145  * Add a renderer to the list
 146  * @param updateBufferIndex to read the model matrix from
 147  * @param renderList to add the item to
 148  * @param renderable Node-Renderer pair
 149  * @param viewMatrix used to calculate modelview matrix for the item
 150  * @param camera The camera used to render
 151  * @param isLayer3d Whether we are processing a 3D layer or not
 152  * @param cull Whether frustum culling is enabled or not
 153  */
 154 inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
 155                                      RenderList& renderList,
 156                                      Renderable& renderable,
 157                                      const Matrix& viewMatrix,
 158                                      SceneGraph::Camera& camera,
 159                                      bool isLayer3d,
 160                                      bool cull )
 161 {
 162   bool inside( true );
 163   Node* node = renderable.mNode;
 164
 165   if( cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
 166   {
 167     const Vector4& boundingSphere = node->GetBoundingSphere();
 168     inside = ( boundingSphere.w > Math::MACHINE_EPSILON_1000 ) &&
 169              ( camera.CheckSphereInFrustum( updateBufferIndex, Vector3( boundingSphere ), boundingSphere.w ) );
 170   }
 171
 172   if( inside )
 173   {
 174     Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType( updateBufferIndex, *renderable.mNode ) : Renderer::OPAQUE;
 175     if( opacityType != Renderer::TRANSPARENT || node->GetClippingMode() == ClippingMode::CLIP_CHILDREN )
 176     {
 177       // Get the next free RenderItem.
 178       RenderItem& item = renderList.GetNextFreeItem();
 179
 180       item.mNode = renderable.mNode;
 181       item.mIsOpaque = ( opacityType == Renderer::OPAQUE );
 182       item.mDepthIndex = 0;
 183
 184       if(!isLayer3d)
 185       {
 186         item.mDepthIndex = renderable.mNode->GetDepthIndex();
 187       }
 188
 189       if( DALI_LIKELY( renderable.mRenderer ) )
 190       {
 191         item.mRenderer =   &renderable.mRenderer->GetRenderer();
 192         item.mTextureSet =  renderable.mRenderer->GetTextures();
 193         item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
 194       }
 195       else
 196       {
 197         item.mRenderer = nullptr;
 198       }
 199
 200       // Save ModelView matrix onto the item.
 201       node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
 202
 203       Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
 204     }
 205
 206      node->SetCulled( updateBufferIndex, false );
 207   }
 208   else
 209   {
 210      node->SetCulled( updateBufferIndex, true );
 211   }
 212 }
 213
 214 /**
 215  * Add all renderers to the list
 216  * @param updateBufferIndex to read the model matrix from
 217  * @param renderList to add the items to
 218  * @param renderers to render
 219  * NodeRendererContainer Node-Renderer pairs
 220  * @param viewMatrix used to calculate modelview matrix for the items
 221  * @param camera The camera used to render
 222  * @param isLayer3d Whether we are processing a 3D layer or not
 223  * @param cull Whether frustum culling is enabled or not
 224  */
 225 inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
 226                                       RenderList& renderList,
 227                                       RenderableContainer& renderers,
 228                                       const Matrix& viewMatrix,
 229                                       SceneGraph::Camera& camera,
 230                                       bool isLayer3d,
 231                                       bool cull )
 232 {
 233   DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
 234
 235   for( auto&& renderer : renderers )
 236   {
 237     AddRendererToRenderList( updateBufferIndex,
 238                              renderList,
 239                              renderer,
 240                              viewMatrix,
 241                              camera,
 242                              isLayer3d,
 243                              cull );
 244   }
 245 }
 246
 247 /**
 248  * Try to reuse cached RenderItems from the RenderList
 249  * This avoids recalculating the model view matrices in case this part of the scene was static
 250  * An example case is a toolbar layer that rarely changes or a popup on top of the rest of the stage
 251  * @param layer that is being processed
 252  * @param renderList that is cached from frame N-1
 253  * @param renderables list of renderables
 254  */
 255 inline bool TryReuseCachedRenderers( Layer& layer,
 256                                      RenderList& renderList,
 257                                      RenderableContainer& renderables )
 258 {
 259   bool retValue = false;
 260   uint32_t renderableCount = static_cast<uint32_t>( renderables.Size() );
 261   // Check that the cached list originates from this layer and that the counts match
 262   if( ( renderList.GetSourceLayer() == &layer )&&
 263       ( renderList.GetCachedItemCount() == renderableCount ) )
 264   {
 265     // Check that all the same renderers are there. This gives us additional security in avoiding rendering the wrong things.
 266     // Render list is sorted so at this stage renderers may be in different order.
 267     // Therefore we check a combined sum of all renderer addresses.
 268     size_t checkSumNew = 0;
 269     size_t checkSumOld = 0;
 270     for( uint32_t index = 0; index < renderableCount; ++index )
 271     {
 272       const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
 273       checkSumNew += reinterpret_cast<std::size_t>( &renderer );
 274       checkSumOld += reinterpret_cast<std::size_t>( &renderList.GetRenderer( index ) );
 275     }
 276     if( checkSumNew == checkSumOld )
 277     {
 278       // tell list to reuse its existing items
 279       renderList.ReuseCachedItems();
 280       retValue = true;
 281     }
 282   }
 283   return retValue;
 284 }
 285
 286 inline bool SetupRenderList( RenderableContainer& renderables,
 287                              Layer& layer,
 288                              RenderInstruction& instruction,
 289                              bool tryReuseRenderList,
 290                              RenderList** renderList )
 291 {
 292   *renderList = &( instruction.GetNextFreeRenderList( renderables.Size() ) );
 293   ( *renderList )->SetClipping( layer.IsClipping(), layer.GetClippingBox() );
 294   ( *renderList )->SetSourceLayer( &layer );
 295
 296   // Try to reuse cached RenderItems from last time around.
 297   return ( tryReuseRenderList && TryReuseCachedRenderers( layer, **renderList, renderables ) );
 298 }
 299
 300 } // Anonymous namespace.
 301
 302
 303 RenderInstructionProcessor::RenderInstructionProcessor()
 304 : mSortingHelper()
 305 {
 306   // Set up a container of comparators for fast run-time selection.
 307   mSortComparitors.Reserve( 3u );
 308
 309   mSortComparitors.PushBack( CompareItems );
 310   mSortComparitors.PushBack( CompareItems3D );
 311   mSortComparitors.PushBack( CompareItems3DWithClipping );
 312 }
 313
 314 RenderInstructionProcessor::~RenderInstructionProcessor()
 315 {
 316 }
 317
 318 inline void RenderInstructionProcessor::SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder )
 319 {
 320   const uint32_t renderableCount = static_cast<uint32_t>( renderList.Count() );
 321   // Reserve space if needed.
 322   const uint32_t oldcapacity = static_cast<uint32_t>( mSortingHelper.size() );
 323   if( oldcapacity < renderableCount )
 324   {
 325     mSortingHelper.reserve( renderableCount );
 326     // Add real objects (reserve does not construct objects).
 327     mSortingHelper.insert( mSortingHelper.begin() + oldcapacity,
 328                           (renderableCount - oldcapacity),
 329                           RenderInstructionProcessor::SortAttributes() );
 330   }
 331   else
 332   {
 333     // Clear extra elements from helper, does not decrease capability.
 334     mSortingHelper.resize( renderableCount );
 335   }
 336
 337   // Calculate the sorting value, once per item by calling the layers sort function.
 338   // Using an if and two for-loops rather than if inside for as its better for branch prediction.
 339   if( layer.UsesDefaultSortFunction() )
 340   {
 341     for( uint32_t index = 0; index < renderableCount; ++index )
 342     {
 343       RenderItem& item = renderList.GetItem( index );
 344
 345       if( item.mRenderer )
 346       {
 347         item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
 348       }
 349
 350       // texture set
 351       mSortingHelper[ index ].textureSet = item.mTextureSet;
 352
 353       // The default sorting function should get inlined here.
 354       mSortingHelper[ index ].zValue = Internal::Layer::ZValue( item.mModelViewMatrix.GetTranslation3() ) - static_cast<float>( item.mDepthIndex );
 355
 356       // Keep the renderitem pointer in the helper so we can quickly reorder items after sort.
 357       mSortingHelper[ index ].renderItem = &item;
 358     }
 359   }
 360   else
 361   {
 362     const Dali::Layer::SortFunctionType sortFunction = layer.GetSortFunction();
 363     for( uint32_t index = 0; index < renderableCount; ++index )
 364     {
 365       RenderItem& item = renderList.GetItem( index );
 366
 367       item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
 368
 369       // texture set
 370       mSortingHelper[ index ].textureSet = item.mTextureSet;
 371
 372
 373       mSortingHelper[ index ].zValue = (*sortFunction)( item.mModelViewMatrix.GetTranslation3() ) - static_cast<float>( item.mDepthIndex );
 374
 375       // Keep the RenderItem pointer in the helper so we can quickly reorder items after sort.
 376       mSortingHelper[ index ].renderItem = &item;
 377     }
 378   }
 379
 380   // Here we determine which comparitor (of the 3) to use.
 381   //   0 is LAYER_UI
 382   //   1 is LAYER_3D
 383   //   2 is LAYER_3D + Clipping
 384   const unsigned int comparitorIndex = layer.GetBehavior() == Dali::Layer::LAYER_3D ? respectClippingOrder ? 2u : 1u : 0u;
 385
 386   std::stable_sort( mSortingHelper.begin(), mSortingHelper.end(), mSortComparitors[ comparitorIndex ] );
 387
 388   // Reorder / re-populate the RenderItems in the RenderList to correct order based on the sortinghelper.
 389   DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "Sorted Transparent List:\n");
 390   RenderItemContainer::Iterator renderListIter = renderList.GetContainer().Begin();
 391   for( uint32_t index = 0; index < renderableCount; ++index, ++renderListIter )
 392   {
 393     *renderListIter = mSortingHelper[ index ].renderItem;
 394     DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "  sortedList[%d] = %p\n", index, mSortingHelper[ index ].renderItem->mRenderer);
 395   }
 396 }
 397
 398 void RenderInstructionProcessor::Prepare( BufferIndex updateBufferIndex,
 399                                           SortedLayerPointers& sortedLayers,
 400                                           Context& context,
 401                                           RenderTask& renderTask,
 402                                           bool cull,
 403                                           bool hasClippingNodes,
 404                                           RenderInstructionContainer& instructions )
 405 {
 406   // Retrieve the RenderInstruction buffer from the RenderInstructionContainer
 407   // then populate with instructions.
 408   RenderInstruction& instruction = renderTask.PrepareRenderInstruction( updateBufferIndex );
 409   bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
 410   bool isRenderListAdded = false;
 411   bool isRootLayerDirty = false;
 412
 413   const Matrix& viewMatrix = renderTask.GetViewMatrix( updateBufferIndex );
 414   SceneGraph::Camera& camera = renderTask.GetCamera();
 415
 416   const SortedLayersIter endIter = sortedLayers.end();
 417   for( SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter )
 418   {
 419     Layer& layer = **iter;
 420     const bool tryReuseRenderList( viewMatrixHasNotChanged && layer.CanReuseRenderers( &renderTask.GetCamera() ) );
 421     const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
 422     RenderList* renderList = NULL;
 423
 424     if( layer.IsRoot() && ( layer.GetDirtyFlags() != NodePropertyFlags::NOTHING ) )
 425     {
 426       // If root-layer & dirty, i.e. a property has changed or a child has been deleted, then we need to ensure we render once more
 427       isRootLayerDirty = true;
 428     }
 429
 430     if( !layer.colorRenderables.Empty() )
 431     {
 432       RenderableContainer& renderables = layer.colorRenderables;
 433
 434       if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
 435       {
 436         renderList->SetHasColorRenderItems( true );
 437         AddRenderersToRenderList( updateBufferIndex,
 438                                   *renderList,
 439                                   renderables,
 440                                   viewMatrix,
 441                                   camera,
 442                                   isLayer3D,
 443                                   cull );
 444
 445         // We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
 446         SortRenderItems( updateBufferIndex, *renderList, layer, hasClippingNodes );
 447       }
 448
 449       isRenderListAdded = true;
 450     }
 451
 452     if( !layer.overlayRenderables.Empty() )
 453     {
 454       RenderableContainer& renderables = layer.overlayRenderables;
 455
 456       if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
 457       {
 458         renderList->SetHasColorRenderItems( false );
 459         AddRenderersToRenderList( updateBufferIndex,
 460                                   *renderList,
 461                                   renderables,
 462                                   viewMatrix,
 463                                   camera,
 464                                   isLayer3D,
 465                                   cull );
 466
 467         // Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor.
 468         SortRenderItems( updateBufferIndex, *renderList, layer, false );
 469       }
 470
 471       isRenderListAdded = true;
 472     }
 473   }
 474
 475   // Inform the render instruction that all renderers have been added and this frame is complete.
 476   instruction.UpdateCompleted();
 477
 478   if( isRenderListAdded || instruction.mIsClearColorSet || isRootLayerDirty )
 479   {
 480     instruction.mContext = &context;
 481     instructions.PushBack( updateBufferIndex, &instruction );
 482   }
 483 }
 484
 485 } // SceneGraph
 486
 487 } // Internal
 488
 489 } // Dali