dali/devel-api/rendering/renderer.h

   1 #ifndef DALI_RENDERER_H
   2 #define DALI_RENDERER_H
   3
   4 /*
   5  * Copyright (c) 2015 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 // EXTERNAL INCLUDES
  22 #include <string> // std::string
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/actors/blending.h> // Dali::BlendingMode, Dali::BlendingEquation, Dali::BlendingFactor
  26 #include <dali/public-api/object/handle.h> // Dali::Handle
  27 #include <dali/public-api/object/property-index-ranges.h> // DEFAULT_OBJECT_PROPERTY_START_INDEX
  28 #include <dali/devel-api/rendering/geometry.h> // Dali::Geometry
  29 #include <dali/devel-api/rendering/material.h> // Dali::Material
  30
  31 namespace Dali
  32 {
  33
  34 namespace Internal DALI_INTERNAL
  35 {
  36 class Renderer;
  37 }
  38
  39 /**
  40  * @brief Renderer is a handle to an object that can be used to provide an image to a material.
  41  */
  42 class DALI_IMPORT_API Renderer : public Handle
  43 {
  44 public:
  45
  46   /**
  47    * @brief Set face culling mode.
  48    */
  49   enum FaceCullingMode
  50   {
  51     NONE,                     ///< None of the faces should be culled
  52     CULL_FRONT,               ///< Cull front face, back face should never be shown
  53     CULL_BACK,                ///< Cull back face, back face should never be shown
  54     CULL_BACK_AND_FRONT,      ///< Cull back and front faces, if the geometry is composed of triangles none of the faces will be shown
  55   };
  56
  57   /**
  58    * @brief An enumeration of properties belonging to the Renderer class.
  59    */
  60   struct Property
  61   {
  62     enum
  63     {
  64       DEPTH_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX,  ///< name "depthIndex",   type INTEGER
  65       FACE_CULLING_MODE,                                  ///< name "faceCullingMode",                type INTEGER
  66       BLENDING_MODE,                                      ///< name "blendingMode",                   type INTEGER
  67       BLEND_EQUATION_RGB,                                 ///< name "blendEquationRgb",               type INTEGER
  68       BLEND_EQUATION_ALPHA,                               ///< name "blendEquationAlpha",             type INTEGER
  69       BLENDING_SRC_FACTOR_RGB,                            ///< name "sourceBlendFactorRgb",           type INTEGER
  70       BLENDING_DEST_FACTOR_RGB,                           ///< name "destinationBlendFactorRgb",      type INTEGER
  71       BLENDING_SRC_FACTOR_ALPHA,                          ///< name "sourceBlendFactorAlpha",         type INTEGER
  72       BLENDING_DEST_FACTOR_ALPHA,                         ///< name "destinationBlendFactorAlpha",    type INTEGER
  73       BLENDING_COLOR,                                     ///< name "blendingColor",                     type VECTOR4
  74       BLEND_PRE_MULTIPLIED_ALPHA,                         ///< name "blendPreMultipledAlpha",         type BOOLEAN
  75     };
  76   };
  77
  78   /**
  79    * @brief Creates a new Renderer object
  80    *
  81    * @param[in] geometry Geometry to be used by this renderer
  82    * @param[in] material Material to be used by this renderer
  83    */
  84   static Renderer New( Geometry& geometry, Material& material );
  85
  86   /**
  87    * @brief Default constructor, creates an empty handle
  88    */
  89   Renderer();
  90
  91   /**
  92    * @brief Destructor
  93    */
  94   ~Renderer();
  95
  96   /**
  97    * @brief Copy constructor, creates a new handle to the same object
  98    *
  99    * @param[in] handle Handle to an object
 100    */
 101   Renderer( const Renderer& handle );
 102
 103   /**
 104    * @brief Downcast to a renderer handle.
 105    *
 106    * If not a renderer the returned renderer handle is left uninitialized.
 107    * @param[in] handle to an object
 108    * @return renderer handle or an uninitialized handle
 109    */
 110   static Renderer DownCast( BaseHandle handle );
 111
 112   /**
 113    * @brief Assignment operator, changes this handle to point at the same object
 114    *
 115    * @param[in] handle Handle to an object
 116    * @return Reference to the assigned object
 117    */
 118   Renderer& operator=( const Renderer& handle );
 119
 120   /**
 121    * @brief Sets the geometry to be used by this renderer
 122    *
 123    * @param[in] geometry The geometry to be used by this renderer
 124    */
 125   void SetGeometry( Geometry& geometry );
 126
 127   /**
 128    * @brief Gets the geometry used by this renderer
 129    *
 130    * @return The geometry used by the renderer
 131    */
 132   Geometry GetGeometry() const;
 133
 134   /**
 135    * @brief Sets the material to be used by this renderer
 136    *
 137    * @param[in] material The material to be used by this renderer
 138    */
 139   void SetMaterial( Material& material );
 140
 141   /**
 142    * @brief Gets the material used by this renderer
 143    *
 144    * @return The material used by the renderer
 145    */
 146   Material GetMaterial() const;
 147
 148   /**
 149    * @brief Specify the pixel arithmetic used when the actor is blended.
 150    *
 151    * @param[in] srcFactorRgba Specifies how the red, green, blue, and alpha source blending factors are computed.
 152    * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR,
 153    * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR,
 154    * GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE.
 155    *
 156    * @param[in] destFactorRgba Specifies how the red, green, blue, and alpha destination blending factors are computed.
 157    * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR,
 158    * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR,
 159    * GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA.
 160    */
 161   void SetBlendFunc( BlendingFactor::Type srcFactorRgba, BlendingFactor::Type destFactorRgba );
 162
 163   /**
 164    * @brief Specify the pixel arithmetic used when the actor is blended.
 165    *
 166    * @param[in] srcFactorRgb Specifies how the red, green, and blue source blending factors are computed.
 167    * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR,
 168    * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR,
 169    * GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE.
 170    *
 171    * @param[in] destFactorRgb Specifies how the red, green, blue, and alpha destination blending factors are computed.
 172    * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR,
 173    * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR,
 174    * GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA.
 175    *
 176    * @param[in] srcFactorAlpha Specifies how the alpha source blending factor is computed.
 177    * The options are the same as for srcFactorRgb.
 178    *
 179    * @param[in] destFactorAlpha Specifies how the alpha source blending factor is computed.
 180    * The options are the same as for destFactorRgb.
 181    */
 182   void SetBlendFunc( BlendingFactor::Type srcFactorRgb,   BlendingFactor::Type destFactorRgb,
 183                      BlendingFactor::Type srcFactorAlpha, BlendingFactor::Type destFactorAlpha );
 184
 185   /**
 186    * @brief Query the pixel arithmetic used when the actor is blended.
 187    *
 188    * @param[out] srcFactorRgb Specifies how the red, green, blue, and alpha source blending factors are computed.
 189    * @param[out] destFactorRgb Specifies how the red, green, blue, and alpha destination blending factors are computed.
 190    * @param[out] srcFactorAlpha Specifies how the red, green, blue, and alpha source blending factors are computed.
 191    * @param[out] destFactorAlpha Specifies how the red, green, blue, and alpha destination blending factors are computed.
 192    */
 193   void GetBlendFunc( BlendingFactor::Type& srcFactorRgb,   BlendingFactor::Type& destFactorRgb,
 194                      BlendingFactor::Type& srcFactorAlpha, BlendingFactor::Type& destFactorAlpha ) const;
 195
 196   /**
 197    * @brief Specify the equation used when the actor is blended.
 198    *
 199    * The options are BlendingEquation::ADD, SUBTRACT, or REVERSE_SUBTRACT.
 200    * @param[in] equationRgba The equation used for combining red, green, blue, and alpha components.
 201    */
 202   void SetBlendEquation( BlendingEquation::Type equationRgba );
 203
 204   /**
 205    * @brief Specify the equation used when the actor is blended.
 206    *
 207    * @param[in] equationRgb The equation used for combining red, green, and blue components.
 208    * @param[in] equationAlpha The equation used for combining the alpha component.
 209    * The options are BlendingEquation::ADD, SUBTRACT, or REVERSE_SUBTRACT.
 210    */
 211   void SetBlendEquation( BlendingEquation::Type equationRgb, BlendingEquation::Type equationAlpha );
 212
 213   /**
 214    * @brief Query the equation used when the actor is blended.
 215    *
 216    * @param[out] equationRgb The equation used for combining red, green, and blue components.
 217    * @param[out] equationAlpha The equation used for combining the alpha component.
 218    */
 219   void GetBlendEquation( BlendingEquation::Type& equationRgb, BlendingEquation::Type& equationAlpha ) const;
 220
 221 public:
 222   /**
 223    * @brief The constructor
 224    *
 225    * @param [in] pointer A pointer to a newly allocated Renderer
 226    */
 227   explicit DALI_INTERNAL Renderer( Internal::Renderer* pointer );
 228 };
 229
 230 } //namespace Dali
 231
 232 #endif // DALI_RENDERER_H