#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/update/manager/geometry-batcher.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
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
+ */
+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;
}
* @param renderable Node-Renderer pair
* @param viewMatrix used to calculate modelview matrix for the item
* @param camera The camera used to render
- * @param geometryBatcher The instance of the geometry batcher
* @param isLayer3d Whether we are processing a 3D layer or not
* @param cull Whether frustum culling is enabled or not
*/
Renderable& renderable,
const Matrix& viewMatrix,
SceneGraph::Camera& camera,
- GeometryBatcher& geometryBatcher,
bool isLayer3d,
bool cull )
{
- // Discard renderable early if it belongs to the batch which has been consumed in during frame.
- Node* renderableNode = renderable.mNode;
- const bool batchingValid( renderable.mRenderer->IsBatchingEnabled() && renderableNode->mBatchIndex != BATCH_NULL_HANDLE );
- if( batchingValid && geometryBatcher.HasRendered( renderableNode->mBatchIndex ) )
- {
- return;
- }
-
bool inside( true );
- const Node* batchParentNode = renderable.mNode->GetBatchParent();
- const Node* node = ( renderable.mRenderer->IsBatchingEnabled() && batchParentNode ) ?
- batchParentNode : renderableNode;
+ const Node* node = renderable.mNode;
if( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
{
if( inside )
{
- if( batchingValid )
- {
- geometryBatcher.SetRendered( renderableNode->mBatchIndex );
- }
-
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();
* NodeRendererContainer Node-Renderer pairs
* @param viewMatrix used to calculate modelview matrix for the items
* @param camera The camera used to render
- * @param geometryBatcher The instance of the geometry batcher
* @param isLayer3d Whether we are processing a 3D layer or not
* @param cull Whether frustum culling is enabled or not
*/
RenderableContainer& renderers,
const Matrix& viewMatrix,
SceneGraph::Camera& camera,
- GeometryBatcher* geometryBatcher,
bool isLayer3d,
bool cull )
{
unsigned int rendererCount( renderers.Size() );
for( unsigned int i(0); i < rendererCount; ++i )
{
- AddRendererToRenderList( updateBufferIndex, renderList, renderers[i], viewMatrix, camera, *geometryBatcher, 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.
SortedLayerPointers& sortedLayers,
RenderTask& renderTask,
bool cull,
- GeometryBatcher& geometryBatcher,
bool hasClippingNodes,
RenderInstructionContainer& instructions )
{
if( !SetupRenderList( renderables, layer, instruction, tryReuseRenderList, &renderList ) )
{
renderList->SetHasColorRenderItems( true );
- AddRenderersToRenderList( updateBufferIndex, *renderList, renderables, viewMatrix, camera, &geometryBatcher, 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, NULL, 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