dali/internal/event/rendering/renderer-impl.h

   1 #ifndef DALI_INTERNAL_RENDERER_H
   2 #define DALI_INTERNAL_RENDERER_H
   3
   4 /*
   5  * Copyright (c) 2020 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/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
  23 #include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
  24 #include <dali/public-api/rendering/renderer.h> // Dali::Renderer
  25 #include <dali/devel-api/rendering/renderer-devel.h>
  26 #include <dali/internal/common/blending-options.h>
  27 #include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
  28 #include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
  29 #include <dali/internal/event/rendering/texture-set-impl.h> // Dali::Internal::TextureSet
  30 #include <dali/internal/event/rendering/geometry-impl.h> // Dali::Internal::Geometry
  31 #include <dali/internal/render/renderers/render-renderer.h> // Dali::Render::Renderer::StencilParameters
  32
  33 namespace Dali
  34 {
  35 namespace Internal
  36 {
  37 namespace SceneGraph
  38 {
  39 class Renderer;
  40 }
  41
  42 class Renderer;
  43 using RendererPtr = IntrusivePtr<Renderer>;
  44
  45 /**
  46  * Renderer is an object that can be used to show content by combining a Geometry with a shader and textures.
  47  */
  48 class Renderer : public Object
  49 {
  50 public:
  51
  52   /**
  53    * Create a new Renderer.
  54    * @return A smart-pointer to the newly allocated Renderer.
  55    */
  56   static RendererPtr New();
  57
  58   /**
  59    * @copydoc Dali::Renderer::SetGeometry()
  60    */
  61   void SetGeometry( Geometry& geometry );
  62
  63   /**
  64    * @copydoc Dali::Renderer::GetGeometry()
  65    */
  66   GeometryPtr GetGeometry() const;
  67
  68   /**
  69    * @copydoc Dali::Renderer::SetTextures()
  70    */
  71   void SetTextures( TextureSet& textureSet );
  72
  73   /**
  74    * @copydoc Dali::Renderer::GetTextures()
  75    */
  76   TextureSetPtr GetTextures() const;
  77
  78   /**
  79    * @copydoc Dali::Renderer::SetShader()
  80    */
  81   void SetShader( Shader& shader );
  82
  83   /**
  84    * @copydoc Dali::Renderer::GetShader()
  85    */
  86   ShaderPtr GetShader() const;
  87
  88   /**
  89    * @copydoc Dali::Renderer::SetDepthIndex()
  90    */
  91   void SetDepthIndex( int32_t depthIndex );
  92
  93   /**
  94    * @copydoc Dali::Renderer::GetDepthIndex()
  95    */
  96   int32_t GetDepthIndex() const;
  97
  98   /**
  99    * @copydoc Dali::Renderer::SetBlendMode()
 100    */
 101   void SetBlendMode( BlendMode::Type mode );
 102
 103   /**
 104    * @copydoc Dali::Renderer::GetBlendMode()
 105    */
 106   BlendMode::Type GetBlendMode() const;
 107
 108   /**
 109    * @copydoc Dali::Renderer::SetBlendFunc()
 110    */
 111   void SetBlendFunc( BlendFactor::Type srcFactorRgba, BlendFactor::Type destFactorRgba );
 112
 113   /**
 114    * @copydoc Dali::Renderer::SetBlendFunc()
 115    */
 116   void SetBlendFunc( BlendFactor::Type srcFactorRgb,   BlendFactor::Type destFactorRgb,
 117                      BlendFactor::Type srcFactorAlpha, BlendFactor::Type destFactorAlpha );
 118
 119   /**
 120    * @copydoc Dali::Renderer::GetBlendFunc()
 121    */
 122   void GetBlendFunc( BlendFactor::Type& srcFactorRgb,   BlendFactor::Type& destFactorRgb,
 123                     BlendFactor::Type& srcFactorAlpha, BlendFactor::Type& destFactorAlpha ) const;
 124
 125   /**
 126    * @brief Set same Blend Equation for the RGB and alpha
 127    */
 128   void SetBlendEquation( DevelBlendEquation::Type equationRgba );
 129
 130   /**
 131    * @brief Set Blend Equation separately for the RGB and alpha
 132    */
 133   void SetBlendEquation( DevelBlendEquation::Type equationRgb, DevelBlendEquation::Type equationAlpha );
 134
 135   /**
 136    * @brief Get Blend Equation of rgb and alpha
 137    */
 138   void GetBlendEquation( DevelBlendEquation::Type& equationRgb, DevelBlendEquation::Type& equationAlpha ) const;
 139
 140   /**
 141    * @copydoc Dali::Renderer::SetIndexedDrawFirstElement
 142    */
 143   void SetIndexedDrawFirstElement( uint32_t firstElement );
 144
 145   /**
 146    * @copydoc Dali::Renderer::SetIndexedDrawElementsCount
 147    */
 148   void SetIndexedDrawElementsCount( uint32_t elementsCount );
 149
 150   /**
 151    * @brief Set whether the Pre-multiplied Alpha Blending is required
 152    *
 153    * @param[in] preMultipled whether alpha is pre-multiplied.
 154    */
 155   void EnablePreMultipliedAlpha( bool preMultipled );
 156
 157   /**
 158    * @brief Query whether alpha is pre-multiplied.
 159    *
 160    * @return True is alpha is pre-multiplied, false otherwise.
 161    */
 162   bool IsPreMultipliedAlphaEnabled() const;
 163
 164   /**
 165    * @brief Query whether Blend Equation Advanced is used in this renderer
 166    *
 167    * @return True is Blend Equation Advanced is used, false otherwise.
 168    */
 169   bool IsAdvancedBlendEquationApplied() const;
 170
 171   /**
 172    * @brief Get the scene graph object
 173    *
 174    * @return the scene object
 175    */
 176   const SceneGraph::Renderer& GetRendererSceneObject() const;
 177
 178 public: // Default property extensions from Object
 179
 180   /**
 181    * @copydoc Dali::Internal::Object::SetDefaultProperty()
 182    */
 183   void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
 184
 185   /**
 186    * @copydoc Dali::Internal::Object::GetDefaultProperty()
 187    */
 188   Property::Value GetDefaultProperty( Property::Index index ) const override;
 189
 190   /**
 191    * @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
 192    */
 193   Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
 194
 195    /**
 196     * @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
 197     */
 198    void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
 199
 200   /**
 201    * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
 202    */
 203   const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
 204
 205   /**
 206    * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
 207    */
 208   const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
 209
 210   /**
 211    * @brief Adds a draw command to the Renderer.
 212    * DrawCommands override Renderer's default behaviour.
 213    *
 214    * @param[in] command Valid reference to a DrawCommand objects
 215    */
 216   void AddDrawCommand( const Dali::DevelRenderer::DrawCommand& command );
 217
 218 private: // implementation
 219
 220   /**
 221    * @brief Constructor.
 222    *
 223    * @param sceneObject the scene graph renderer
 224    */
 225   Renderer( const SceneGraph::Renderer* sceneObject );
 226
 227   /**
 228    * @brief Sets the blend color.
 229    * @param[in] blendColor The blend color to set.
 230    */
 231   void SetBlendColor( const Vector4& blendColor );
 232
 233   /**
 234    * @brief Retrieves the blend-color.
 235    * @return A const reference to the blend-color
 236    */
 237   const Vector4& GetBlendColor() const;
 238
 239   /**
 240    * @brief Retrieves the cached event side value of a default property.
 241    * @param[in]  index  The index of the property
 242    * @param[out] value  Is set with the cached value of the property if found.
 243    * @return True if value set, false otherwise.
 244    */
 245   bool GetCachedPropertyValue( Property::Index index, Property::Value& value ) const;
 246
 247   /**
 248    * @brief Retrieves the current value of a default property from the scene-graph.
 249    * @param[in]  index  The index of the property
 250    * @param[out] value  Is set with the current scene-graph value of the property
 251    * @return True if value set, false otherwise.
 252    */
 253   bool GetCurrentPropertyValue( Property::Index index, Property::Value& value  ) const;
 254
 255 protected:
 256   /**
 257    * A reference counted object may only be deleted by calling Unreference()
 258    */
 259   ~Renderer() override;
 260
 261 private: // unimplemented methods
 262   Renderer( const Renderer& );
 263   Renderer& operator=( const Renderer& );
 264
 265 private: // data
 266
 267   GeometryPtr                         mGeometry;                   ///< Intrusive pointer to the geometry used by this renderer
 268   TextureSetPtr                       mTextureSet;                 ///< Intrusive pointer to the texture set used by this renderer
 269   ShaderPtr                           mShader;                     ///< Intrusive pointer to the shader used by this renderer
 270
 271   int32_t                             mDepthIndex;
 272
 273   uint32_t                            mIndexedDrawFirstElement;    ///< Offset of first element to draw from bound index buffer
 274   uint32_t                            mIndexedDrawElementCount;    ///< Number of elements to draw
 275
 276   Render::Renderer::StencilParameters mStencilParameters;          ///< Struct containing all stencil related options
 277   BlendingOptions                     mBlendingOptions;            ///< Local copy of blending options bitmask
 278
 279   float                               mOpacity;                    ///< Local copy of the opacity
 280   DepthFunction::Type                 mDepthFunction:4;            ///< Local copy of the depth function
 281   FaceCullingMode::Type               mFaceCullingMode:3;          ///< Local copy of the mode of face culling
 282   BlendMode::Type                     mBlendMode:3;                ///< Local copy of the mode of blending
 283   DepthWriteMode::Type                mDepthWriteMode:3;           ///< Local copy of the depth write mode
 284   DepthTestMode::Type                 mDepthTestMode:3;            ///< Local copy of the depth test mode
 285   DevelRenderer::Rendering::Type      mRenderingBehavior:2;        ///< The rendering behavior
 286   bool                                mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
 287
 288   std::vector<Dali::DevelRenderer::DrawCommand> mDrawCommands;     ///< list of draw commands
 289 };
 290
 291 } // namespace Internal
 292
 293 // Helpers for public-api forwarding methods
 294 inline Internal::Renderer& GetImplementation( Dali::Renderer& handle )
 295 {
 296   DALI_ASSERT_ALWAYS(handle && "Renderer handle is empty");
 297
 298   BaseObject& object = handle.GetBaseObject();
 299
 300   return static_cast<Internal::Renderer&>(object);
 301 }
 302
 303 inline const Internal::Renderer& GetImplementation( const Dali::Renderer& handle )
 304 {
 305   DALI_ASSERT_ALWAYS(handle && "Renderer handle is empty");
 306
 307   const BaseObject& object = handle.GetBaseObject();
 308
 309   return static_cast<const Internal::Renderer&>(object);
 310 }
 311
 312 } // namespace Dali
 313
 314 #endif // DALI_INTERNAL_RENDERER_H