/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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/render/renderers/render-renderer.h>
#include <dali/internal/render/renderers/render-property-buffer.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
+#include <dali/internal/common/math.h>
namespace
{
bool cull )
{
bool inside( true );
- const Node* node = renderable.mNode;
-
- if( cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
+ Node* node = renderable.mNode;
+ bool isModifiesGeometryHint = false;
+ if( cull && renderable.mRenderer && !( isModifiesGeometryHint = renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) ) )
{
const Vector4& boundingSphere = node->GetBoundingSphere();
inside = ( boundingSphere.w > Math::MACHINE_EPSILON_1000 ) &&
item.mNode = renderable.mNode;
item.mIsOpaque = ( opacityType == Renderer::OPAQUE );
+ item.mDepthIndex = 0;
+ item.mPartialUpdateEnabled = false;
+
if( !isLayer3d )
{
item.mDepthIndex = renderable.mNode->GetDepthIndex();
}
+ if( isLayer3d || isModifiesGeometryHint )
+ {
+ renderList.SetPartialUpdateEnabled( false );
+ }
if( DALI_LIKELY( renderable.mRenderer ) )
{
item.mRenderer = &renderable.mRenderer->GetRenderer();
item.mTextureSet = renderable.mRenderer->GetTextures();
item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
+
+ if( FaceCullingMode::NONE != renderable.mRenderer->GetFaceCullingMode() )
+ {
+ renderList.SetPartialUpdateEnabled( false );
+ }
}
else
{
node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
+
+ if( DALI_LIKELY( item.mRenderer ) && renderList.IsPartialUpdateEnabled() )
+ {
+ if( node->IsPropertyDirty() || node->IsComponentChanged() )
+ {
+ item.mPartialUpdateEnabled = true;
+
+ item.mUpdateSizeHint = item.mSize;
+ Vector3 updateSizeHint = node->GetUpdateSizeHint( updateBufferIndex );
+ if( updateSizeHint != Vector3::ZERO )
+ {
+ item.mUpdateSizeHint = updateSizeHint;
+ }
+ }
+ }
}
+ node->SetCulled( updateBufferIndex, false );
+ }
+ else
+ {
+ node->SetCulled( updateBufferIndex, true );
}
}
{
DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
- unsigned int rendererCount( renderers.Size() );
- for( unsigned int i(0); i < rendererCount; ++i )
+ for( auto&& renderer : renderers )
{
AddRendererToRenderList( updateBufferIndex,
renderList,
- renderers[i],
+ renderer,
viewMatrix,
camera,
isLayer3d,
RenderableContainer& renderables )
{
bool retValue = false;
- size_t renderableCount = renderables.Size();
+ 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 ) )
// Therefore we check a combined sum of all renderer addresses.
size_t checkSumNew = 0;
size_t checkSumOld = 0;
- for( size_t index = 0; index < renderableCount; ++index )
+ for( uint32_t index = 0; index < renderableCount; ++index )
{
const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
- checkSumNew += size_t( &renderer );
- checkSumOld += size_t( &renderList.GetRenderer( index ) );
+ checkSumNew += reinterpret_cast<std::size_t>( &renderer );
+ checkSumOld += reinterpret_cast<std::size_t>( &renderList.GetRenderer( index ) );
}
if( checkSumNew == checkSumOld )
{
inline void RenderInstructionProcessor::SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder )
{
- const size_t renderableCount = renderList.Count();
+ const uint32_t renderableCount = static_cast<uint32_t>( renderList.Count() );
// Reserve space if needed.
- const unsigned int oldcapacity = mSortingHelper.size();
+ const uint32_t oldcapacity = static_cast<uint32_t>( mSortingHelper.size() );
if( oldcapacity < renderableCount )
{
mSortingHelper.reserve( renderableCount );
// Using an if and two for-loops rather than if inside for as its better for branch prediction.
if( layer.UsesDefaultSortFunction() )
{
- for( size_t index = 0; index < renderableCount; ++index )
+ for( uint32_t index = 0; index < renderableCount; ++index )
{
RenderItem& item = renderList.GetItem( index );
mSortingHelper[ index ].textureSet = item.mTextureSet;
// The default sorting function should get inlined here.
- mSortingHelper[ index ].zValue = Internal::Layer::ZValue( item.mModelViewMatrix.GetTranslation3() ) - 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;
else
{
const Dali::Layer::SortFunctionType sortFunction = layer.GetSortFunction();
- for( size_t index = 0; index < renderableCount; ++index )
+ for( uint32_t index = 0; index < renderableCount; ++index )
{
RenderItem& item = renderList.GetItem( index );
mSortingHelper[ index ].textureSet = item.mTextureSet;
- mSortingHelper[ index ].zValue = (*sortFunction)( item.mModelViewMatrix.GetTranslation3() ) - 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;
// 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");
RenderItemContainer::Iterator renderListIter = renderList.GetContainer().Begin();
- for( unsigned int 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);
renderTask.PrepareRenderInstruction( instruction, updateBufferIndex );
bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
bool isRenderListAdded = false;
+ bool isRootLayerDirty = false;
const Matrix& viewMatrix = renderTask.GetViewMatrix( updateBufferIndex );
SceneGraph::Camera& camera = renderTask.GetCamera();
const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
RenderList* renderList = NULL;
+ 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() )
{
RenderableContainer& renderables = layer.colorRenderables;
if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
{
renderList->SetHasColorRenderItems( true );
+ if( !isLayer3D )
+ {
+ renderList->SetPartialUpdateEnabled( true );
+ }
AddRenderersToRenderList( updateBufferIndex,
*renderList,
renderables,
if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
{
renderList->SetHasColorRenderItems( false );
+ if( !isLayer3D )
+ {
+ renderList->SetPartialUpdateEnabled( true );
+ }
AddRenderersToRenderList( updateBufferIndex,
*renderList,
renderables,
// Inform the render instruction that all renderers have been added and this frame is complete.
instruction.UpdateCompleted();
- if( !isRenderListAdded && !instruction.mIsClearColorSet )
+ if( !isRenderListAdded && !instruction.mIsClearColorSet && !isRootLayerDirty )
{
instructions.DiscardCurrentInstruction( updateBufferIndex );
}
projects / platform / core / uifw / dali-core.git / blobdiff