dali/internal/render/common/render-algorithms.h

   1 #ifndef DALI_INTERNAL_RENDER_ALGORITHMS_H
   2 #define DALI_INTERNAL_RENDER_ALGORITHMS_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/integration-api/core-enumerations.h>
  23 #include <dali/internal/common/buffer-index.h>
  24 #include <dali/internal/render/common/render-list.h>
  25
  26 namespace Dali
  27 {
  28 namespace Internal
  29 {
  30 class Context;
  31
  32 namespace SceneGraph
  33 {
  34 class RenderInstruction;
  35 struct RenderItem;
  36 } // namespace SceneGraph
  37
  38 namespace Render
  39 {
  40 /**
  41  * @brief The responsibility of the RenderAlgorithms object is to action renders required by a RenderInstruction.
  42  */
  43 class RenderAlgorithms
  44 {
  45 public:
  46   /**
  47    * Constructor.
  48    *
  49    * @param[in] graphicsController The graphics controller
  50    */
  51   RenderAlgorithms(Graphics::Controller& graphicsController);
  52
  53   /**
  54    * Process a render-instruction.
  55    * @param[in] instruction            The render-instruction to process.
  56    * @param[in] context                The GL context.
  57    * @param[in] bufferIndex            The current render buffer index (previous update buffer)
  58    * @param[in] depthBufferAvailable   Whether the depth buffer is available
  59    * @param[in] stencilBufferAvailable Whether the stencil buffer is available
  60    * @param[in] boundTextures          The textures bound for rendering
  61    * @param[in] viewport               The viewport for drawing
  62    * @param[in] rootClippingRect       The clipping rectangle
  63    * @param[in] orientation            The surface orientation
  64    */
  65   void ProcessRenderInstruction(const SceneGraph::RenderInstruction& instruction,
  66                                 Context&                             context,
  67                                 BufferIndex                          bufferIndex,
  68                                 Integration::DepthBufferAvailable    depthBufferAvailable,
  69                                 Integration::StencilBufferAvailable  stencilBufferAvailable,
  70                                 Vector<Graphics::Texture*>&          boundTextures,
  71                                 const Rect<int32_t>&                 viewport,
  72                                 const Rect<int>&                     rootClippingRect,
  73                                 int                                  orientation);
  74
  75 private:
  76   /**
  77    * @brief Calculate a 2D AABB (axis aligned bounding box) in screen space.
  78    * The RenderItems dimensions are translated and a Z value of 0 is assumed for this purpose.
  79    * No projection is performed, but rotation on Z is supported.
  80    * @param[in] item The RenderItem to generate an AABB for
  81    * @return         The generated AABB in screen space
  82    */
  83   inline Dali::ClippingBox CalculateScreenSpaceAABB(const Dali::Internal::SceneGraph::RenderItem& item);
  84
  85   /**
  86    * @brief Perform any scissor clipping related operations based on the current RenderItem.
  87    * This includes:
  88    *  - Determining if any action is to be taken (so the method can be exited early if not).
  89    *  - If the node is a clipping node, apply the nodes clip intersected with the current/parent scissor clip.
  90    *  - If we have gone up the scissor hierarchy, and need to un-apply a scissor clip.
  91    *  - Disable scissor clipping completely if it is not needed
  92    * @param[in] item        The current RenderItem (about to be rendered)
  93    * @param[in] context     The current Context
  94    * @param[in] instruction The render-instruction to process.
  95    */
  96   inline void SetupScissorClipping(const Dali::Internal::SceneGraph::RenderItem& item, Context& context, const Dali::Internal::SceneGraph::RenderInstruction& instruction);
  97
  98   /**
  99    * @brief Set up the clipping based on the specified clipping settings.
 100    * @param[in]     item                     The current RenderItem (about to be rendered)
 101    * @param[in]     context                  The context
 102    * @param[in/out] usedStencilBuffer        True if the stencil buffer has been used so far within this RenderList. Used by StencilMode::ON.
 103    * @param[in/out] lastClippingDepth        The stencil depth of the last renderer drawn. Used by the clipping feature.
 104    * @param[in/out] lastClippingId           The clipping ID of the last renderer drawn.   Used by the clipping feature.
 105    * @param[in]     stencilBufferAvailable   Whether the stencil buffer is available
 106    * @param[in]     instruction              The render-instruction to process.
 107    */
 108   inline void SetupClipping(const Dali::Internal::SceneGraph::RenderItem&        item,
 109                             Context&                                             context,
 110                             bool&                                                usedStencilBuffer,
 111                             uint32_t&                                            lastClippingDepth,
 112                             uint32_t&                                            lastClippingId,
 113                             Integration::StencilBufferAvailable                  stencilBufferAvailable,
 114                             const Dali::Internal::SceneGraph::RenderInstruction& instruction);
 115
 116   /**
 117    * @brief Process a render-list.
 118    * @param[in] renderList             The render-list to process.
 119    * @param[in] context                The GL context.
 120    * @param[in] buffer                 The current render buffer index (previous update buffer)
 121    * @param[in] viewMatrix             The view matrix from the appropriate camera.
 122    * @param[in] projectionMatrix       The projection matrix from the appropriate camera.
 123    * @param[in] depthBufferAvailable   Whether the depth buffer is available
 124    * @param[in] stencilBufferAvailable Whether the stencil buffer is available
 125    * @param[in] boundTextures          The textures bound for rendering
 126    * @param[in] viewport               The Viewport
 127    * @param[in] rootClippingRect       The root clipping rectangle
 128    * @param[in] orientation            The Scene's surface orientation
 129    */
 130   inline void ProcessRenderList(const Dali::Internal::SceneGraph::RenderList&        renderList,
 131                                 Context&                                             context,
 132                                 BufferIndex                                          bufferIndex,
 133                                 const Matrix&                                        viewMatrix,
 134                                 const Matrix&                                        projectionMatrix,
 135                                 Integration::DepthBufferAvailable                    depthBufferAvailable,
 136                                 Integration::StencilBufferAvailable                  stencilBufferAvailable,
 137                                 Vector<Graphics::Texture*>&                          boundTextures,
 138                                 const Dali::Internal::SceneGraph::RenderInstruction& instruction, // in the case of reflection, things like CullFace need to be adjusted for reflection world
 139                                 const Rect<int32_t>&                                 viewport,
 140                                 const Rect<int>&                                     rootClippingRect,
 141                                 int                                                  orientation);
 142
 143   // Prevent copying:
 144   RenderAlgorithms(RenderAlgorithms& rhs);
 145   RenderAlgorithms& operator=(const RenderAlgorithms& rhs);
 146
 147   // Member variables:
 148
 149   using ScissorStackType = std::vector<Dali::ClippingBox>; ///< The container type used to maintain the applied scissor hierarchy
 150
 151   Graphics::Controller&                        mGraphicsController;
 152   Graphics::UniquePtr<Graphics::CommandBuffer> mGraphicsCommandBuffer{};
 153
 154   ScissorStackType  mScissorStack;        ///< Contains the currently applied scissor hierarchy (so we can undo clips)
 155   Dali::ClippingBox mViewportRectangle;   ///< The viewport dimensions, used to translate AABBs to scissor coordinates
 156   bool              mHasLayerScissor : 1; ///< Marks if the currently process render instruction has a layer-based clipping region
 157 };
 158
 159 } // namespace Render
 160
 161 } // namespace Internal
 162
 163 } // namespace Dali
 164
 165 #endif // DALI_INTERNAL_RENDER_ALGORITHMS_H