2 * Copyright (c) 2020 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-task-processor.h>
22 #include <dali/internal/update/manager/sorted-layers.h>
23 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
24 #include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
25 #include <dali/internal/update/nodes/scene-graph-layer.h>
26 #include <dali/internal/render/common/render-item.h>
27 #include <dali/internal/render/common/render-tracker.h>
28 #include <dali/internal/render/common/render-instruction.h>
29 #include <dali/internal/render/common/render-instruction-container.h>
30 #include <dali/internal/render/renderers/render-renderer.h>
31 #include <dali/integration-api/debug.h>
33 #if defined(DEBUG_ENABLED)
34 extern Debug::Filter* gRenderTaskLogFilter;
46 namespace //Unnamed namespace
49 // Return false if the node or it's parents are exclusive to another render-task.
50 bool CheckExclusivity( const Node& node, const RenderTask& task )
52 const RenderTask* exclusiveTo = node.GetExclusiveRenderTask();
55 return ( exclusiveTo == &task );
58 const Node* parent = node.GetParent();
61 return CheckExclusivity( *parent, task );
64 // No exclusive flags set.
68 Layer* FindLayer( Node& node )
70 Node* currentNode( &node );
74 if( ( layer = currentNode->GetLayer() ) != NULL )
79 currentNode = currentNode->GetParent();
86 * Rebuild the Layer::colorRenderables and overlayRenderables members,
87 * including only renderers which are included in the current render-task.
89 * @param[in] updateBufferIndex The current update buffer index.
90 * @param[in] node The current node of the scene-graph.
91 * @param[in] currentLayer The current layer containing lists of opaque/transparent renderables.
92 * @param[in] renderTask The current render-task.
93 * @param[in] inheritedDrawMode The draw mode of the parent
94 * @param[in] parentDepthIndex The inherited parent node depth index
95 * @param[in] currentClippingId The current Clipping Id
96 * Note: ClippingId is passed by reference, so it is permanently modified when traversing back up the tree for uniqueness.
97 * @param[in] clippingDepth The current stencil clipping depth
98 * @param[in] clippingDepth The current scissor clipping depth
99 * @param[out] clippingUsed Gets set to true if any clipping nodes have been found
100 * @return true if rendering should be kept, false otherwise.
102 bool AddRenderablesForTask( BufferIndex updateBufferIndex,
105 RenderTask& renderTask,
106 int inheritedDrawMode,
107 uint32_t& currentClippingId,
108 uint32_t clippingDepth,
109 uint32_t scissorDepth,
112 bool keepRendering = false;
114 // Short-circuit for invisible nodes
115 if( !node.IsVisible( updateBufferIndex ) )
117 return keepRendering;
120 // Check whether node is exclusive to a different render-task
121 const RenderTask* exclusiveTo = node.GetExclusiveRenderTask();
122 if( exclusiveTo && ( exclusiveTo != &renderTask ) )
124 return keepRendering;
127 // Assume all children go to this layer (if this node is a layer).
128 Layer* layer = node.GetLayer();
131 // Layers do not inherit the DrawMode from their parents
132 inheritedDrawMode = node.GetDrawMode();
136 // This node is not a layer.
137 layer = ¤tLayer;
138 inheritedDrawMode |= node.GetDrawMode();
141 DALI_ASSERT_DEBUG( NULL != layer );
143 const uint32_t count = node.GetRendererCount();
145 // Update the clipping Id and depth for this node (if clipping is enabled).
146 const Dali::ClippingMode::Type clippingMode = node.GetClippingMode();
147 if( DALI_UNLIKELY( clippingMode != ClippingMode::DISABLED ) )
149 if( DALI_LIKELY( clippingMode == ClippingMode::CLIP_TO_BOUNDING_BOX ) )
151 ++scissorDepth; // This only modifies the local value (which is passed in when the method recurses).
152 // If we do not have any renderers, create one to house the scissor operation.
155 layer->colorRenderables.PushBack( Renderable( &node, nullptr ) );
160 // We only need clipping Id for stencil clips. This means we can deliberately avoid modifying it for bounding box clips,
161 // thus allowing bounding box clipping to still detect clip depth changes without turning on the stencil buffer for non-clipped nodes.
162 ++currentClippingId; // This modifies the reference passed in as well as the local value, causing the value to be global to the recursion.
163 ++clippingDepth; // This only modifies the local value (which is passed in when the method recurses).
167 // Set the information in the node.
168 node.SetClippingInformation( currentClippingId, clippingDepth, scissorDepth );
170 for( uint32_t i = 0; i < count; ++i )
172 SceneGraph::Renderer* renderer = node.GetRendererAt( i );
174 // Normal is the more-likely draw mode to occur.
175 if( DALI_LIKELY( inheritedDrawMode == DrawMode::NORMAL ) )
177 layer->colorRenderables.PushBack( Renderable( &node, renderer ) );
181 layer->overlayRenderables.PushBack( Renderable( &node, renderer ) );
184 if( renderer->GetRenderingBehavior() == DevelRenderer::Rendering::CONTINUOUSLY )
186 keepRendering = true;
191 NodeContainer& children = node.GetChildren();
192 const NodeIter endIter = children.End();
193 for( NodeIter iter = children.Begin(); iter != endIter; ++iter )
195 Node& child = **iter;
196 keepRendering |= AddRenderablesForTask( updateBufferIndex, child, *layer, renderTask, inheritedDrawMode, currentClippingId, clippingDepth, scissorDepth, clippingUsed );
199 return keepRendering;
203 * Process the list of render-tasks; the output is a series of render instructions.
204 * @note When ProcessRenderTasks is called, the layers should already the transparent/opaque renderers which are ready to render.
205 * If there is only one default render-task, then no further processing is required.
206 * @param[in] updateBufferIndex The current update buffer index.
207 * @param[in] taskContainer The container of render-tasks.
208 * @param[in] rootNode The root node of the scene-graph.
209 * @param[in] sortedLayers The layers containing lists of opaque / transparent renderables.
210 * @param[out] instructions The instructions for rendering the next frame.
211 * @param[in] renderInstructionProcessor An instance of the RenderInstructionProcessor used to sort and handle the renderers for each layer.
212 * @param[in] renderToFboEnabled Whether rendering into the Frame Buffer Object is enabled (used to measure FPS above 60)
213 * @param[in] isRenderingToFbo Whether this frame is being rendered into the Frame Buffer Object (used to measure FPS above 60)
214 * @param[in] processOffscreen Whether the offscreen render tasks are the ones processed. Otherwise it processes the onscreen tasks.
215 * @return true if rendering should be kept, false otherwise.
217 bool ProcessTasks( BufferIndex updateBufferIndex,
218 RenderTaskList::RenderTaskContainer& taskContainer,
220 SortedLayerPointers& sortedLayers,
221 RenderInstructionContainer& instructions,
222 RenderInstructionProcessor& renderInstructionProcessor,
223 bool renderToFboEnabled,
224 bool isRenderingToFbo,
225 bool processOffscreen )
227 uint32_t clippingId = 0u;
228 bool hasClippingNodes = false;
230 bool isFirstRenderTask = true;
231 bool keepRendering = false;
232 for( RenderTaskList::RenderTaskContainer::Iterator iter = taskContainer.Begin(), endIter = taskContainer.End(); endIter != iter; ++iter )
234 RenderTask& renderTask = **iter;
236 const bool hasFrameBuffer = NULL != renderTask.GetFrameBuffer();
237 const bool isDefaultRenderTask = isFirstRenderTask;
238 isFirstRenderTask = false;
240 if( ( !renderToFboEnabled && ( ( !processOffscreen && hasFrameBuffer ) ||
241 ( processOffscreen && !hasFrameBuffer ) ) ) ||
242 ( renderToFboEnabled && ( ( processOffscreen && !hasFrameBuffer ) ||
243 ( isDefaultRenderTask && processOffscreen ) ||
244 ( !isDefaultRenderTask && !processOffscreen && hasFrameBuffer ) ) ) ||
245 !renderTask.ReadyToRender( updateBufferIndex ) )
247 // Skip to next task.
251 Node* sourceNode = renderTask.GetSourceNode();
252 DALI_ASSERT_DEBUG( NULL != sourceNode ); // Otherwise Prepare() should return false
254 // Check that the source node is not exclusive to another task.
255 if( !CheckExclusivity( *sourceNode, renderTask ) )
260 Layer* layer = FindLayer( *sourceNode );
263 // Skip to next task as no layer.
267 const uint32_t currentNumberOfInstructions = instructions.Count( updateBufferIndex );
269 if( renderTask.IsRenderRequired() )
271 for( auto&& sortedLayer : sortedLayers )
273 sortedLayer->ClearRenderables();
276 keepRendering |= AddRenderablesForTask( updateBufferIndex,
280 sourceNode->GetDrawMode(),
286 renderInstructionProcessor.Prepare( updateBufferIndex,
289 renderTask.GetCullMode(),
294 if( !processOffscreen && isDefaultRenderTask && renderToFboEnabled && !isRenderingToFbo && hasFrameBuffer )
296 // Traverse the instructions of the default render task and mark them to be rendered into the frame buffer.
297 const uint32_t count = instructions.Count( updateBufferIndex );
298 for( uint32_t index = currentNumberOfInstructions; index < count; ++index )
300 RenderInstruction& instruction = instructions.At( updateBufferIndex, index );
301 instruction.mIgnoreRenderToFbo = true;
306 return keepRendering;
309 } // Anonymous namespace.
311 RenderTaskProcessor::RenderTaskProcessor()
315 RenderTaskProcessor::~RenderTaskProcessor()
319 bool RenderTaskProcessor::Process( BufferIndex updateBufferIndex,
320 RenderTaskList& renderTasks,
322 SortedLayerPointers& sortedLayers,
323 RenderInstructionContainer& instructions,
324 bool renderToFboEnabled,
325 bool isRenderingToFbo )
327 RenderTaskList::RenderTaskContainer& taskContainer = renderTasks.GetTasks();
328 bool keepRendering = false;
330 if( taskContainer.IsEmpty() )
332 // Early-exit if there are no tasks to process
333 return keepRendering;
336 // For each render-task:
337 // 1) Prepare the render-task
338 // 2) Clear the layer-stored lists of renderers (TODO check if the layer is not changed and don't clear in this case)
339 // 3) Traverse the scene-graph, filling the lists for the current render-task
340 // 4) Prepare render-instructions
342 DALI_LOG_INFO( gRenderTaskLogFilter, Debug::General, "RenderTaskProcessor::Process() Offscreens first\n" );
344 // First process off screen render tasks - we may need the results of these for the on screen renders
346 keepRendering = ProcessTasks( updateBufferIndex,
351 mRenderInstructionProcessor,
356 DALI_LOG_INFO( gRenderTaskLogFilter, Debug::General, "RenderTaskProcessor::Process() Onscreen\n" );
358 // Now that the off screen renders are done we can process on screen render tasks.
359 // Reset the clipping Id for the OnScreen render tasks.
361 keepRendering |= ProcessTasks( updateBufferIndex,
366 mRenderInstructionProcessor,
371 return keepRendering;