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) 2019 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
  29 namespace Internal
  30 {
  31 class Context;
  32
  33 namespace SceneGraph
  34 {
  35 class RenderInstruction;
  36 struct RenderItem;
  37 }
  38
  39 namespace Render
  40 {
  41
  42 /**
  43  * @brief The responsibility of the RenderAlgorithms object is to action renders required by a RenderInstruction.
  44  */
  45 class RenderAlgorithms
  46 {
  47   public:
  48
  49     /**
  50      * Constructor.
  51      */
  52     RenderAlgorithms();
  53
  54     /**
  55      * Process a render-instruction.
  56      * @param[in] instruction            The render-instruction to process.
  57      * @param[in] context                The GL context.
  58      * @param[in] bufferIndex            The current render buffer index (previous update buffer)
  59      * @param[in] depthBufferAvailable   Whether the depth buffer is available
  60      * @param[in] stencilBufferAvailable Whether the stencil buffer is available
  61      * @param[in] boundTextures          The textures bound for rendering
  62      */
  63     void ProcessRenderInstruction( const SceneGraph::RenderInstruction& instruction,
  64                                    Context& context,
  65                                    BufferIndex bufferIndex,
  66                                    Integration::DepthBufferAvailable depthBufferAvailable,
  67                                    Integration::StencilBufferAvailable stencilBufferAvailable,
  68                                    Vector<GLuint>& boundTextures,
  69                                    const Rect<int>& rootClippingRect,
  70                                    int orientation);
  71
  72   private:
  73
  74     /**
  75      * @brief Calculate a 2D AABB (axis aligned bounding box) in screen space.
  76      * The RenderItems dimensions are translated and a Z value of 0 is assumed for this purpose.
  77      * No projection is performed, but rotation on Z is supported.
  78      * @param[in] item The RenderItem to generate an AABB for
  79      * @return         The generated AABB in screen space
  80      */
  81     inline Dali::ClippingBox CalculateScreenSpaceAABB( const Dali::Internal::SceneGraph::RenderItem& item );
  82
  83     /**
  84      * @brief Perform any scissor clipping related operations based on the current RenderItem.
  85      * This includes:
  86      *  - Determining if any action is to be taken (so the method can be exited early if not).
  87      *  - If the node is a clipping node, apply the nodes clip intersected with the current/parent scissor clip.
  88      *  - If we have gone up the scissor hierarchy, and need to un-apply a scissor clip.
  89      *  - Disable scissor clipping completely if it is not needed
  90      * @param[in] item     The current RenderItem (about to be rendered)
  91      * @param[in] context  The current Context
  92      */
  93     inline void SetupScissorClipping( const Dali::Internal::SceneGraph::RenderItem& item, Context& context, int orientation );
  94
  95     /**
  96      * @brief Set up the clipping based on the specified clipping settings.
  97      * @param[in]     item                     The current RenderItem (about to be rendered)
  98      * @param[in]     context                  The context
  99      * @param[in/out] usedStencilBuffer        True if the stencil buffer has been used so far within this RenderList. Used by StencilMode::ON.
 100      * @param[in/out] lastClippingDepth        The stencil depth of the last renderer drawn. Used by the clipping feature.
 101      * @param[in/out] lastClippingId           The clipping ID of the last renderer drawn.   Used by the clipping feature.
 102      * @param[in]     stencilBufferAvailable   Whether the stencil buffer is available
 103      */
 104     inline void SetupClipping( const Dali::Internal::SceneGraph::RenderItem& item,
 105                                Context& context,
 106                                bool& usedStencilBuffer,
 107                                uint32_t& lastClippingDepth,
 108                                uint32_t& lastClippingId,
 109                                Integration::StencilBufferAvailable stencilBufferAvailable,
 110                                int orientation );
 111
 112     /**
 113      * @brief Process a render-list.
 114      * @param[in] renderList             The render-list to process.
 115      * @param[in] context                The GL context.
 116      * @param[in] buffer                 The current render buffer index (previous update buffer)
 117      * @param[in] viewMatrix             The view matrix from the appropriate camera.
 118      * @param[in] projectionMatrix       The projection matrix from the appropriate camera.
 119      * @param[in] depthBufferAvailable   Whether the depth buffer is available
 120      * @param[in] stencilBufferAvailable Whether the stencil buffer is available
 121      * @param[in] boundTextures          The textures bound for rendering
 122      */
 123     inline void ProcessRenderList( const Dali::Internal::SceneGraph::RenderList& renderList,
 124                                    Context& context,
 125                                    BufferIndex bufferIndex,
 126                                    const Matrix& viewMatrix,
 127                                    const Matrix& projectionMatrix,
 128                                    Integration::DepthBufferAvailable depthBufferAvailable,
 129                                    Integration::StencilBufferAvailable stencilBufferAvailable,
 130                                    Vector<GLuint>& boundTextures,
 131                                    const Dali::Internal::SceneGraph::RenderInstruction& instruction, // in the case of reflection, things like CullFace need to be adjusted for reflection world
 132                                    const Rect<int>& rootClippingRect,
 133                                    int orientation );
 134
 135     // Prevent copying:
 136     RenderAlgorithms( RenderAlgorithms& rhs );
 137     RenderAlgorithms& operator=( const RenderAlgorithms& rhs );
 138
 139
 140     // Member variables:
 141
 142     using ScissorStackType = std::vector<Dali::ClippingBox>;      ///< The container type used to maintain the applied scissor hierarchy
 143
 144     ScissorStackType                        mScissorStack;        ///< Contains the currently applied scissor hierarchy (so we can undo clips)
 145     Dali::ClippingBox                       mViewportRectangle;   ///< The viewport dimensions, used to translate AABBs to scissor coordinates
 146     bool                                    mHasLayerScissor:1;   ///< Marks if the currently process render instruction has a layer-based clipping region
 147 };
 148
 149 } // namespace Render
 150
 151 } // namespace Internal
 152
 153 } // namespace Dali
 154
 155 #endif // DALI_INTERNAL_RENDER_ALGORITHMS_H