#include <dali/internal/update/manager/render-instruction-processor.h>
// INTERNAL INCLUDES
-#include <dali/public-api/shader-effects/shader-effect.h>
#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
{
/**
+ * 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
+ */
+bool PartialCompareItems( const RenderInstructionProcessor::SortAttributes& lhs,
+ const RenderInstructionProcessor::SortAttributes& rhs )
+{
+ if( lhs.shader == rhs.shader )
+ {
+ if( lhs.textureSet == rhs.textureSet )
+ {
+ return lhs.geometry < rhs.geometry;
+ }
+ return lhs.textureSet < rhs.textureSet;
+ }
+ return lhs.shader < rhs.shader;
+}
+
+/**
* Function which sorts render items by depth index then by instance
- * ptrs of shader/geometry/material.
+ * ptrs of 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
// encapsulates the same data (e.g. the middle-order bits of the ptrs).
if( lhs.renderItem->mDepthIndex == rhs.renderItem->mDepthIndex )
{
- if( lhs.shader == rhs.shader )
- {
- if( lhs.textureResourceId == rhs.textureResourceId )
- {
- return lhs.geometry < rhs.geometry;
- }
- return lhs.textureResourceId < rhs.textureResourceId;
- }
- return lhs.shader < rhs.shader;
+ return PartialCompareItems(lhs, rhs);
}
return lhs.renderItem->mDepthIndex < rhs.renderItem->mDepthIndex;
}
if( lhsIsOpaque )
{
// If both RenderItems are opaque, sort using shader, then material then geometry.
- if( lhs.shader == rhs.shader )
- {
- if( lhs.textureResourceId == rhs.textureResourceId )
- {
- return lhs.geometry < rhs.geometry;
- }
- return lhs.textureResourceId < rhs.textureResourceId;
- }
- return lhs.shader < rhs.shader;
+ 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( lhs.shader == rhs.shader )
- {
- if( lhs.textureResourceId == rhs.textureResourceId )
- {
- return lhs.geometry < rhs.geometry;
- }
- return lhs.textureResourceId < rhs.textureResourceId;
- }
- return lhs.shader < rhs.shader;
+ return PartialCompareItems( lhs, rhs );
}
return lhs.zValue > rhs.zValue;
}
bool cull )
{
bool inside( true );
- if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
+ const Node* node = renderable.mNode;
+
+ if( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
{
- const Vector4& boundingSphere = renderable.mNode->GetBoundingSphere();
- inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
- (camera.CheckSphereInFrustum( updateBufferIndex, Vector3(boundingSphere), boundingSphere.w ) );
+ const Vector4& boundingSphere = node->GetBoundingSphere();
+ inside = ( boundingSphere.w > Math::MACHINE_EPSILON_1000 ) &&
+ ( camera.CheckSphereInFrustum( updateBufferIndex, Vector3( boundingSphere ), boundingSphere.w ) );
}
- if ( inside )
+ if( inside )
{
Renderer::Opacity opacity = renderable.mRenderer->GetOpacity( updateBufferIndex, *renderable.mNode );
if( opacity != Renderer::TRANSPARENT )
RenderItem& item = renderList.GetNextFreeItem();
item.mRenderer = &renderable.mRenderer->GetRenderer();
item.mNode = renderable.mNode;
+ item.mTextureSet = renderable.mRenderer->GetTextures();
item.mIsOpaque = ( opacity == Renderer::OPAQUE );
item.mDepthIndex = renderable.mRenderer->GetDepthIndex();
if( !isLayer3d )
{
- item.mDepthIndex += static_cast<int>( renderable.mNode->GetDepth() ) * Dali::Layer::TREE_DEPTH_MULTIPLIER;
+ item.mDepthIndex += renderable.mNode->GetDepthIndex();
}
// Save ModelView matrix onto the item.
- renderable.mNode->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
+ node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
+
Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
}
}
unsigned int rendererCount( renderers.Size() );
for( unsigned int i(0); i < rendererCount; ++i )
{
- AddRendererToRenderList( updateBufferIndex, renderList, renderers[i], viewMatrix, camera, isLayer3d, cull );
+ AddRendererToRenderList( updateBufferIndex,
+ renderList,
+ renderers[i],
+ viewMatrix,
+ camera,
+ isLayer3d,
+ cull );
}
}
item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
+ // texture set
+ mSortingHelper[ index ].textureSet = item.mTextureSet;
+
// The default sorting function should get inlined here.
mSortingHelper[ index ].zValue = Internal::Layer::ZValue( item.mModelViewMatrix.GetTranslation3() ) - item.mDepthIndex;
RenderItem& item = renderList.GetItem( index );
item.mRenderer->SetSortAttributes( bufferIndex, mSortingHelper[ index ] );
+
+ // texture set
+ mSortingHelper[ index ].textureSet = item.mTextureSet;
+
+
mSortingHelper[ index ].zValue = (*sortFunction)( item.mModelViewMatrix.GetTranslation3() ) - item.mDepthIndex;
// Keep the RenderItem pointer in the helper so we can quickly reorder items after sort.
if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
{
renderList->SetHasColorRenderItems( true );
- AddRenderersToRenderList( updateBufferIndex, *renderList, renderables, viewMatrix, camera, isLayer3D, cull );
+ AddRenderersToRenderList( updateBufferIndex,
+ *renderList,
+ renderables,
+ viewMatrix,
+ camera,
+ isLayer3D,
+ cull );
// We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
SortRenderItems( updateBufferIndex, *renderList, layer, hasClippingNodes );
if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
{
renderList->SetHasColorRenderItems( false );
- AddRenderersToRenderList( updateBufferIndex, *renderList, renderables, viewMatrix, camera, isLayer3D, cull );
+ AddRenderersToRenderList( updateBufferIndex,
+ *renderList,
+ renderables,
+ viewMatrix,
+ camera,
+ isLayer3D,
+ 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 );
projects / platform / core / uifw / dali-core.git / blobdiff