2 * Copyright (c) 2017 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/render/common/render-algorithms.h>
22 #include <dali/internal/render/common/render-debug.h>
23 #include <dali/internal/render/common/render-list.h>
24 #include <dali/internal/render/common/render-instruction.h>
25 #include <dali/internal/render/gl-resources/context.h>
26 #include <dali/internal/render/renderers/render-renderer.h>
27 #include <dali/internal/update/nodes/scene-graph-layer.h>
29 using Dali::Internal::SceneGraph::RenderItem;
30 using Dali::Internal::SceneGraph::RenderList;
31 using Dali::Internal::SceneGraph::RenderListContainer;
32 using Dali::Internal::SceneGraph::RenderInstruction;
46 // Table for fast look-up of Dali::DepthFunction enum to a GL depth function.
47 // Note: These MUST be in the same order as Dali::DepthFunction enum.
48 const int DaliDepthToGLDepthTable[] = { GL_NEVER, GL_ALWAYS, GL_LESS, GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_LEQUAL, GL_GEQUAL };
50 // Table for fast look-up of Dali::StencilFunction enum to a GL stencil function.
51 // Note: These MUST be in the same order as Dali::StencilFunction enum.
52 const int DaliStencilFunctionToGL[] = { GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS };
54 // Table for fast look-up of Dali::StencilOperation enum to a GL stencil operation.
55 // Note: These MUST be in the same order as Dali::StencilOperation enum.
56 const int DaliStencilOperationToGL[] = { GL_ZERO, GL_KEEP, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP };
59 * @brief Find the intersection of two AABB rectangles.
60 * This is a logical AND operation. IE. The intersection is the area overlapped by both rectangles.
61 * @param[in] aabbA Rectangle A
62 * @param[in] aabbB Rectangle B
63 * @return The intersection of rectangle A & B (result is a rectangle)
65 inline ClippingBox IntersectAABB( const ClippingBox& aabbA, const ClippingBox& aabbB )
67 ClippingBox intersectionBox;
69 // First calculate the largest starting positions in X and Y.
70 intersectionBox.x = std::max( aabbA.x, aabbB.x );
71 intersectionBox.y = std::max( aabbA.y, aabbB.y );
73 // Now calculate the smallest ending positions, and take the largest starting
74 // positions from the result, to get the width and height respectively.
75 // If the two boxes do not intersect at all, then we need a 0 width and height clipping area.
76 // We use max here to clamp both width and height to >= 0 for this use-case.
77 intersectionBox.width = std::max( std::min( aabbA.x + aabbA.width, aabbB.x + aabbB.width ) - intersectionBox.x, 0 );
78 intersectionBox.height = std::max( std::min( aabbA.y + aabbA.height, aabbB.y + aabbB.height ) - intersectionBox.y, 0 );
80 return intersectionBox;
84 * @brief Set up the stencil and color buffer for automatic clipping (StencilMode::AUTO).
85 * @param[in] item The current RenderItem about to be rendered
86 * @param[in] context The context
87 * @param[in/out] lastClippingDepth The stencil depth of the last renderer drawn.
88 * @param[in/out] lastClippingId The clipping ID of the last renderer drawn.
90 inline void SetupStencilClipping( const RenderItem& item, Context& context, uint32_t& lastClippingDepth, uint32_t& lastClippingId )
92 const Dali::Internal::SceneGraph::Node* node = item.mNode;
93 const uint32_t clippingId = node->GetClippingId();
94 // If there is no clipping Id, then either we haven't reached a clipping Node yet, or there aren't any.
95 // Either way we can skip clipping setup for this renderer.
96 if( clippingId == 0u )
98 // Exit immediately if there are no clipping actions to perform (EG. we have not yet hit a clipping node).
99 context.EnableStencilBuffer( false );
103 context.EnableStencilBuffer( true );
105 const uint32_t clippingDepth = node->GetClippingDepth();
107 // Pre-calculate a mask which has all bits set up to and including the current clipping depth.
108 // EG. If depth is 3, the mask would be "111" in binary.
109 const uint32_t currentDepthMask = ( 1u << clippingDepth ) - 1u;
111 // Are we are writing to the stencil buffer?
112 if( item.mNode->GetClippingMode() == Dali::ClippingMode::CLIP_CHILDREN )
114 // We are writing to the stencil buffer.
115 // If clipping Id is 1, this is the first clipping renderer within this render-list.
116 if( clippingId == 1u )
118 // We are enabling the stencil-buffer for the first time within this render list.
119 // Clear the buffer at this point.
120 context.StencilMask( 0xff );
121 context.Clear( GL_STENCIL_BUFFER_BIT, Context::CHECK_CACHED_VALUES );
123 else if( ( clippingDepth < lastClippingDepth ) ||
124 ( ( clippingDepth == lastClippingDepth ) && ( clippingId > lastClippingId ) ) )
126 // The above if() statement tests if we need to clear some (not all) stencil bit-planes.
127 // We need to do this if either of the following are true:
128 // 1) We traverse up the scene-graph to a previous stencil depth
129 // 2) We are at the same stencil depth but the clipping Id has increased.
131 // This calculation takes the new depth to move to, and creates an inverse-mask of that number of consecutive bits.
132 // This has the effect of clearing everything except the bit-planes up to (and including) our current depth.
133 const uint32_t stencilClearMask = ( currentDepthMask >> 1u ) ^ 0xff;
135 context.StencilMask( stencilClearMask );
136 context.Clear( GL_STENCIL_BUFFER_BIT, Context::CHECK_CACHED_VALUES );
139 // We keep track of the last clipping Id and depth so we can determine when we are
140 // moving back up the scene graph and require some of the stencil bit-planes to be deleted.
141 lastClippingDepth = clippingDepth;
142 lastClippingId = clippingId;
144 // We only ever write to bit-planes up to the current depth as we may need
145 // to erase individual bit-planes and revert to a previous clipping area.
146 // Our reference value for testing (in StencilFunc) is written to to the buffer, but we actually
147 // want to test a different value. IE. All the bit-planes up to but not including the current depth.
148 // So we use the Mask parameter of StencilFunc to mask off the top bit-plane when testing.
149 // Here we create our test mask to innore the top bit of the reference test value.
150 // As the mask is made up of contiguous "1" values, we can do this quickly with a bit-shift.
151 const uint32_t testMask = currentDepthMask >> 1u;
153 context.StencilFunc( GL_EQUAL, currentDepthMask, testMask ); // Test against existing stencil bit-planes. All must match up to (but not including) this depth.
154 context.StencilMask( currentDepthMask ); // Write to the new stencil bit-plane (the other previous bit-planes are also written to).
155 context.StencilOp( GL_KEEP, GL_REPLACE, GL_REPLACE );
159 // We are reading from the stencil buffer. Set up the stencil accordingly
160 // This calculation sets all the bits up to the current depth bit.
161 // This has the effect of testing that the pixel being written to exists in every bit-plane up to the current depth.
162 context.StencilFunc( GL_EQUAL, currentDepthMask, 0xff );
163 context.StencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
168 * @brief Sets up the depth buffer for reading and writing based on the current render item.
169 * The items read and write mode are used if specified.
170 * - If AUTO is selected for reading, the decision will be based on the Layer Behavior.
171 * - If AUTO is selected for writing, the decision will be based on the items opacity.
172 * @param[in] item The RenderItem to set up the depth buffer for.
173 * @param[in] context The context used to execute GL commands.
174 * @param[in] depthTestEnabled True if depth testing has been enabled.
175 * @param[in/out] firstDepthBufferUse Initialize to true on the first call, this method will set it to false afterwards.
177 inline void SetupDepthBuffer( const RenderItem& item, Context& context, bool depthTestEnabled, bool& firstDepthBufferUse )
179 // Set up whether or not to write to the depth buffer.
180 const DepthWriteMode::Type depthWriteMode = item.mRenderer->GetDepthWriteMode();
181 // Most common mode (AUTO) is tested first.
182 const bool enableDepthWrite = ( ( depthWriteMode == DepthWriteMode::AUTO ) && depthTestEnabled && item.mIsOpaque ) ||
183 ( depthWriteMode == DepthWriteMode::ON );
185 // Set up whether or not to read from (test) the depth buffer.
186 const DepthTestMode::Type depthTestMode = item.mRenderer->GetDepthTestMode();
187 // Most common mode (AUTO) is tested first.
188 const bool enableDepthTest = ( ( depthTestMode == DepthTestMode::AUTO ) && depthTestEnabled ) ||
189 ( depthTestMode == DepthTestMode::ON );
191 // Is the depth buffer in use?
192 if( enableDepthWrite || enableDepthTest )
194 // The depth buffer must be enabled if either reading or writing.
195 context.EnableDepthBuffer( true );
197 // Set up the depth mask based on our depth write setting.
198 context.DepthMask( enableDepthWrite );
200 // Look-up the GL depth function from the Dali::DepthFunction enum, and set it.
201 context.DepthFunc( DaliDepthToGLDepthTable[ item.mRenderer->GetDepthFunction() ] );
203 // If this is the first use of the depth buffer this RenderTask, perform a clear.
204 // Note: We could do this at the beginning of the RenderTask and rely on the
205 // context cache to ignore the clear if not required, but, we would have to enable
206 // the depth buffer to do so, which could be a redundant enable.
207 if( DALI_UNLIKELY( firstDepthBufferUse ) )
209 // This is the first time the depth buffer is being written to or read.
210 firstDepthBufferUse = false;
212 // Note: The buffer will only be cleared if written to since a previous clear.
213 context.Clear( GL_DEPTH_BUFFER_BIT, Context::CHECK_CACHED_VALUES );
218 // The depth buffer is not being used by this renderer, so we must disable it to stop it being tested.
219 context.EnableDepthBuffer( false );
223 } // Unnamed namespace
226 inline ClippingBox RenderAlgorithms::CalculateScreenSpaceAABB( const SceneGraph::RenderItem& item )
228 // Calculate extent vector of the AABB:
229 const Vector3& actorSize = item.mSize;
230 const float halfActorX = actorSize.x * 0.5f;
231 const float halfActorY = actorSize.y * 0.5f;
233 // Transform to absolute oriented bounding box.
234 const Matrix& worldMatrix = item.mModelViewMatrix;
236 // To transform the actor bounds to screen-space, We do a fast, 2D version of a matrix multiply optimized for 2D quads.
237 // This reduces float multiplications from 64 (16 * 4) to 12 (4 * 3).
238 // We create an array of 4 corners and directly initialize the first 3 with the matrix multiplication result of the respective corner.
239 // This causes the construction of the vector arrays contents in-place for optimization.
240 // We skip the 4th corner here as we can calculate that from the other 3, bypassing matrix multiplication.
241 // Note: The below * operators trigger a fast (2D) matrix multiply (only 4 multiplications are done).
242 Vector2 corners[4]{ worldMatrix * Vector2( -halfActorX, -halfActorY ),
243 worldMatrix * Vector2( halfActorX, -halfActorY ),
244 worldMatrix * Vector2( halfActorX, halfActorY ) };
246 // As we are dealing with a rectangle, we can do a fast calculation to get the 4th corner from knowing the other 3 (even if rotated).
247 corners[3] = Vector2( corners[0] + ( corners[2] - corners[1] ) );
249 // Calculate the AABB:
250 // We use knowledge that opposite corners will be the max/min of each other. Doing this reduces the normal 12 branching comparisons to 3.
251 // The standard equivalent min/max code of the below would be:
252 // Vector2 AABBmax( std::max( corners[0].x, std::max( corners[1].x, std::max( corners[3].x, corners[2].x ) ) ),
253 // std::max( corners[0].y, std::max( corners[1].y, std::max( corners[3].y, corners[2].y ) ) ) );
254 // Vector2 AABBmin( std::min( corners[0].x, std::min( corners[1].x, std::min( corners[3].x, corners[2].x ) ) ),
255 // std::min( corners[0].y, std::min( corners[1].y, std::min( corners[3].y, corners[2].y ) ) ) );
256 unsigned int smallestX = 0u;
257 // Loop 3 times to find the index of the smallest X value.
258 // Note: We deliberately do NOT unroll the code here as this hampers the compilers output.
259 for( unsigned int i = 1u; i < 4u; ++i )
261 if( corners[i].x < corners[smallestX].x )
267 // As we are dealing with a rectangle, we can assume opposite corners are the largest.
268 // So without doing min/max branching, we can fetch the min/max values of all the remaining X/Y coords from this one index.
269 Vector4 aabb( corners[smallestX].x, corners[( smallestX + 3u ) % 4].y, corners[( smallestX + 2u ) % 4].x, corners[( smallestX + 1u ) % 4].y );
271 // Convert maximums to extents.
275 // Return the AABB in screen-space pixels (x, y, width, height).
276 // Note: This is a algebraic simplification of: ( viewport.x - aabb.width ) / 2 - ( ( aabb.width / 2 ) + aabb.x ) per axis.
277 return ClippingBox( ( mViewportRectangle.width / 2 ) - aabb.z - aabb.x, ( mViewportRectangle.height / 2 ) - aabb.w - aabb.y, aabb.z, aabb.w );
280 inline void RenderAlgorithms::SetupScissorClipping( const RenderItem& item, Context& context )
282 // Get the number of child scissors in the stack (do not include layer or root box).
283 size_t childStackDepth = mScissorStack.size() - 1u;
284 const uint32_t scissorDepth = item.mNode->GetScissorDepth();
285 const bool clippingNode = item.mNode->GetClippingMode() == Dali::ClippingMode::CLIP_TO_BOUNDING_BOX;
286 bool traversedUpTree = false;
288 // If we are using scissor clipping and we are at the same depth (or less), we need to undo previous clips.
289 // We do this by traversing up the scissor clip stack and then apply the appropriate clip for the current render item.
290 // To know this, we use clippingDepth. This value is set on *every* node, but only increased as clipping nodes are hit depth-wise.
291 // So we know if we are at depth 4 and the stackDepth is 5, that we have gone up.
292 // If the depth is the same then we are effectively part of a different sub-tree from the parent, we must also remove the current clip.
293 // Note: Stack depth must always be at least 1, as we will have the layer or stage size as the root value.
294 if( ( childStackDepth > 0u ) && ( scissorDepth < childStackDepth ) )
296 while( scissorDepth < childStackDepth )
298 mScissorStack.pop_back();
302 // We traversed up the tree, we need to apply a new scissor rectangle (unless we are at the root).
303 traversedUpTree = true;
306 // If we are on a clipping node, or we have traveled up the tree and gone back past a clipping node, may need to apply a new scissor clip.
307 if( clippingNode || traversedUpTree )
309 // First, check if we are a clipping node.
312 // This is a clipping node. We generate the AABB for this node and intersect it with the previous intersection further up the tree.
314 // Get the AABB bounding box for the current render item.
315 const ClippingBox scissorBox( CalculateScreenSpaceAABB( item ) );
316 // Get the AABB for the parent item that we must intersect with.
317 const ClippingBox& parentBox( mScissorStack.back() );
319 // We must reduce the clipping area based on the parents area to allow nested clips. This is a set intersection function.
320 // We add the new scissor box to the stack so we can return to it if needed.
321 mScissorStack.emplace_back( IntersectAABB( parentBox, scissorBox ) );
324 // The scissor test is enabled if we have any children on the stack, OR, if there are none but it is a user specified layer scissor box.
325 // IE. It is not enabled if we are at the top of the stack and the layer does not have a specified clipping box.
326 const bool scissorEnabled = ( mScissorStack.size() > 0u ) || mHasLayerScissor;
328 // Enable the scissor test based on the above calculation
329 context.SetScissorTest( scissorEnabled );
331 // If scissor is enabled, we use the calculated screen-space coordinates (now in the stack).
334 ClippingBox useScissorBox( mScissorStack.back() );
335 context.Scissor( useScissorBox.x, useScissorBox.y, useScissorBox.width, useScissorBox.height );
340 inline void RenderAlgorithms::SetupClipping( const RenderItem& item, Context& context, bool& usedStencilBuffer, uint32_t& lastClippingDepth, uint32_t& lastClippingId )
342 const Renderer *renderer = item.mRenderer;
344 // Setup the stencil using either the automatic clipping feature, or, the manual per-renderer stencil API.
345 // Note: This switch is in order of most likely value first.
346 RenderMode::Type renderMode = renderer->GetRenderMode();
349 case RenderMode::AUTO:
351 // Turn the color buffer on as we always want to render this renderer, regardless of clipping hierarchy.
352 context.ColorMask( true );
354 // The automatic clipping feature will manage the scissor and stencil functions.
355 // As both scissor and stencil clips can be nested, we may be simultaneously traversing up the scissor tree, requiring a scissor to be un-done. Whilst simultaneously adding a new stencil clip.
356 // We process both based on our current and old clipping depths for each mode.
357 // Both methods with return rapidly if there is nothing to be done for that type of clipping.
358 SetupScissorClipping( item, context );
359 SetupStencilClipping( item, context, lastClippingDepth, lastClippingId );
363 case RenderMode::NONE:
364 case RenderMode::COLOR:
366 // No clipping is performed for these modes.
367 // Note: We do not turn off scissor clipping as it may be used for the whole layer.
368 // The stencil buffer will not be used at all.
369 context.EnableStencilBuffer( false );
371 // Setup the color buffer based on the RenderMode.
372 context.ColorMask( renderMode == RenderMode::COLOR );
376 case RenderMode::STENCIL:
377 case RenderMode::COLOR_STENCIL:
379 // We are using the low-level Renderer Stencil API.
380 // The stencil buffer must be enabled for every renderer with stencil mode on, as renderers in between can disable it.
381 // Note: As the command state is cached, it is only sent when needed.
382 context.EnableStencilBuffer( true );
384 // Setup the color buffer based on the RenderMode.
385 context.ColorMask( renderMode == RenderMode::COLOR_STENCIL );
387 // If this is the first use of the stencil buffer within this RenderList, clear it (this avoids unnecessary clears).
388 if( !usedStencilBuffer )
390 context.Clear( GL_STENCIL_BUFFER_BIT, Context::CHECK_CACHED_VALUES );
391 usedStencilBuffer = true;
394 // Setup the stencil buffer based on the renderers properties.
395 context.StencilFunc( DaliStencilFunctionToGL[ renderer->GetStencilFunction() ],
396 renderer->GetStencilFunctionReference(),
397 renderer->GetStencilFunctionMask() );
398 context.StencilOp( DaliStencilOperationToGL[ renderer->GetStencilOperationOnFail() ],
399 DaliStencilOperationToGL[ renderer->GetStencilOperationOnZFail() ],
400 DaliStencilOperationToGL[ renderer->GetStencilOperationOnZPass() ] );
401 context.StencilMask( renderer->GetStencilMask() );
407 inline void RenderAlgorithms::ProcessRenderList(
408 const RenderList& renderList,
410 BufferIndex bufferIndex,
411 const Matrix& viewMatrix,
412 const Matrix& projectionMatrix )
414 DALI_PRINT_RENDER_LIST( renderList );
416 // Note: The depth buffer is enabled or disabled on a per-renderer basis.
417 // Here we pre-calculate the value to use if these modes are set to AUTO.
418 const bool autoDepthTestMode( !( renderList.GetSourceLayer()->IsDepthTestDisabled() ) && renderList.HasColorRenderItems() );
419 const std::size_t count = renderList.Count();
420 uint32_t lastClippingDepth( 0u );
421 uint32_t lastClippingId( 0u );
422 bool usedStencilBuffer( false );
423 bool firstDepthBufferUse( true );
424 mViewportRectangle = context.GetViewport();
425 mHasLayerScissor = false;
427 // Setup Scissor testing (for both viewport and per-node scissor)
428 mScissorStack.clear();
429 if( renderList.IsClipping() )
431 context.SetScissorTest( true );
432 const ClippingBox& layerScissorBox = renderList.GetClippingBox();
433 context.Scissor( layerScissorBox.x, layerScissorBox.y, layerScissorBox.width, layerScissorBox.height );
434 mScissorStack.push_back( layerScissorBox );
435 mHasLayerScissor = true;
439 // We are not performing a layer clip. Add the viewport as the root scissor rectangle.
440 context.SetScissorTest( false );
441 mScissorStack.push_back( mViewportRectangle );
444 for( size_t index( 0u ); index < count; ++index )
446 const RenderItem& item = renderList.GetItem( index );
447 DALI_PRINT_RENDER_ITEM( item );
449 // Set up the depth buffer based on per-renderer flags.
450 // If the per renderer flags are set to "ON" or "OFF", they will always override any Layer depth mode or
451 // draw-mode state, such as Overlays.
452 // If the flags are set to "AUTO", the behavior then depends on the type of renderer. Overlay Renderers will always
453 // disable depth testing and writing. Color Renderers will enable them if the Layer does.
454 SetupDepthBuffer( item, context, autoDepthTestMode, firstDepthBufferUse );
456 // Set up clipping based on both the Renderer and Actor APIs.
457 // The Renderer API will be used if specified. If AUTO, the Actors automatic clipping feature will be used.
458 SetupClipping( item, context, usedStencilBuffer, lastClippingDepth, lastClippingId );
460 // Render the item (we skip rendering for bounding box clips).
461 if( item.mNode->GetClippingMode() != ClippingMode::CLIP_TO_BOUNDING_BOX )
463 item.mRenderer->Render( context, bufferIndex, *item.mNode, item.mModelMatrix, item.mModelViewMatrix,
464 viewMatrix, projectionMatrix, item.mSize, !item.mIsOpaque );
469 RenderAlgorithms::RenderAlgorithms()
470 : mViewportRectangle(),
471 mHasLayerScissor( false )
475 void RenderAlgorithms::ProcessRenderInstruction( const RenderInstruction& instruction, Context& context, BufferIndex bufferIndex )
477 DALI_PRINT_RENDER_INSTRUCTION( instruction, bufferIndex );
479 const Matrix* viewMatrix = instruction.GetViewMatrix( bufferIndex );
480 const Matrix* projectionMatrix = instruction.GetProjectionMatrix( bufferIndex );
482 DALI_ASSERT_DEBUG( viewMatrix );
483 DALI_ASSERT_DEBUG( projectionMatrix );
485 if( viewMatrix && projectionMatrix )
487 const RenderListContainer::SizeType count = instruction.RenderListCount();
489 // Iterate through each render list in order. If a pair of render lists
490 // are marked as interleaved, then process them together.
491 for( RenderListContainer::SizeType index = 0; index < count; ++index )
493 const RenderList* renderList = instruction.GetRenderList( index );
495 if( renderList && !renderList->IsEmpty() )
497 ProcessRenderList( *renderList, context, bufferIndex, *viewMatrix, *projectionMatrix );
504 } // namespace Render
506 } // namespace Internal