2 * Copyright (c) 2018 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/render/renderers/render-property-buffer.h>
35 #include <dali/internal/update/nodes/scene-graph-layer.h>
39 #if defined(DEBUG_ENABLED)
40 Debug::Filter* gRenderListLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RENDER_LISTS");
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
62 inline bool PartialCompareItems( const RenderInstructionProcessor::SortAttributes& lhs,
63 const RenderInstructionProcessor::SortAttributes& rhs )
65 if( lhs.shader == rhs.shader )
67 if( lhs.textureSet == rhs.textureSet )
69 return lhs.geometry < rhs.geometry;
71 return lhs.textureSet < rhs.textureSet;
73 return lhs.shader < rhs.shader;
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
83 bool CompareItems( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
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 )
89 return PartialCompareItems( lhs, rhs );
91 return lhs.renderItem->mDepthIndex < rhs.renderItem->mDepthIndex;
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
101 bool CompareItems3D( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
103 const bool lhsIsOpaque = lhs.renderItem->mIsOpaque;
104 if( lhsIsOpaque == rhs.renderItem->mIsOpaque )
108 // If both RenderItems are opaque, sort using shader, then material then geometry.
109 return PartialCompareItems( lhs, rhs );
113 // If both RenderItems are transparent, sort using Z, then shader, then material, then geometry.
114 if( Equals( lhs.zValue, rhs.zValue ) )
116 return PartialCompareItems( lhs, rhs );
118 return lhs.zValue > rhs.zValue;
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
133 bool CompareItems3DWithClipping( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
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 )
138 return CompareItems3D( lhs, rhs );
141 return lhs.renderItem->mNode->mClippingSortModifier < rhs.renderItem->mNode->mClippingSortModifier;
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
154 inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
155 RenderList& renderList,
156 Renderable& renderable,
157 const Matrix& viewMatrix,
158 SceneGraph::Camera& camera,
163 const Node* node = renderable.mNode;
165 if( cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
167 const Vector4& boundingSphere = node->GetBoundingSphere();
168 inside = ( boundingSphere.w > Math::MACHINE_EPSILON_1000 ) &&
169 ( camera.CheckSphereInFrustum( updateBufferIndex, Vector3( boundingSphere ), boundingSphere.w ) );
174 Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType( updateBufferIndex, *renderable.mNode ) : Renderer::OPAQUE;
175 if( opacityType != Renderer::TRANSPARENT || node->GetClippingMode() == ClippingMode::CLIP_CHILDREN )
177 // Get the next free RenderItem.
178 RenderItem& item = renderList.GetNextFreeItem();
180 item.mNode = renderable.mNode;
181 item.mIsOpaque = ( opacityType == Renderer::OPAQUE );
182 item.mDepthIndex = 0;
186 item.mDepthIndex = renderable.mNode->GetDepthIndex();
189 if( DALI_LIKELY( renderable.mRenderer ) )
191 item.mRenderer = &renderable.mRenderer->GetRenderer();
192 item.mTextureSet = renderable.mRenderer->GetTextures();
193 item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
197 item.mRenderer = nullptr;
200 // Save ModelView matrix onto the item.
201 node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
203 Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
209 * Add all renderers to the list
210 * @param updateBufferIndex to read the model matrix from
211 * @param renderList to add the items to
212 * @param renderers to render
213 * NodeRendererContainer Node-Renderer pairs
214 * @param viewMatrix used to calculate modelview matrix for the items
215 * @param camera The camera used to render
216 * @param isLayer3d Whether we are processing a 3D layer or not
217 * @param cull Whether frustum culling is enabled or not
219 inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
220 RenderList& renderList,
221 RenderableContainer& renderers,
222 const Matrix& viewMatrix,
223 SceneGraph::Camera& camera,
227 DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
229 unsigned int rendererCount( renderers.Size() );
230 for( unsigned int i(0); i < rendererCount; ++i )
232 AddRendererToRenderList( updateBufferIndex,
243 * Try to reuse cached RenderItems from the RenderList
244 * This avoids recalculating the model view matrices in case this part of the scene was static
245 * An example case is a toolbar layer that rarely changes or a popup on top of the rest of the stage
246 * @param layer that is being processed
247 * @param renderList that is cached from frame N-1
248 * @param renderables list of renderables
250 inline bool TryReuseCachedRenderers( Layer& layer,
251 RenderList& renderList,
252 RenderableContainer& renderables )
254 bool retValue = false;
255 size_t renderableCount = renderables.Size();
256 // Check that the cached list originates from this layer and that the counts match
257 if( ( renderList.GetSourceLayer() == &layer )&&
258 ( renderList.GetCachedItemCount() == renderableCount ) )
260 // Check that all the same renderers are there. This gives us additional security in avoiding rendering the wrong things.
261 // Render list is sorted so at this stage renderers may be in different order.
262 // Therefore we check a combined sum of all renderer addresses.
263 size_t checkSumNew = 0;
264 size_t checkSumOld = 0;
265 for( size_t index = 0; index < renderableCount; ++index )
267 const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
268 checkSumNew += size_t( &renderer );
269 checkSumOld += size_t( &renderList.GetRenderer( index ) );
271 if( checkSumNew == checkSumOld )
273 // tell list to reuse its existing items
274 renderList.ReuseCachedItems();
281 inline bool SetupRenderList( RenderableContainer& renderables,
283 RenderInstruction& instruction,
284 bool tryReuseRenderList,
285 RenderList** renderList )
287 *renderList = &( instruction.GetNextFreeRenderList( renderables.Size() ) );
288 ( *renderList )->SetClipping( layer.IsClipping(), layer.GetClippingBox() );
289 ( *renderList )->SetSourceLayer( &layer );
291 // Try to reuse cached RenderItems from last time around.
292 return ( tryReuseRenderList && TryReuseCachedRenderers( layer, **renderList, renderables ) );
295 } // Anonymous namespace.
298 RenderInstructionProcessor::RenderInstructionProcessor()
301 // Set up a container of comparators for fast run-time selection.
302 mSortComparitors.Reserve( 3u );
304 mSortComparitors.PushBack( CompareItems );
305 mSortComparitors.PushBack( CompareItems3D );
306 mSortComparitors.PushBack( CompareItems3DWithClipping );
309 RenderInstructionProcessor::~RenderInstructionProcessor()
313 inline void RenderInstructionProcessor::SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder )
315 const size_t renderableCount = renderList.Count();
316 // Reserve space if needed.
317 const unsigned int oldcapacity = mSortingHelper.size();
318 if( oldcapacity < renderableCount )
320 mSortingHelper.reserve( renderableCount );
321 // Add real objects (reserve does not construct objects).
322 mSortingHelper.insert( mSortingHelper.begin() + oldcapacity,
323 (renderableCount - oldcapacity),
324 RenderInstructionProcessor::SortAttributes() );
328 // Clear extra elements from helper, does not decrease capability.
329 mSortingHelper.resize( renderableCount );
332 // Calculate the sorting value, once per item by calling the layers sort function.
333 // Using an if and two for-loops rather than if inside for as its better for branch prediction.
334 if( layer.UsesDefaultSortFunction() )
336 for( size_t index = 0; index < renderableCount; ++index )
338 RenderItem& item = renderList.GetItem( index );
342 item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
346 mSortingHelper[ index ].textureSet = item.mTextureSet;
348 // The default sorting function should get inlined here.
349 mSortingHelper[ index ].zValue = Internal::Layer::ZValue( item.mModelViewMatrix.GetTranslation3() ) - item.mDepthIndex;
351 // Keep the renderitem pointer in the helper so we can quickly reorder items after sort.
352 mSortingHelper[ index ].renderItem = &item;
357 const Dali::Layer::SortFunctionType sortFunction = layer.GetSortFunction();
358 for( size_t index = 0; index < renderableCount; ++index )
360 RenderItem& item = renderList.GetItem( index );
362 item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
365 mSortingHelper[ index ].textureSet = item.mTextureSet;
368 mSortingHelper[ index ].zValue = (*sortFunction)( item.mModelViewMatrix.GetTranslation3() ) - item.mDepthIndex;
370 // Keep the RenderItem pointer in the helper so we can quickly reorder items after sort.
371 mSortingHelper[ index ].renderItem = &item;
375 // Here we determine which comparitor (of the 3) to use.
378 // 2 is LAYER_3D + Clipping
379 const unsigned int comparitorIndex = layer.GetBehavior() == Dali::Layer::LAYER_3D ? respectClippingOrder ? 2u : 1u : 0u;
381 std::stable_sort( mSortingHelper.begin(), mSortingHelper.end(), mSortComparitors[ comparitorIndex ] );
383 // Reorder / re-populate the RenderItems in the RenderList to correct order based on the sortinghelper.
384 DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "Sorted Transparent List:\n");
385 RenderItemContainer::Iterator renderListIter = renderList.GetContainer().Begin();
386 for( unsigned int index = 0; index < renderableCount; ++index, ++renderListIter )
388 *renderListIter = mSortingHelper[ index ].renderItem;
389 DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, mSortingHelper[ index ].renderItem->mRenderer);
393 void RenderInstructionProcessor::Prepare( BufferIndex updateBufferIndex,
394 SortedLayerPointers& sortedLayers,
395 RenderTask& renderTask,
397 bool hasClippingNodes,
398 RenderInstructionContainer& instructions )
400 // Retrieve the RenderInstruction buffer from the RenderInstructionContainer
401 // then populate with instructions.
402 RenderInstruction& instruction = instructions.GetNextInstruction( updateBufferIndex );
403 renderTask.PrepareRenderInstruction( instruction, updateBufferIndex );
404 bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
405 bool isRenderListAdded = false;
407 const Matrix& viewMatrix = renderTask.GetViewMatrix( updateBufferIndex );
408 SceneGraph::Camera& camera = renderTask.GetCamera();
410 const SortedLayersIter endIter = sortedLayers.end();
411 for( SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter )
413 Layer& layer = **iter;
414 const bool tryReuseRenderList( viewMatrixHasNotChanged && layer.CanReuseRenderers( &renderTask.GetCamera() ) );
415 const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
416 RenderList* renderList = NULL;
418 if( !layer.colorRenderables.Empty() )
420 RenderableContainer& renderables = layer.colorRenderables;
422 if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
424 renderList->SetHasColorRenderItems( true );
425 AddRenderersToRenderList( updateBufferIndex,
433 // We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
434 SortRenderItems( updateBufferIndex, *renderList, layer, hasClippingNodes );
437 isRenderListAdded = true;
440 if( !layer.overlayRenderables.Empty() )
442 RenderableContainer& renderables = layer.overlayRenderables;
444 if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
446 renderList->SetHasColorRenderItems( false );
447 AddRenderersToRenderList( updateBufferIndex,
455 // Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor.
456 SortRenderItems( updateBufferIndex, *renderList, layer, false );
459 isRenderListAdded = true;
463 // Inform the render instruction that all renderers have been added and this frame is complete.
464 instruction.UpdateCompleted();
466 if( !isRenderListAdded && !instruction.mIsClearColorSet )
468 instructions.DiscardCurrentInstruction( updateBufferIndex );