2 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <dali/internal/update/manager/render-instruction-processor.h>
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/update/nodes/scene-graph-layer.h>
38 #if defined(DEBUG_ENABLED)
39 Debug::Filter* gRenderListLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RENDER_LISTS");
56 * Function which compares render items by shader/textureSet/geometry
57 * @param[in] lhs Left hand side item
58 * @param[in] rhs Right hand side item
59 * @return True if left item is greater than right
61 inline bool PartialCompareItems( const RenderInstructionProcessor::SortAttributes& lhs,
62 const RenderInstructionProcessor::SortAttributes& rhs )
64 if( lhs.shader == rhs.shader )
66 if( lhs.textureSet == rhs.textureSet )
68 return lhs.geometry < rhs.geometry;
70 return lhs.textureSet < rhs.textureSet;
72 return lhs.shader < rhs.shader;
76 * Function which sorts render items by depth index then by instance
77 * ptrs of shader/textureSet/geometry.
78 * @param[in] lhs Left hand side item
79 * @param[in] rhs Right hand side item
80 * @return True if left item is greater than right
82 bool CompareItems( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
84 // @todo Consider replacing all these sortAttributes with a single long int that
85 // encapsulates the same data (e.g. the middle-order bits of the ptrs).
86 if( lhs.renderItem->mDepthIndex == rhs.renderItem->mDepthIndex )
88 return PartialCompareItems( lhs, rhs );
90 return lhs.renderItem->mDepthIndex < rhs.renderItem->mDepthIndex;
94 * Function which sorts the render items by Z function, then
95 * by instance ptrs of shader / geometry / material.
96 * @param[in] lhs Left hand side item
97 * @param[in] rhs Right hand side item
98 * @return True if left item is greater than right
100 bool CompareItems3D( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
102 const bool lhsIsOpaque = lhs.renderItem->mIsOpaque;
103 if( lhsIsOpaque == rhs.renderItem->mIsOpaque )
107 // If both RenderItems are opaque, sort using shader, then material then geometry.
108 return PartialCompareItems( lhs, rhs );
112 // If both RenderItems are transparent, sort using Z, then shader, then material, then geometry.
113 if( Equals( lhs.zValue, rhs.zValue ) )
115 return PartialCompareItems( lhs, rhs );
117 return lhs.zValue > rhs.zValue;
127 * Function which sorts render items by clipping hierarchy, then Z function and instance ptrs of shader / geometry / material.
128 * @param[in] lhs Left hand side item
129 * @param[in] rhs Right hand side item
130 * @return True if left item is greater than right
132 bool CompareItems3DWithClipping( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
134 // Items must be sorted in order of clipping first, otherwise incorrect clipping regions could be used.
135 if( lhs.renderItem->mNode->mClippingSortModifier == rhs.renderItem->mNode->mClippingSortModifier )
137 return CompareItems3D( lhs, rhs );
140 return lhs.renderItem->mNode->mClippingSortModifier < rhs.renderItem->mNode->mClippingSortModifier;
144 * Add a renderer to the list
145 * @param updateBufferIndex to read the model matrix from
146 * @param renderList to add the item to
147 * @param renderable Node-Renderer pair
148 * @param viewMatrix used to calculate modelview matrix for the item
149 * @param camera The camera used to render
150 * @param isLayer3d Whether we are processing a 3D layer or not
151 * @param cull Whether frustum culling is enabled or not
153 inline void AddRendererToRenderList(BufferIndex updateBufferIndex,
154 RenderList& renderList,
155 Renderable& renderable,
156 const Matrix& viewMatrix,
157 SceneGraph::Camera& camera,
162 Node* node = renderable.mNode;
164 if (cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY))
166 const Vector4& boundingSphere = node->GetBoundingSphere();
167 inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
168 (camera.CheckSphereInFrustum(updateBufferIndex, Vector3(boundingSphere), boundingSphere.w));
173 Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType( updateBufferIndex, *renderable.mNode ) : Renderer::OPAQUE;
174 if (opacityType != Renderer::TRANSPARENT || node->GetClippingMode() == ClippingMode::CLIP_CHILDREN)
176 // Get the next free RenderItem.
177 RenderItem& item = renderList.GetNextFreeItem();
179 item.mIsUpdated = (item.mNode != renderable.mNode);
180 item.mNode = renderable.mNode;
182 bool prevIsOpaque = item.mIsOpaque;
183 item.mIsOpaque = (opacityType == Renderer::OPAQUE);
184 item.mIsUpdated |= (prevIsOpaque != item.mIsOpaque);
186 Vector4 prevColor = item.mColor;
187 item.mColor = renderable.mNode->GetColor(updateBufferIndex);
188 item.mIsUpdated |= (prevColor != item.mColor);
190 int prevDepthIndex = item.mDepthIndex;
191 item.mDepthIndex = 0;
194 item.mDepthIndex = renderable.mNode->GetDepthIndex();
197 Render::Renderer* prevRenderer = item.mRenderer;
198 if (DALI_LIKELY(renderable.mRenderer))
200 item.mRenderer = &renderable.mRenderer->GetRenderer();
201 const void* prevTextureSet = item.mTextureSet;
202 item.mTextureSet = renderable.mRenderer->GetTextures();
203 item.mIsUpdated |= (prevTextureSet != item.mTextureSet);
204 item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
208 item.mRenderer = nullptr;
211 item.mIsUpdated |= (prevDepthIndex != item.mDepthIndex);
212 item.mIsUpdated |= (prevRenderer != item.mRenderer);
213 item.mIsUpdated |= isLayer3d;
215 if (!item.mIsUpdated)
217 Matrix prevModelViewMatrix = item.mModelViewMatrix;
218 Vector3 prevSize = item.mSize;
220 // Save ModelView matrix onto the item.
221 node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
222 Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
224 item.mIsUpdated = ((prevSize != item.mSize) || (item.mModelViewMatrix != prevModelViewMatrix));
228 // Save ModelView matrix onto the item.
229 node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
230 Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
233 item.mUpdateSize = node->GetUpdateSizeHint();
234 if (item.mUpdateSize == Vector3::ZERO)
236 // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform
237 // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be to slow
238 if (!isLayer3d && item.mModelMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f))
240 item.mUpdateSize = item.mSize;
245 node->SetCulled( updateBufferIndex, false );
249 node->SetCulled( updateBufferIndex, true );
254 * Add all renderers to the list
255 * @param updateBufferIndex to read the model matrix from
256 * @param renderList to add the items to
257 * @param renderers to render
258 * NodeRendererContainer Node-Renderer pairs
259 * @param viewMatrix used to calculate modelview matrix for the items
260 * @param camera The camera used to render
261 * @param isLayer3d Whether we are processing a 3D layer or not
262 * @param cull Whether frustum culling is enabled or not
264 inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
265 RenderList& renderList,
266 RenderableContainer& renderers,
267 const Matrix& viewMatrix,
268 SceneGraph::Camera& camera,
272 DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
274 for( auto&& renderer : renderers )
276 AddRendererToRenderList( updateBufferIndex,
287 * Try to reuse cached RenderItems from the RenderList
288 * This avoids recalculating the model view matrices in case this part of the scene was static
289 * An example case is a toolbar layer that rarely changes or a popup on top of the rest of the stage
290 * @param layer that is being processed
291 * @param renderList that is cached from frame N-1
292 * @param renderables list of renderables
294 inline bool TryReuseCachedRenderers( Layer& layer,
295 RenderList& renderList,
296 RenderableContainer& renderables )
298 bool retValue = false;
299 uint32_t renderableCount = static_cast<uint32_t>( renderables.Size() );
300 // Check that the cached list originates from this layer and that the counts match
301 if( ( renderList.GetSourceLayer() == &layer )&&
302 ( renderList.GetCachedItemCount() == renderableCount ) )
304 // Check that all the same renderers are there. This gives us additional security in avoiding rendering the wrong things.
305 // Render list is sorted so at this stage renderers may be in different order.
306 // Therefore we check a combined sum of all renderer addresses.
307 size_t checkSumNew = 0;
308 size_t checkSumOld = 0;
309 for( uint32_t index = 0; index < renderableCount; ++index )
311 const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
312 checkSumNew += reinterpret_cast<std::size_t>( &renderer );
313 checkSumOld += reinterpret_cast<std::size_t>( &renderList.GetRenderer( index ) );
315 if( checkSumNew == checkSumOld )
317 // tell list to reuse its existing items
318 renderList.ReuseCachedItems();
326 inline bool SetupRenderList( RenderableContainer& renderables,
328 RenderInstruction& instruction,
329 bool tryReuseRenderList,
330 RenderList** renderList )
332 *renderList = &( instruction.GetNextFreeRenderList( renderables.Size() ) );
333 ( *renderList )->SetClipping( layer.IsClipping(), layer.GetClippingBox() );
334 ( *renderList )->SetSourceLayer( &layer );
336 // Try to reuse cached RenderItems from last time around.
337 return ( tryReuseRenderList && TryReuseCachedRenderers( layer, **renderList, renderables ) );
340 } // Anonymous namespace.
343 RenderInstructionProcessor::RenderInstructionProcessor()
346 // Set up a container of comparators for fast run-time selection.
347 mSortComparitors.Reserve( 3u );
349 mSortComparitors.PushBack( CompareItems );
350 mSortComparitors.PushBack( CompareItems3D );
351 mSortComparitors.PushBack( CompareItems3DWithClipping );
354 RenderInstructionProcessor::~RenderInstructionProcessor() = default;
356 inline void RenderInstructionProcessor::SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder )
358 const uint32_t renderableCount = static_cast<uint32_t>( renderList.Count() );
359 // Reserve space if needed.
360 const uint32_t oldcapacity = static_cast<uint32_t>( mSortingHelper.size() );
361 if( oldcapacity < renderableCount )
363 mSortingHelper.reserve( renderableCount );
364 // Add real objects (reserve does not construct objects).
365 mSortingHelper.insert( mSortingHelper.begin() + oldcapacity,
366 (renderableCount - oldcapacity),
367 RenderInstructionProcessor::SortAttributes() );
371 // Clear extra elements from helper, does not decrease capability.
372 mSortingHelper.resize( renderableCount );
375 // Calculate the sorting value, once per item by calling the layers sort function.
376 // Using an if and two for-loops rather than if inside for as its better for branch prediction.
377 if( layer.UsesDefaultSortFunction() )
379 for( uint32_t index = 0; index < renderableCount; ++index )
381 RenderItem& item = renderList.GetItem( index );
385 item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
389 mSortingHelper[ index ].textureSet = item.mTextureSet;
391 // The default sorting function should get inlined here.
392 mSortingHelper[ index ].zValue = Internal::Layer::ZValue( item.mModelViewMatrix.GetTranslation3() ) - static_cast<float>( item.mDepthIndex );
394 // Keep the renderitem pointer in the helper so we can quickly reorder items after sort.
395 mSortingHelper[ index ].renderItem = &item;
400 const Dali::Layer::SortFunctionType sortFunction = layer.GetSortFunction();
401 for( uint32_t index = 0; index < renderableCount; ++index )
403 RenderItem& item = renderList.GetItem( index );
405 item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
408 mSortingHelper[ index ].textureSet = item.mTextureSet;
411 mSortingHelper[ index ].zValue = (*sortFunction)( item.mModelViewMatrix.GetTranslation3() ) - static_cast<float>( item.mDepthIndex );
413 // Keep the RenderItem pointer in the helper so we can quickly reorder items after sort.
414 mSortingHelper[ index ].renderItem = &item;
418 // Here we determine which comparitor (of the 3) to use.
421 // 2 is LAYER_3D + Clipping
422 const unsigned int comparitorIndex = layer.GetBehavior() == Dali::Layer::LAYER_3D ? respectClippingOrder ? 2u : 1u : 0u;
424 std::stable_sort( mSortingHelper.begin(), mSortingHelper.end(), mSortComparitors[ comparitorIndex ] );
426 // Reorder / re-populate the RenderItems in the RenderList to correct order based on the sortinghelper.
427 DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "Sorted Transparent List:\n");
428 RenderItemContainer::Iterator renderListIter = renderList.GetContainer().Begin();
429 for( uint32_t index = 0; index < renderableCount; ++index, ++renderListIter )
431 *renderListIter = mSortingHelper[ index ].renderItem;
432 DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, mSortingHelper[ index ].renderItem->mRenderer);
436 void RenderInstructionProcessor::Prepare( BufferIndex updateBufferIndex,
437 SortedLayerPointers& sortedLayers,
438 RenderTask& renderTask,
440 bool hasClippingNodes,
441 RenderInstructionContainer& instructions )
443 // Retrieve the RenderInstruction buffer from the RenderInstructionContainer
444 // then populate with instructions.
445 RenderInstruction& instruction = renderTask.PrepareRenderInstruction( updateBufferIndex );
446 bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
447 bool isRenderListAdded = false;
448 bool isRootLayerDirty = false;
450 const Matrix& viewMatrix = renderTask.GetViewMatrix( updateBufferIndex );
451 SceneGraph::Camera& camera = renderTask.GetCamera();
453 const SortedLayersIter endIter = sortedLayers.end();
454 for( SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter )
456 Layer& layer = **iter;
457 const bool tryReuseRenderList( viewMatrixHasNotChanged && layer.CanReuseRenderers( &renderTask.GetCamera() ) );
458 const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
459 RenderList* renderList = nullptr;
461 if( layer.IsRoot() && ( layer.GetDirtyFlags() != NodePropertyFlags::NOTHING ) )
463 // 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
464 isRootLayerDirty = true;
467 if( !layer.colorRenderables.Empty() )
469 RenderableContainer& renderables = layer.colorRenderables;
471 if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
473 renderList->SetHasColorRenderItems( true );
474 AddRenderersToRenderList( updateBufferIndex,
482 // We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
483 SortRenderItems( updateBufferIndex, *renderList, layer, hasClippingNodes );
486 isRenderListAdded = true;
489 if( !layer.overlayRenderables.Empty() )
491 RenderableContainer& renderables = layer.overlayRenderables;
493 if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
495 renderList->SetHasColorRenderItems( false );
496 AddRenderersToRenderList( updateBufferIndex,
504 // Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor.
505 SortRenderItems( updateBufferIndex, *renderList, layer, false );
508 isRenderListAdded = true;
512 // Inform the render instruction that all renderers have been added and this frame is complete.
513 instruction.UpdateCompleted();
515 if( isRenderListAdded || instruction.mIsClearColorSet || isRootLayerDirty )
517 instructions.PushBack( updateBufferIndex, &instruction );