/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/update/manager/render-instruction-processor.h>
// INTERNAL INCLUDES
-#include <dali/public-api/actors/layer.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/event/actors/layer-impl.h> // for the default sorting function
-#include <dali/internal/update/manager/sorted-layers.h>
-#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
-#include <dali/internal/update/rendering/scene-graph-texture-set.h>
+#include <dali/internal/render/common/render-instruction-container.h>
+#include <dali/internal/render/common/render-instruction.h>
#include <dali/internal/render/common/render-item.h>
#include <dali/internal/render/common/render-tracker.h>
-#include <dali/internal/render/common/render-instruction.h>
-#include <dali/internal/render/common/render-instruction-container.h>
-#include <dali/internal/render/shaders/scene-graph-shader.h>
#include <dali/internal/render/renderers/render-renderer.h>
-#include <dali/internal/render/renderers/render-property-buffer.h>
+#include <dali/internal/render/shaders/render-shader.h>
+#include <dali/internal/update/manager/sorted-layers.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
+#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
+#include <dali/internal/update/rendering/scene-graph-texture-set.h>
+#include <dali/public-api/actors/layer.h>
namespace
{
#if defined(DEBUG_ENABLED)
Debug::Filter* gRenderListLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RENDER_LISTS");
#endif
-}
+} // namespace
namespace Dali
{
-
namespace Internal
{
-
namespace SceneGraph
{
-
namespace
{
-
/**
* Function which compares render items by shader/textureSet/geometry
* @param[in] lhs Left hand side item
* @param[in] rhs Right hand side item
* @return True if left item is greater than right
*/
-inline bool PartialCompareItems( const RenderInstructionProcessor::SortAttributes& lhs,
- const RenderInstructionProcessor::SortAttributes& rhs )
+inline bool PartialCompareItems(const RenderInstructionProcessor::SortAttributes& lhs,
+ const RenderInstructionProcessor::SortAttributes& rhs)
{
- if( lhs.shader == rhs.shader )
+ if(lhs.shader == rhs.shader)
{
- if( lhs.textureSet == rhs.textureSet )
+ if(lhs.textureSet == rhs.textureSet)
{
return lhs.geometry < rhs.geometry;
}
* @param[in] rhs Right hand side item
* @return True if left item is greater than right
*/
-bool CompareItems( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
+bool CompareItems(const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs)
{
// @todo Consider replacing all these sortAttributes with a single long int that
// encapsulates the same data (e.g. the middle-order bits of the ptrs).
- if( lhs.renderItem->mDepthIndex == rhs.renderItem->mDepthIndex )
+ if(lhs.renderItem->mDepthIndex == rhs.renderItem->mDepthIndex)
{
- return PartialCompareItems( lhs, rhs );
+ return PartialCompareItems(lhs, rhs);
}
return lhs.renderItem->mDepthIndex < rhs.renderItem->mDepthIndex;
}
* @param[in] rhs Right hand side item
* @return True if left item is greater than right
*/
-bool CompareItems3D( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
+bool CompareItems3D(const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs)
{
const bool lhsIsOpaque = lhs.renderItem->mIsOpaque;
- if( lhsIsOpaque == rhs.renderItem->mIsOpaque )
+ if(lhsIsOpaque == rhs.renderItem->mIsOpaque)
{
- if( lhsIsOpaque )
+ if(lhsIsOpaque)
{
// If both RenderItems are opaque, sort using shader, then material then geometry.
- return PartialCompareItems( lhs, rhs );
+ return PartialCompareItems(lhs, rhs);
}
else
{
// If both RenderItems are transparent, sort using Z, then shader, then material, then geometry.
- if( Equals( lhs.zValue, rhs.zValue ) )
+ if(Equals(lhs.zValue, rhs.zValue))
{
- return PartialCompareItems( lhs, rhs );
+ return PartialCompareItems(lhs, rhs);
}
return lhs.zValue > rhs.zValue;
}
* @param[in] rhs Right hand side item
* @return True if left item is greater than right
*/
-bool CompareItems3DWithClipping( const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs )
+bool CompareItems3DWithClipping(const RenderInstructionProcessor::SortAttributes& lhs, const RenderInstructionProcessor::SortAttributes& rhs)
{
// Items must be sorted in order of clipping first, otherwise incorrect clipping regions could be used.
- if( lhs.renderItem->mNode->mClippingSortModifier == rhs.renderItem->mNode->mClippingSortModifier )
+ if(lhs.renderItem->mNode->mClippingSortModifier == rhs.renderItem->mNode->mClippingSortModifier)
{
- return CompareItems3D( lhs, rhs );
+ return CompareItems3D(lhs, rhs);
}
return lhs.renderItem->mNode->mClippingSortModifier < rhs.renderItem->mNode->mClippingSortModifier;
}
/**
+ * Set the update size of the node
+ * @param[in] node The node of the renderer
+ * @param[in] isLayer3d Whether we are processing a 3D layer or not
+ * @param[in,out] nodeWorldMatrix The world matrix of the node
+ * @param[in,out] nodeSize The size of the node
+ * @param[in,out] nodeUpdateSize The update size of the node
+ */
+inline void SetNodeUpdateSize(Node* node, bool isLayer3d, Matrix& nodeWorldMatrix, Vector3& nodeSize, Vector3& nodeUpdateSize)
+{
+ node->GetWorldMatrixAndSize(nodeWorldMatrix, nodeSize);
+
+ if(node->GetUpdateSizeHint() == Vector3::ZERO)
+ {
+ // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform
+ // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be too slow
+ if(!isLayer3d && nodeWorldMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f))
+ {
+ nodeUpdateSize = nodeSize;
+ }
+ }
+ else
+ {
+ nodeUpdateSize = node->GetUpdateSizeHint();
+ }
+}
+
+/**
* Add a renderer to the list
* @param updateBufferIndex to read the model matrix from
* @param renderList to add the item to
* @param viewMatrix used to calculate modelview matrix for the item
* @param camera The camera used to render
* @param isLayer3d Whether we are processing a 3D layer or not
+ * @param viewportSet Whether the viewport is set or not
+ * @param viewport The viewport
* @param cull Whether frustum culling is enabled or not
*/
-inline void AddRendererToRenderList(BufferIndex updateBufferIndex,
- RenderList& renderList,
- Renderable& renderable,
- const Matrix& viewMatrix,
+inline void AddRendererToRenderList(BufferIndex updateBufferIndex,
+ RenderList& renderList,
+ Renderable& renderable,
+ const Matrix& viewMatrix,
SceneGraph::Camera& camera,
- bool isLayer3d,
- bool cull)
+ bool isLayer3d,
+ bool viewportSet,
+ const Viewport& viewport,
+ bool cull)
{
- bool inside(true);
- Node* node = renderable.mNode;
-
- if (cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY))
+ bool inside(true);
+ Node* node = renderable.mNode;
+ Matrix nodeWorldMatrix(false);
+ Vector3 nodeSize;
+ Vector3 nodeUpdateSize;
+ bool nodeUpdateSizeSet(false);
+ Matrix nodeModelViewMatrix(false);
+ bool nodeModelViewMatrixSet(false);
+
+ if(cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY) && node->GetClippingMode() == ClippingMode::DISABLED)
{
const Vector4& boundingSphere = node->GetBoundingSphere();
- inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
+ inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
(camera.CheckSphereInFrustum(updateBufferIndex, Vector3(boundingSphere), boundingSphere.w));
+
+ if(inside && !isLayer3d && viewportSet)
+ {
+ SetNodeUpdateSize(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateSize);
+ nodeUpdateSizeSet = true;
+
+ const Vector3& scale = node->GetWorldScale(updateBufferIndex);
+ const Vector3& halfSize = nodeUpdateSize * scale * 0.5f;
+ float radius(halfSize.Length());
+
+ if(radius > Math::MACHINE_EPSILON_1000)
+ {
+ Matrix::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
+ nodeModelViewMatrixSet = true;
+
+ ClippingBox clippingBox = RenderItem::CalculateViewportSpaceAABB(nodeModelViewMatrix, nodeUpdateSize, viewport.width, viewport.height);
+ inside = clippingBox.Intersects(viewport);
+ }
+ }
}
- if (inside)
+ if(inside)
{
- Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType( updateBufferIndex, *renderable.mNode ) : Renderer::OPAQUE;
- if (opacityType != Renderer::TRANSPARENT || node->GetClippingMode() == ClippingMode::CLIP_CHILDREN)
+ Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType(updateBufferIndex, *node) : Renderer::OPAQUE;
+
+ // We can skip render when node is not clipping and transparent
+ const bool skipRender(opacityType == Renderer::TRANSPARENT && node->GetClippingMode() == ClippingMode::DISABLED);
+ if(!skipRender)
{
// Get the next free RenderItem.
RenderItem& item = renderList.GetNextFreeItem();
- item.mIsUpdated = (item.mNode != renderable.mNode);
- item.mNode = renderable.mNode;
+ // Get cached values
+ auto& partialRenderingData = node->GetPartialRenderingData();
- bool prevIsOpaque = item.mIsOpaque;
- item.mIsOpaque = (opacityType == Renderer::OPAQUE);
- item.mIsUpdated |= (prevIsOpaque != item.mIsOpaque);
+ auto& partialRenderingCacheInfo = node->GetPartialRenderingData().GetCurrentCacheInfo();
- Vector4 prevColor = item.mColor;
- item.mColor = renderable.mNode->GetColor(updateBufferIndex);
- item.mIsUpdated |= (prevColor != item.mColor);
+ partialRenderingCacheInfo.node = node;
+ partialRenderingCacheInfo.isOpaque = (opacityType == Renderer::OPAQUE);
+ partialRenderingCacheInfo.renderer = renderable.mRenderer;
+ partialRenderingCacheInfo.color = node->GetColor(updateBufferIndex);
+ partialRenderingCacheInfo.depthIndex = node->GetDepthIndex();
+
+ if(DALI_LIKELY(renderable.mRenderer))
+ {
+ partialRenderingCacheInfo.textureSet = renderable.mRenderer->GetTextureSet();
+ }
+
+ item.mNode = node;
+ item.mIsOpaque = (opacityType == Renderer::OPAQUE);
+ item.mColor = node->GetColor(updateBufferIndex);
- int prevDepthIndex = item.mDepthIndex;
item.mDepthIndex = 0;
- if (!isLayer3d)
+ if(!isLayer3d)
{
- item.mDepthIndex = renderable.mNode->GetDepthIndex();
+ item.mDepthIndex = node->GetDepthIndex();
}
- Render::Renderer* prevRenderer = item.mRenderer;
- if (DALI_LIKELY(renderable.mRenderer))
+ if(DALI_LIKELY(renderable.mRenderer))
{
- item.mRenderer = &renderable.mRenderer->GetRenderer();
- const void* prevTextureSet = item.mTextureSet;
- item.mTextureSet = renderable.mRenderer->GetTextures();
- item.mIsUpdated |= (prevTextureSet != item.mTextureSet);
+ item.mRenderer = &renderable.mRenderer->GetRenderer();
+ item.mTextureSet = renderable.mRenderer->GetTextureSet();
item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
}
else
item.mRenderer = nullptr;
}
- item.mIsUpdated |= (prevDepthIndex != item.mDepthIndex);
- item.mIsUpdated |= (prevRenderer != item.mRenderer);
item.mIsUpdated |= isLayer3d;
- if (!item.mIsUpdated)
+ if(!nodeUpdateSizeSet)
{
- Matrix prevModelViewMatrix = item.mModelViewMatrix;
- Vector3 prevSize = item.mSize;
+ SetNodeUpdateSize(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateSize);
+ }
- // Save ModelView matrix onto the item.
- node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
- Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
+ item.mSize = nodeSize;
+ item.mUpdateSize = nodeUpdateSize;
+ item.mModelMatrix = nodeWorldMatrix;
- item.mIsUpdated = ((prevSize != item.mSize) || (item.mModelViewMatrix != prevModelViewMatrix));
- }
- else
+ if(!nodeModelViewMatrixSet)
{
- // Save ModelView matrix onto the item.
- node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
- Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
+ Matrix::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
}
+ item.mModelViewMatrix = nodeModelViewMatrix;
- item.mUpdateSize = node->GetUpdateSizeHint();
- if (item.mUpdateSize == Vector3::ZERO)
- {
- // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform
- // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be to slow
- if (!isLayer3d && item.mModelMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f))
- {
- item.mUpdateSize = item.mSize;
- }
- }
+ partialRenderingCacheInfo.matrix = item.mModelViewMatrix;
+ partialRenderingCacheInfo.size = item.mSize;
+ partialRenderingCacheInfo.updatedSize = item.mUpdateSize;
+
+ item.mIsUpdated = partialRenderingData.IsUpdated() || item.mIsUpdated;
+ partialRenderingData.SwapBuffers();
+ }
+ else
+ {
+ // Mark as invisible
+ auto& partialRenderingData = node->GetPartialRenderingData();
+ partialRenderingData.mVisible = false;
}
- node->SetCulled( updateBufferIndex, false );
+ node->SetCulled(updateBufferIndex, false);
}
else
{
- node->SetCulled( updateBufferIndex, true );
+ node->SetCulled(updateBufferIndex, true);
}
}
* @param isLayer3d Whether we are processing a 3D layer or not
* @param cull Whether frustum culling is enabled or not
*/
-inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
- RenderList& renderList,
- RenderableContainer& renderers,
- const Matrix& viewMatrix,
- SceneGraph::Camera& camera,
- bool isLayer3d,
- bool cull )
+inline void AddRenderersToRenderList(BufferIndex updateBufferIndex,
+ RenderList& renderList,
+ RenderableContainer& renderers,
+ const Matrix& viewMatrix,
+ SceneGraph::Camera& camera,
+ bool isLayer3d,
+ bool viewportSet,
+ const Viewport& viewport,
+ bool cull)
{
- DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
+ DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
- for( auto&& renderer : renderers )
+ for(auto&& renderer : renderers)
{
- AddRendererToRenderList( updateBufferIndex,
- renderList,
- renderer,
- viewMatrix,
- camera,
- isLayer3d,
- cull);
+ AddRendererToRenderList(updateBufferIndex,
+ renderList,
+ renderer,
+ viewMatrix,
+ camera,
+ isLayer3d,
+ viewportSet,
+ viewport,
+ cull);
}
}
* @param renderList that is cached from frame N-1
* @param renderables list of renderables
*/
-inline bool TryReuseCachedRenderers( Layer& layer,
- RenderList& renderList,
- RenderableContainer& renderables )
+inline bool TryReuseCachedRenderers(Layer& layer,
+ RenderList& renderList,
+ RenderableContainer& renderables)
{
- bool retValue = false;
- uint32_t renderableCount = static_cast<uint32_t>( renderables.Size() );
+ bool retValue = false;
+ uint32_t renderableCount = static_cast<uint32_t>(renderables.Size());
// Check that the cached list originates from this layer and that the counts match
- if( ( renderList.GetSourceLayer() == &layer )&&
- ( renderList.GetCachedItemCount() == renderableCount ) )
+ if((renderList.GetSourceLayer() == &layer) &&
+ (renderList.GetCachedItemCount() == renderableCount))
{
// Check that all the same renderers are there. This gives us additional security in avoiding rendering the wrong things.
// Render list is sorted so at this stage renderers may be in different order.
// Therefore we check a combined sum of all renderer addresses.
size_t checkSumNew = 0;
size_t checkSumOld = 0;
- for( uint32_t index = 0; index < renderableCount; ++index )
+ for(uint32_t index = 0; index < renderableCount; ++index)
{
- const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
- checkSumNew += reinterpret_cast<std::size_t>( &renderer );
- checkSumOld += reinterpret_cast<std::size_t>( &renderList.GetRenderer( index ) );
+ if(DALI_LIKELY(renderables[index].mRenderer))
+ {
+ const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
+ checkSumNew += reinterpret_cast<std::size_t>(&renderer);
+ }
+ if(DALI_LIKELY(renderList.GetItem(index).mRenderer))
+ {
+ checkSumOld += reinterpret_cast<std::size_t>(&renderList.GetRenderer(index));
+ }
}
- if( checkSumNew == checkSumOld )
+ if(checkSumNew == checkSumOld)
{
// tell list to reuse its existing items
renderList.ReuseCachedItems();
return retValue;
}
-inline bool SetupRenderList( RenderableContainer& renderables,
- Layer& layer,
- RenderInstruction& instruction,
- bool tryReuseRenderList,
- RenderList** renderList )
+inline bool SetupRenderList(RenderableContainer& renderables,
+ Layer& layer,
+ RenderInstruction& instruction,
+ bool tryReuseRenderList,
+ RenderList** renderList)
{
- *renderList = &( instruction.GetNextFreeRenderList( renderables.Size() ) );
- ( *renderList )->SetClipping( layer.IsClipping(), layer.GetClippingBox() );
- ( *renderList )->SetSourceLayer( &layer );
+ *renderList = &(instruction.GetNextFreeRenderList(renderables.Size()));
+ (*renderList)->SetClipping(layer.IsClipping(), layer.GetClippingBox());
+ (*renderList)->SetSourceLayer(&layer);
// Try to reuse cached RenderItems from last time around.
- return ( tryReuseRenderList && TryReuseCachedRenderers( layer, **renderList, renderables ) );
+ return (tryReuseRenderList && TryReuseCachedRenderers(layer, **renderList, renderables));
}
} // Anonymous namespace.
-
RenderInstructionProcessor::RenderInstructionProcessor()
: mSortingHelper()
{
// Set up a container of comparators for fast run-time selection.
- mSortComparitors.Reserve( 3u );
+ mSortComparitors.Reserve(3u);
- mSortComparitors.PushBack( CompareItems );
- mSortComparitors.PushBack( CompareItems3D );
- mSortComparitors.PushBack( CompareItems3DWithClipping );
+ mSortComparitors.PushBack(CompareItems);
+ mSortComparitors.PushBack(CompareItems3D);
+ mSortComparitors.PushBack(CompareItems3DWithClipping);
}
-RenderInstructionProcessor::~RenderInstructionProcessor()
-{
-}
+RenderInstructionProcessor::~RenderInstructionProcessor() = default;
-inline void RenderInstructionProcessor::SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder )
+inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder)
{
- const uint32_t renderableCount = static_cast<uint32_t>( renderList.Count() );
+ const uint32_t renderableCount = static_cast<uint32_t>(renderList.Count());
// Reserve space if needed.
- const uint32_t oldcapacity = static_cast<uint32_t>( mSortingHelper.size() );
- if( oldcapacity < renderableCount )
+ const uint32_t oldcapacity = static_cast<uint32_t>(mSortingHelper.size());
+ if(oldcapacity < renderableCount)
{
- mSortingHelper.reserve( renderableCount );
+ mSortingHelper.reserve(renderableCount);
// Add real objects (reserve does not construct objects).
- mSortingHelper.insert( mSortingHelper.begin() + oldcapacity,
+ mSortingHelper.insert(mSortingHelper.begin() + oldcapacity,
(renderableCount - oldcapacity),
- RenderInstructionProcessor::SortAttributes() );
+ RenderInstructionProcessor::SortAttributes());
}
else
{
// Clear extra elements from helper, does not decrease capability.
- mSortingHelper.resize( renderableCount );
+ mSortingHelper.resize(renderableCount);
}
// Calculate the sorting value, once per item by calling the layers sort function.
// Using an if and two for-loops rather than if inside for as its better for branch prediction.
- if( layer.UsesDefaultSortFunction() )
+ if(layer.UsesDefaultSortFunction())
{
- for( uint32_t index = 0; index < renderableCount; ++index )
+ for(uint32_t index = 0; index < renderableCount; ++index)
{
- RenderItem& item = renderList.GetItem( index );
+ RenderItem& item = renderList.GetItem(index);
- if( item.mRenderer )
+ if(DALI_LIKELY(item.mRenderer))
{
- item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
+ item.mRenderer->SetSortAttributes(mSortingHelper[index]);
}
// texture set
- mSortingHelper[ index ].textureSet = item.mTextureSet;
+ mSortingHelper[index].textureSet = item.mTextureSet;
// The default sorting function should get inlined here.
- mSortingHelper[ index ].zValue = Internal::Layer::ZValue( item.mModelViewMatrix.GetTranslation3() ) - static_cast<float>( item.mDepthIndex );
+ mSortingHelper[index].zValue = Internal::Layer::ZValue(item.mModelViewMatrix.GetTranslation3()) - static_cast<float>(item.mDepthIndex);
// Keep the renderitem pointer in the helper so we can quickly reorder items after sort.
- mSortingHelper[ index ].renderItem = &item;
+ mSortingHelper[index].renderItem = &item;
}
}
else
{
const Dali::Layer::SortFunctionType sortFunction = layer.GetSortFunction();
- for( uint32_t index = 0; index < renderableCount; ++index )
+ for(uint32_t index = 0; index < renderableCount; ++index)
{
- RenderItem& item = renderList.GetItem( index );
+ RenderItem& item = renderList.GetItem(index);
- item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
+ if(DALI_LIKELY(item.mRenderer))
+ {
+ item.mRenderer->SetSortAttributes(mSortingHelper[index]);
+ }
// texture set
- mSortingHelper[ index ].textureSet = item.mTextureSet;
+ mSortingHelper[index].textureSet = item.mTextureSet;
-
- mSortingHelper[ index ].zValue = (*sortFunction)( item.mModelViewMatrix.GetTranslation3() ) - static_cast<float>( item.mDepthIndex );
+ mSortingHelper[index].zValue = (*sortFunction)(item.mModelViewMatrix.GetTranslation3()) - static_cast<float>(item.mDepthIndex);
// Keep the RenderItem pointer in the helper so we can quickly reorder items after sort.
- mSortingHelper[ index ].renderItem = &item;
+ mSortingHelper[index].renderItem = &item;
}
}
// 2 is LAYER_3D + Clipping
const unsigned int comparitorIndex = layer.GetBehavior() == Dali::Layer::LAYER_3D ? respectClippingOrder ? 2u : 1u : 0u;
- std::stable_sort( mSortingHelper.begin(), mSortingHelper.end(), mSortComparitors[ comparitorIndex ] );
+ std::stable_sort(mSortingHelper.begin(), mSortingHelper.end(), mSortComparitors[comparitorIndex]);
// Reorder / re-populate the RenderItems in the RenderList to correct order based on the sortinghelper.
- DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "Sorted Transparent List:\n");
+ DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "Sorted Transparent List:\n");
RenderItemContainer::Iterator renderListIter = renderList.GetContainer().Begin();
- for( uint32_t index = 0; index < renderableCount; ++index, ++renderListIter )
+ for(uint32_t index = 0; index < renderableCount; ++index, ++renderListIter)
{
- *renderListIter = mSortingHelper[ index ].renderItem;
- DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, mSortingHelper[ index ].renderItem->mRenderer);
+ *renderListIter = mSortingHelper[index].renderItem;
+ DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, mSortingHelper[index].renderItem->mRenderer);
}
}
-void RenderInstructionProcessor::Prepare( BufferIndex updateBufferIndex,
- SortedLayerPointers& sortedLayers,
- RenderTask& renderTask,
- bool cull,
- bool hasClippingNodes,
- RenderInstructionContainer& instructions )
+void RenderInstructionProcessor::Prepare(BufferIndex updateBufferIndex,
+ SortedLayerPointers& sortedLayers,
+ RenderTask& renderTask,
+ bool cull,
+ bool hasClippingNodes,
+ RenderInstructionContainer& instructions)
{
// Retrieve the RenderInstruction buffer from the RenderInstructionContainer
// then populate with instructions.
- RenderInstruction& instruction = renderTask.PrepareRenderInstruction( updateBufferIndex );
- bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
- bool isRenderListAdded = false;
- bool isRootLayerDirty = false;
+ RenderInstruction& instruction = renderTask.PrepareRenderInstruction(updateBufferIndex);
+ bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
+ bool isRenderListAdded = false;
+ bool isRootLayerDirty = false;
+
+ const Matrix& viewMatrix = renderTask.GetViewMatrix(updateBufferIndex);
+ SceneGraph::Camera& camera = renderTask.GetCamera();
- const Matrix& viewMatrix = renderTask.GetViewMatrix( updateBufferIndex );
- SceneGraph::Camera& camera = renderTask.GetCamera();
+ Viewport viewport;
+ bool viewportSet = renderTask.QueryViewport(updateBufferIndex, viewport);
const SortedLayersIter endIter = sortedLayers.end();
- for( SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter )
+ for(SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter)
{
- Layer& layer = **iter;
- const bool tryReuseRenderList( viewMatrixHasNotChanged && layer.CanReuseRenderers( &renderTask.GetCamera() ) );
- const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
- RenderList* renderList = NULL;
+ Layer& layer = **iter;
+ const bool tryReuseRenderList(viewMatrixHasNotChanged && layer.CanReuseRenderers(&renderTask.GetCamera()));
+ const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
+ RenderList* renderList = nullptr;
- if( layer.IsRoot() && ( layer.GetDirtyFlags() != NodePropertyFlags::NOTHING ) )
+ if(layer.IsRoot() && (layer.GetDirtyFlags() != NodePropertyFlags::NOTHING))
{
// 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
isRootLayerDirty = true;
}
- if( !layer.colorRenderables.Empty() )
+ if(!layer.colorRenderables.Empty())
{
RenderableContainer& renderables = layer.colorRenderables;
- if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
+ if(!SetupRenderList(renderables, layer, instruction, tryReuseRenderList, &renderList))
{
- renderList->SetHasColorRenderItems( true );
- AddRenderersToRenderList( updateBufferIndex,
- *renderList,
- renderables,
- viewMatrix,
- camera,
- isLayer3D,
- cull );
+ renderList->SetHasColorRenderItems(true);
+ AddRenderersToRenderList(updateBufferIndex,
+ *renderList,
+ renderables,
+ viewMatrix,
+ camera,
+ isLayer3D,
+ viewportSet,
+ viewport,
+ cull);
// We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
- SortRenderItems( updateBufferIndex, *renderList, layer, hasClippingNodes );
+ SortRenderItems(updateBufferIndex, *renderList, layer, hasClippingNodes);
}
isRenderListAdded = true;
}
- if( !layer.overlayRenderables.Empty() )
+ if(!layer.overlayRenderables.Empty())
{
RenderableContainer& renderables = layer.overlayRenderables;
- if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
+ if(!SetupRenderList(renderables, layer, instruction, tryReuseRenderList, &renderList))
{
- renderList->SetHasColorRenderItems( false );
- AddRenderersToRenderList( updateBufferIndex,
- *renderList,
- renderables,
- viewMatrix,
- camera,
- isLayer3D,
- cull );
+ renderList->SetHasColorRenderItems(false);
+ AddRenderersToRenderList(updateBufferIndex,
+ *renderList,
+ renderables,
+ viewMatrix,
+ camera,
+ isLayer3D,
+ viewportSet,
+ viewport,
+ cull);
// Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor.
- SortRenderItems( updateBufferIndex, *renderList, layer, false );
+ SortRenderItems(updateBufferIndex, *renderList, layer, false);
}
isRenderListAdded = true;
// Inform the render instruction that all renderers have been added and this frame is complete.
instruction.UpdateCompleted();
- if( isRenderListAdded || instruction.mIsClearColorSet || isRootLayerDirty )
+ if(isRenderListAdded || instruction.mIsClearColorSet || isRootLayerDirty)
{
- instructions.PushBack( updateBufferIndex, &instruction );
+ instructions.PushBack(updateBufferIndex, &instruction);
}
}
-} // SceneGraph
+} // namespace SceneGraph
-} // Internal
+} // namespace Internal
-} // Dali
+} // namespace Dali
projects / platform / core / uifw / dali-core.git / blobdiff