2 * Copyright (c) 2022 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/integration-api/debug.h>
23 #include <dali/internal/common/matrix-utils.h>
24 #include <dali/internal/event/actors/layer-impl.h> // for the default sorting function
25 #include <dali/internal/render/common/render-instruction-container.h>
26 #include <dali/internal/render/common/render-instruction.h>
27 #include <dali/internal/render/common/render-item.h>
28 #include <dali/internal/render/common/render-tracker.h>
29 #include <dali/internal/render/renderers/render-renderer.h>
30 #include <dali/internal/render/shaders/render-shader.h>
31 #include <dali/internal/update/manager/sorted-layers.h>
32 #include <dali/internal/update/nodes/scene-graph-layer.h>
33 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
34 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
35 #include <dali/public-api/actors/layer.h>
39 #if defined(DEBUG_ENABLED)
40 Debug::Filter* gRenderListLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RENDER_LISTS");
53 * Function which compares render items by shader/textureSet/geometry
54 * @param[in] lhs Left hand side item
55 * @param[in] rhs Right hand side item
56 * @return True if left item is greater than right
58 inline bool PartialCompareItems(const RenderInstructionProcessor::SortAttributes& lhs,
59 const RenderInstructionProcessor::SortAttributes& rhs)
61 if(lhs.shader == rhs.shader)
63 if(lhs.textureSet == rhs.textureSet)
65 return lhs.geometry < rhs.geometry;
67 return lhs.textureSet < rhs.textureSet;
69 return lhs.shader < rhs.shader;
73 * Function which sorts render items by depth index then by instance
74 * ptrs of shader/textureSet/geometry.
75 * @param[in] lhs Left hand side item
76 * @param[in] rhs Right hand side item
77 * @return True if left item is greater than right
79 bool CompareItems(const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs)
81 // @todo Consider replacing all these sortAttributes with a single long int that
82 // encapsulates the same data (e.g. the middle-order bits of the ptrs).
83 if(lhs.renderItem->mDepthIndex == rhs.renderItem->mDepthIndex)
85 return PartialCompareItems(lhs, rhs);
87 return lhs.renderItem->mDepthIndex < rhs.renderItem->mDepthIndex;
91 * Function which sorts the render items by Z function, then
92 * by instance ptrs of shader / geometry / material.
93 * @param[in] lhs Left hand side item
94 * @param[in] rhs Right hand side item
95 * @return True if left item is greater than right
97 bool CompareItems3D(const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs)
99 const bool lhsIsOpaque = lhs.renderItem->mIsOpaque;
100 if(lhsIsOpaque == rhs.renderItem->mIsOpaque)
104 // If both RenderItems are opaque, sort using shader, then material then geometry.
105 return PartialCompareItems(lhs, rhs);
109 // If both RenderItems are transparent, sort using Z, then shader, then material, then geometry.
110 if(Equals(lhs.zValue, rhs.zValue))
112 return PartialCompareItems(lhs, rhs);
114 return lhs.zValue > rhs.zValue;
124 * Function which sorts render items by clipping hierarchy, then Z function and instance ptrs of shader / geometry / material.
125 * @param[in] lhs Left hand side item
126 * @param[in] rhs Right hand side item
127 * @return True if left item is greater than right
129 bool CompareItems3DWithClipping(const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs)
131 // Items must be sorted in order of clipping first, otherwise incorrect clipping regions could be used.
132 if(lhs.renderItem->mNode->mClippingSortModifier == rhs.renderItem->mNode->mClippingSortModifier)
134 return CompareItems3D(lhs, rhs);
137 return lhs.renderItem->mNode->mClippingSortModifier < rhs.renderItem->mNode->mClippingSortModifier;
141 * Set the update area of the node
142 * @param[in] node The node of the renderer
143 * @param[in] isLayer3d Whether we are processing a 3D layer or not
144 * @param[in,out] nodeWorldMatrix The world matrix of the node
145 * @param[in,out] nodeSize The size of the node
146 * @param[in,out] nodeUpdateArea The update area of the node
148 * @return True if node use it's own UpdateAreaHint, or z transform occured. False if we use nodeUpdateArea equal with Vector4(0, 0, nodeSize.width, nodeSize.height).
150 inline bool SetNodeUpdateArea(Node* node, bool isLayer3d, Matrix& nodeWorldMatrix, Vector3& nodeSize, Vector4& nodeUpdateArea)
152 node->GetWorldMatrixAndSize(nodeWorldMatrix, nodeSize);
154 if(node->GetUpdateAreaHint() == Vector4::ZERO)
156 // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform
157 // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be too slow
158 if(!isLayer3d && nodeWorldMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f))
160 nodeUpdateArea = Vector4(0.0f, 0.0f, nodeSize.width, nodeSize.height);
163 // Keep nodeUpdateArea as Vector4::ZERO, and return true.
168 nodeUpdateArea = node->GetUpdateAreaHint();
174 * Add a renderer to the list
175 * @param updateBufferIndex to read the model matrix from
176 * @param renderList to add the item to
177 * @param renderable Node-Renderer pair
178 * @param viewMatrix used to calculate modelview matrix for the item
179 * @param camera The camera used to render
180 * @param isLayer3d Whether we are processing a 3D layer or not
181 * @param viewportSet Whether the viewport is set or not
182 * @param viewport The viewport
183 * @param cull Whether frustum culling is enabled or not
185 inline void AddRendererToRenderList(BufferIndex updateBufferIndex,
186 RenderList& renderList,
187 Renderable& renderable,
188 const Matrix& viewMatrix,
189 const SceneGraph::Camera& camera,
192 const Viewport& viewport,
196 Node* node = renderable.mNode;
197 Matrix nodeWorldMatrix(false);
199 Vector4 nodeUpdateArea;
200 bool nodeUpdateAreaSet(false);
201 bool nodeUpdateAreaUseHint(false);
202 Matrix nodeModelViewMatrix(false);
203 bool nodeModelViewMatrixSet(false);
205 // Don't cull items which have render callback
206 bool hasRenderCallback = (renderable.mRenderer && renderable.mRenderer->GetRenderCallback());
208 if(cull && renderable.mRenderer && (hasRenderCallback || (!renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY) && node->GetClippingMode() == ClippingMode::DISABLED)))
210 const Vector4& boundingSphere = node->GetBoundingSphere();
211 inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
212 (camera.CheckSphereInFrustum(updateBufferIndex, Vector3(boundingSphere), boundingSphere.w));
214 if(inside && !isLayer3d && viewportSet)
216 nodeUpdateAreaUseHint = SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea);
217 nodeUpdateAreaSet = true;
219 const Vector3& scale = node->GetWorldScale(updateBufferIndex);
220 const Vector3& size = Vector3(nodeUpdateArea.z, nodeUpdateArea.w, 1.0f) * scale;
222 if(size.LengthSquared() > Math::MACHINE_EPSILON_1000)
224 MatrixUtils::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
225 nodeModelViewMatrixSet = true;
227 // Assume actors are at z=0, compute AABB in view space & test rect intersection
228 // against z=0 plane boundaries for frustum. (NOT viewport). This should take into account
229 // magnification due to FOV etc.
231 // TODO : Below logic might need to refactor it.
232 // If camera is Perspective, we need to calculate clipping box by FoV. Currently, we just believe default camera setup OrthographicSize well.
233 // - If then, It must use math calculate like tan(fov) internally. So, we might need calculate it only one times, and cache.
234 ClippingBox boundingBox = RenderItem::CalculateTransformSpaceAABB(nodeModelViewMatrix, Vector3(nodeUpdateArea.x, nodeUpdateArea.y, 0.0f), Vector3(nodeUpdateArea.z, nodeUpdateArea.w, 0.0f));
235 ClippingBox clippingBox = camera.GetOrthographicClippingBox(updateBufferIndex);
236 inside = clippingBox.Intersects(boundingBox);
240 * Note, the API Camera::CheckAABBInFrustum() can be used to test if a bounding box is (partially/fully) inside the view frustum.
246 bool skipRender(false);
247 bool isOpaque = true;
248 if(!hasRenderCallback)
250 Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType(updateBufferIndex, *node) : Renderer::OPAQUE;
252 // We can skip render when node is not clipping and transparent
253 skipRender = (opacityType == Renderer::TRANSPARENT && node->GetClippingMode() == ClippingMode::DISABLED);
255 isOpaque = (opacityType == Renderer::OPAQUE);
260 // Get the next free RenderItem.
261 RenderItem& item = renderList.GetNextFreeItem();
264 auto& partialRenderingData = node->GetPartialRenderingData();
266 auto& partialRenderingCacheInfo = node->GetPartialRenderingData().GetCurrentCacheInfo();
268 partialRenderingCacheInfo.node = node;
269 partialRenderingCacheInfo.isOpaque = isOpaque;
270 partialRenderingCacheInfo.renderer = renderable.mRenderer;
271 partialRenderingCacheInfo.color = node->GetWorldColor(updateBufferIndex);
272 partialRenderingCacheInfo.depthIndex = node->GetDepthIndex();
274 if(DALI_LIKELY(renderable.mRenderer))
276 partialRenderingCacheInfo.color.a *= renderable.mRenderer->GetOpacity(updateBufferIndex);
277 partialRenderingCacheInfo.textureSet = renderable.mRenderer->GetTextureSet();
281 item.mIsOpaque = isOpaque;
282 item.mColor = node->GetColor(updateBufferIndex);
284 item.mDepthIndex = 0;
287 item.mDepthIndex = node->GetDepthIndex();
290 if(DALI_LIKELY(renderable.mRenderer))
292 item.mRenderer = &renderable.mRenderer->GetRenderer();
293 item.mTextureSet = renderable.mRenderer->GetTextureSet();
294 item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
296 // Get whether collected map is up to date
297 item.mIsUpdated |= renderable.mRenderer->UniformMapUpdated();
301 item.mRenderer = nullptr;
304 item.mIsUpdated |= isLayer3d;
306 if(!nodeUpdateAreaSet)
308 nodeUpdateAreaUseHint = SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea);
311 item.mSize = nodeSize;
312 item.mUpdateArea = nodeUpdateArea;
313 item.mModelMatrix = nodeWorldMatrix;
315 // Apply transform informations if node doesn't have update size hint and use VisualRenderer.
316 if(!nodeUpdateAreaUseHint && renderable.mRenderer && renderable.mRenderer->GetVisualProperties())
318 Vector3 updateSize = renderable.mRenderer->CalculateVisualTransformedUpdateSize(updateBufferIndex, Vector3(item.mUpdateArea.z, item.mUpdateArea.w, 0.0f));
319 item.mUpdateArea.z = updateSize.x;
320 item.mUpdateArea.w = updateSize.y;
323 if(!nodeModelViewMatrixSet)
325 MatrixUtils::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
327 item.mModelViewMatrix = nodeModelViewMatrix;
329 partialRenderingCacheInfo.matrix = item.mModelViewMatrix;
330 partialRenderingCacheInfo.size = item.mSize;
331 partialRenderingCacheInfo.updatedPositionSize = item.mUpdateArea;
333 item.mIsUpdated = partialRenderingData.IsUpdated() || item.mIsUpdated;
335 partialRenderingData.mRendered = true;
337 partialRenderingData.SwapBuffers();
341 // Mark as not rendered
342 auto& partialRenderingData = node->GetPartialRenderingData();
343 partialRenderingData.mRendered = false;
346 node->SetCulled(updateBufferIndex, false);
350 // Mark as not rendered
351 auto& partialRenderingData = node->GetPartialRenderingData();
352 partialRenderingData.mRendered = false;
354 node->SetCulled(updateBufferIndex, true);
359 * Add all renderers to the list
360 * @param updateBufferIndex to read the model matrix from
361 * @param renderList to add the items to
362 * @param renderers to render
363 * NodeRendererContainer Node-Renderer pairs
364 * @param viewMatrix used to calculate modelview matrix for the items
365 * @param camera The camera used to render
366 * @param isLayer3d Whether we are processing a 3D layer or not
367 * @param cull Whether frustum culling is enabled or not
369 inline void AddRenderersToRenderList(BufferIndex updateBufferIndex,
370 RenderList& renderList,
371 RenderableContainer& renderers,
372 const Matrix& viewMatrix,
373 const SceneGraph::Camera& camera,
376 const Viewport& viewport,
379 DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
381 for(auto&& renderer : renderers)
383 AddRendererToRenderList(updateBufferIndex,
396 * Try to reuse cached RenderItems from the RenderList
397 * This avoids recalculating the model view matrices in case this part of the scene was static
398 * An example case is a toolbar layer that rarely changes or a popup on top of the rest of the stage
399 * @param layer that is being processed
400 * @param renderList that is cached from frame N-1
401 * @param renderables list of renderables
403 inline bool TryReuseCachedRenderers(Layer& layer,
404 RenderList& renderList,
405 RenderableContainer& renderables)
407 bool retValue = false;
408 uint32_t renderableCount = static_cast<uint32_t>(renderables.Size());
409 // Check that the cached list originates from this layer and that the counts match
410 if((renderList.GetSourceLayer() == &layer) &&
411 (renderList.GetCachedItemCount() == renderableCount))
413 // Check that all the same renderers are there. This gives us additional security in avoiding rendering the wrong things.
414 // Render list is sorted so at this stage renderers may be in different order.
415 // Therefore we check a combined sum of all renderer addresses.
416 size_t checkSumNew = 0;
417 size_t checkSumOld = 0;
418 for(uint32_t index = 0; index < renderableCount; ++index)
420 if(DALI_LIKELY(renderables[index].mRenderer))
422 const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
423 checkSumNew += reinterpret_cast<std::size_t>(&renderer);
425 if(DALI_LIKELY(renderList.GetItem(index).mRenderer))
427 checkSumOld += reinterpret_cast<std::size_t>(&renderList.GetRenderer(index));
430 if(checkSumNew == checkSumOld)
432 // tell list to reuse its existing items
433 renderList.ReuseCachedItems();
441 inline bool SetupRenderList(RenderableContainer& renderables,
443 RenderInstruction& instruction,
444 bool tryReuseRenderList,
445 RenderList** renderList)
447 *renderList = &(instruction.GetNextFreeRenderList(renderables.Size()));
448 (*renderList)->SetClipping(layer.IsClipping(), layer.GetClippingBox());
449 (*renderList)->SetSourceLayer(&layer);
451 // Try to reuse cached RenderItems from last time around.
452 return (tryReuseRenderList && TryReuseCachedRenderers(layer, **renderList, renderables));
455 } // Anonymous namespace.
457 RenderInstructionProcessor::RenderInstructionProcessor()
460 // Set up a container of comparators for fast run-time selection.
461 mSortComparitors.Reserve(3u);
463 mSortComparitors.PushBack(CompareItems);
464 mSortComparitors.PushBack(CompareItems3D);
465 mSortComparitors.PushBack(CompareItems3DWithClipping);
468 RenderInstructionProcessor::~RenderInstructionProcessor() = default;
470 inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder, bool isOrthographicCamera)
472 const uint32_t renderableCount = static_cast<uint32_t>(renderList.Count());
473 // Reserve space if needed.
474 const uint32_t oldcapacity = static_cast<uint32_t>(mSortingHelper.size());
475 if(oldcapacity < renderableCount)
477 mSortingHelper.reserve(renderableCount);
478 // Add real objects (reserve does not construct objects).
479 mSortingHelper.insert(mSortingHelper.begin() + oldcapacity,
480 (renderableCount - oldcapacity),
481 RenderInstructionProcessor::SortAttributes());
485 // Clear extra elements from helper, does not decrease capability.
486 mSortingHelper.resize(renderableCount);
489 // Calculate the sorting value, once per item by calling the layers sort function.
490 // Using an if and two for-loops rather than if inside for as its better for branch prediction.
492 // List of zValue calculating functions.
493 const Dali::Layer::SortFunctionType zValueFunctionFromVector3[] = {
494 [](const Vector3& position) { return position.z; },
495 [](const Vector3& position) { return position.LengthSquared(); },
496 layer.GetSortFunction(),
499 // Determine whether we need to use zValue as Euclidean distance or translatoin's z value.
500 // If layer is LAYER_UI or camera is OrthographicProjection mode, we don't need to calculate
501 // renderItem's distance from camera.
503 // Here we determine which zValue SortFunctionType (of the 3) to use.
504 // 0 is position z value : Default LAYER_UI or Orthographic camera
505 // 1 is distance square value : Default LAYER_3D and Perspective camera
506 // 2 is user defined function.
507 const int zValueFunctionIndex = layer.UsesDefaultSortFunction() ? ((layer.GetBehavior() == Dali::Layer::LAYER_UI || isOrthographicCamera) ? 0 : 1) : 2;
509 for(uint32_t index = 0; index < renderableCount; ++index)
511 RenderItem& item = renderList.GetItem(index);
513 if(DALI_LIKELY(item.mRenderer))
515 item.mRenderer->SetSortAttributes(mSortingHelper[index]);
519 mSortingHelper[index].textureSet = item.mTextureSet;
521 mSortingHelper[index].zValue = zValueFunctionFromVector3[zValueFunctionIndex](item.mModelViewMatrix.GetTranslation3()) - static_cast<float>(item.mDepthIndex);
523 // Keep the renderitem pointer in the helper so we can quickly reorder items after sort.
524 mSortingHelper[index].renderItem = &item;
527 // Here we determine which comparitor (of the 3) to use.
530 // 2 is LAYER_3D + Clipping
531 const unsigned int comparitorIndex = layer.GetBehavior() == Dali::Layer::LAYER_3D ? respectClippingOrder ? 2u : 1u : 0u;
533 std::stable_sort(mSortingHelper.begin(), mSortingHelper.end(), mSortComparitors[comparitorIndex]);
535 // Reorder / re-populate the RenderItems in the RenderList to correct order based on the sortinghelper.
536 DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "Sorted Transparent List:\n");
537 RenderItemContainer::Iterator renderListIter = renderList.GetContainer().Begin();
538 for(uint32_t index = 0; index < renderableCount; ++index, ++renderListIter)
540 *renderListIter = mSortingHelper[index].renderItem;
541 DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, mSortingHelper[index].renderItem->mRenderer);
545 void RenderInstructionProcessor::Prepare(BufferIndex updateBufferIndex,
546 SortedLayerPointers& sortedLayers,
547 RenderTask& renderTask,
549 bool hasClippingNodes,
550 RenderInstructionContainer& instructions)
552 // Retrieve the RenderInstruction buffer from the RenderInstructionContainer
553 // then populate with instructions.
554 RenderInstruction& instruction = renderTask.PrepareRenderInstruction(updateBufferIndex);
555 bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
556 bool isRenderListAdded = false;
557 bool isRootLayerDirty = false;
559 const Matrix& viewMatrix = renderTask.GetViewMatrix(updateBufferIndex);
560 const SceneGraph::Camera& camera = renderTask.GetCamera();
561 const bool isOrthographicCamera = camera.mProjectionMode == Dali::Camera::ProjectionMode::ORTHOGRAPHIC_PROJECTION;
564 bool viewportSet = renderTask.QueryViewport(updateBufferIndex, viewport);
566 const SortedLayersIter endIter = sortedLayers.end();
567 for(SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter)
569 Layer& layer = **iter;
570 const bool tryReuseRenderList(viewMatrixHasNotChanged && layer.CanReuseRenderers(&camera));
571 const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
572 RenderList* renderList = nullptr;
574 if(layer.IsRoot() && (layer.GetDirtyFlags() != NodePropertyFlags::NOTHING))
576 // 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
577 isRootLayerDirty = true;
580 if(!layer.colorRenderables.Empty())
582 RenderableContainer& renderables = layer.colorRenderables;
584 if(!SetupRenderList(renderables, layer, instruction, tryReuseRenderList, &renderList))
586 renderList->SetHasColorRenderItems(true);
587 AddRenderersToRenderList(updateBufferIndex,
597 // We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
598 SortRenderItems(updateBufferIndex, *renderList, layer, hasClippingNodes, isOrthographicCamera);
601 isRenderListAdded = true;
604 if(!layer.overlayRenderables.Empty())
606 RenderableContainer& renderables = layer.overlayRenderables;
608 if(!SetupRenderList(renderables, layer, instruction, tryReuseRenderList, &renderList))
610 renderList->SetHasColorRenderItems(false);
611 AddRenderersToRenderList(updateBufferIndex,
621 // Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor.
622 SortRenderItems(updateBufferIndex, *renderList, layer, false, isOrthographicCamera);
625 isRenderListAdded = true;
629 // Inform the render instruction that all renderers have been added and this frame is complete.
630 instruction.UpdateCompleted();
632 if(isRenderListAdded || instruction.mIsClearColorSet || isRootLayerDirty)
634 instructions.PushBack(updateBufferIndex, &instruction);
638 } // namespace SceneGraph
640 } // namespace Internal