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

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/rendering/renderer-impl.h> // Dali::Internal::Renderer
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/devel-api/scripting/scripting.h>
  23 #include <dali/devel-api/rendering/renderer-devel.h>
  24 #include <dali/public-api/object/type-registry.h>
  25 #include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
  26 #include <dali/internal/event/common/property-helper.h>    // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
  27 #include <dali/internal/event/common/property-input-impl.h>
  28 #include <dali/internal/render/renderers/render-geometry.h>
  29 #include <dali/internal/update/manager/update-manager.h>
  30 #include <dali/internal/update/rendering/scene-graph-renderer.h>
  31
  32 namespace Dali
  33 {
  34 namespace Internal
  35 {
  36
  37 namespace
  38 {
  39
  40 /**
  41  * Properties: |name                              |type     |writable|animatable|constraint-input|enum for index-checking|
  42  */
  43 DALI_PROPERTY_TABLE_BEGIN
  44 DALI_PROPERTY( "depthIndex",                      INTEGER,   true, false,  false, Dali::Renderer::Property::DEPTH_INDEX )
  45 DALI_PROPERTY( "faceCullingMode",                 INTEGER,   true, false,  false, Dali::Renderer::Property::FACE_CULLING_MODE )
  46 DALI_PROPERTY( "blendMode",                       INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_MODE )
  47 DALI_PROPERTY( "blendEquationRgb",                INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_EQUATION_RGB )
  48 DALI_PROPERTY( "blendEquationAlpha",              INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_EQUATION_ALPHA )
  49 DALI_PROPERTY( "blendFactorSrcRgb",               INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB )
  50 DALI_PROPERTY( "blendFactorDestRgb",              INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB )
  51 DALI_PROPERTY( "blendFactorSrcAlpha",             INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA )
  52 DALI_PROPERTY( "blendFactorDestAlpha",            INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA )
  53 DALI_PROPERTY( "blendColor",                      VECTOR4,   true, false,  false, Dali::Renderer::Property::BLEND_COLOR )
  54 DALI_PROPERTY( "blendPreMultipliedAlpha",         BOOLEAN,   true, false,  false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA )
  55 DALI_PROPERTY( "indexRangeFirst",                 INTEGER,   true, false,  false, Dali::Renderer::Property::INDEX_RANGE_FIRST )
  56 DALI_PROPERTY( "indexRangeCount",                 INTEGER,   true, false,  false, Dali::Renderer::Property::INDEX_RANGE_COUNT )
  57 DALI_PROPERTY( "depthWriteMode",                  INTEGER,   true, false,  false, Dali::Renderer::Property::DEPTH_WRITE_MODE )
  58 DALI_PROPERTY( "depthFunction",                   INTEGER,   true, false,  false, Dali::Renderer::Property::DEPTH_FUNCTION )
  59 DALI_PROPERTY( "depthTestMode",                   INTEGER,   true, false,  false, Dali::Renderer::Property::DEPTH_TEST_MODE )
  60 DALI_PROPERTY( "renderMode",                      INTEGER,   true, false,  false, Dali::Renderer::Property::RENDER_MODE )
  61 DALI_PROPERTY( "stencilFunction",                 INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_FUNCTION )
  62 DALI_PROPERTY( "stencilFunctionMask",             INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_FUNCTION_MASK )
  63 DALI_PROPERTY( "stencilFunctionReference",        INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE )
  64 DALI_PROPERTY( "stencilMask",                     INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_MASK )
  65 DALI_PROPERTY( "stencilOperationOnFail",          INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL )
  66 DALI_PROPERTY( "stencilOperationOnZFail",         INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL )
  67 DALI_PROPERTY( "stencilOperationOnZPass",         INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS )
  68 DALI_PROPERTY_TABLE_END( DEFAULT_RENDERER_PROPERTY_START_INDEX )
  69
  70 // Property string to enumeration tables:
  71
  72 DALI_ENUM_TO_STRING_TABLE_BEGIN( FACE_CULLING_MODE )
  73 DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, NONE )
  74 DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, FRONT )
  75 DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, BACK )
  76 DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, FRONT_AND_BACK )
  77 DALI_ENUM_TO_STRING_TABLE_END( FACE_CULLING_MODE )
  78
  79 DALI_ENUM_TO_STRING_TABLE_BEGIN( BLEND_MODE )
  80 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendMode, OFF )
  81 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendMode, AUTO )
  82 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendMode, ON )
  83 DALI_ENUM_TO_STRING_TABLE_END( BLEND_MODE )
  84
  85 DALI_ENUM_TO_STRING_TABLE_BEGIN( BLEND_EQUATION )
  86 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendEquation, ADD )
  87 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendEquation, SUBTRACT )
  88 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendEquation, REVERSE_SUBTRACT )
  89 DALI_ENUM_TO_STRING_TABLE_END( BLEND_EQUATION )
  90
  91 DALI_ENUM_TO_STRING_TABLE_BEGIN( BLEND_FACTOR )
  92 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ZERO )
  93 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE )
  94 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, SRC_COLOR )
  95 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_SRC_COLOR )
  96 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, SRC_ALPHA )
  97 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_SRC_ALPHA )
  98 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, DST_ALPHA )
  99 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_DST_ALPHA )
 100 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, DST_COLOR )
 101 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_DST_COLOR )
 102 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, SRC_ALPHA_SATURATE )
 103 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, CONSTANT_COLOR )
 104 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_CONSTANT_COLOR )
 105 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, CONSTANT_ALPHA )
 106 DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_CONSTANT_ALPHA )
 107 DALI_ENUM_TO_STRING_TABLE_END( BLEND_FACTOR )
 108
 109 DALI_ENUM_TO_STRING_TABLE_BEGIN( DEPTH_WRITE_MODE )
 110 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthWriteMode, OFF )
 111 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthWriteMode, AUTO )
 112 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthWriteMode, ON )
 113 DALI_ENUM_TO_STRING_TABLE_END( DEPTH_WRITE_MODE )
 114
 115 DALI_ENUM_TO_STRING_TABLE_BEGIN( DEPTH_TEST_MODE )
 116 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthTestMode, OFF )
 117 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthTestMode, AUTO )
 118 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthTestMode, ON )
 119 DALI_ENUM_TO_STRING_TABLE_END( DEPTH_TEST_MODE )
 120
 121 DALI_ENUM_TO_STRING_TABLE_BEGIN( DEPTH_FUNCTION )
 122 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, NEVER )
 123 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, ALWAYS )
 124 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, LESS )
 125 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, GREATER )
 126 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, EQUAL )
 127 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, NOT_EQUAL )
 128 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, LESS_EQUAL )
 129 DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, GREATER_EQUAL )
 130 DALI_ENUM_TO_STRING_TABLE_END( DEPTH_FUNCTION )
 131
 132 DALI_ENUM_TO_STRING_TABLE_BEGIN( STENCIL_FUNCTION )
 133 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, NEVER )
 134 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, LESS )
 135 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, EQUAL )
 136 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, LESS_EQUAL )
 137 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, GREATER )
 138 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, NOT_EQUAL )
 139 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, GREATER_EQUAL )
 140 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, ALWAYS )
 141 DALI_ENUM_TO_STRING_TABLE_END( STENCIL_FUNCTION )
 142
 143 DALI_ENUM_TO_STRING_TABLE_BEGIN( RENDER_MODE )
 144 DALI_ENUM_TO_STRING_WITH_SCOPE( RenderMode, NONE )
 145 DALI_ENUM_TO_STRING_WITH_SCOPE( RenderMode, AUTO )
 146 DALI_ENUM_TO_STRING_WITH_SCOPE( RenderMode, COLOR )
 147 DALI_ENUM_TO_STRING_WITH_SCOPE( RenderMode, STENCIL )
 148 DALI_ENUM_TO_STRING_WITH_SCOPE( RenderMode, COLOR_STENCIL )
 149 DALI_ENUM_TO_STRING_TABLE_END( RENDER_MODE )
 150
 151 DALI_ENUM_TO_STRING_TABLE_BEGIN( STENCIL_OPERATION )
 152 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, ZERO )
 153 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, KEEP )
 154 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, REPLACE )
 155 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, INCREMENT )
 156 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, DECREMENT )
 157 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, INVERT )
 158 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, INCREMENT_WRAP )
 159 DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, DECREMENT_WRAP )
 160 DALI_ENUM_TO_STRING_TABLE_END( STENCIL_OPERATION )
 161
 162 const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS };
 163
 164 BaseHandle Create()
 165 {
 166   return Dali::BaseHandle();
 167 }
 168
 169 TypeRegistration mType( typeid( Dali::Renderer ), typeid( Dali::Handle ), Create );
 170
 171 } // unnamed namespace
 172
 173 RendererPtr Renderer::New()
 174 {
 175   RendererPtr rendererPtr( new Renderer() );
 176   rendererPtr->Initialize();
 177   return rendererPtr;
 178 }
 179
 180 void Renderer::SetGeometry( Geometry& geometry )
 181 {
 182   mGeometry = &geometry;
 183
 184   const Render::Geometry* geometrySceneObject = geometry.GetRenderObject();
 185   SetGeometryMessage( GetEventThreadServices(), *mSceneObject, *geometrySceneObject );
 186 }
 187
 188 Geometry* Renderer::GetGeometry() const
 189 {
 190   return mGeometry.Get();
 191 }
 192
 193 void Renderer::SetTextures( TextureSet& textureSet )
 194 {
 195   mTextureSet = &textureSet;
 196   const SceneGraph::TextureSet* textureSetSceneObject = textureSet.GetTextureSetSceneObject();
 197   SetTexturesMessage( GetEventThreadServices(), *mSceneObject, *textureSetSceneObject );
 198 }
 199
 200 TextureSet* Renderer::GetTextures() const
 201 {
 202   return mTextureSet.Get();
 203 }
 204
 205 void Renderer::SetShader( Shader& shader )
 206 {
 207   mShader = &shader;
 208   SceneGraph::Shader& sceneGraphShader = *shader.GetShaderSceneObject();
 209   SceneGraph::SetShaderMessage( GetEventThreadServices(), *mSceneObject, sceneGraphShader );
 210 }
 211
 212 Shader* Renderer::GetShader() const
 213 {
 214   return mShader.Get();
 215 }
 216
 217 void Renderer::SetDepthIndex( int depthIndex )
 218 {
 219   if ( mDepthIndex != depthIndex )
 220   {
 221     mDepthIndex = depthIndex;
 222     SetDepthIndexMessage( GetEventThreadServices(), *mSceneObject, depthIndex );
 223   }
 224 }
 225
 226 int Renderer::GetDepthIndex() const
 227 {
 228   return mDepthIndex;
 229 }
 230
 231 void Renderer::SetBlendMode( BlendMode::Type mode )
 232 {
 233   if( mBlendMode != mode )
 234   {
 235     mBlendMode = mode;
 236
 237     SetBlendModeMessage( GetEventThreadServices(), *mSceneObject, mBlendMode );
 238   }
 239 }
 240
 241 BlendMode::Type Renderer::GetBlendMode() const
 242 {
 243   return mBlendMode;
 244 }
 245
 246 void Renderer::SetBlendFunc( BlendFactor::Type srcFactorRgba, BlendFactor::Type destFactorRgba )
 247 {
 248   mBlendingOptions.SetBlendFunc( srcFactorRgba, destFactorRgba, srcFactorRgba, destFactorRgba );
 249   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 250 }
 251
 252 void Renderer::SetBlendFunc( BlendFactor::Type srcFactorRgb,
 253                              BlendFactor::Type destFactorRgb,
 254                              BlendFactor::Type srcFactorAlpha,
 255                              BlendFactor::Type destFactorAlpha )
 256 {
 257   mBlendingOptions.SetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 258   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 259 }
 260
 261 void Renderer::GetBlendFunc( BlendFactor::Type& srcFactorRgb,
 262                              BlendFactor::Type& destFactorRgb,
 263                              BlendFactor::Type& srcFactorAlpha,
 264                              BlendFactor::Type& destFactorAlpha ) const
 265 {
 266   srcFactorRgb    = mBlendingOptions.GetBlendSrcFactorRgb();
 267   destFactorRgb   = mBlendingOptions.GetBlendDestFactorRgb();
 268   srcFactorAlpha  = mBlendingOptions.GetBlendSrcFactorAlpha();
 269   destFactorAlpha = mBlendingOptions.GetBlendDestFactorAlpha();
 270 }
 271
 272 void Renderer::SetBlendEquation( BlendEquation::Type equationRgba )
 273 {
 274   mBlendingOptions.SetBlendEquation( equationRgba, equationRgba );
 275   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 276 }
 277
 278 void Renderer::SetBlendEquation( BlendEquation::Type equationRgb,
 279                                  BlendEquation::Type equationAlpha )
 280 {
 281   mBlendingOptions.SetBlendEquation( equationRgb, equationAlpha );
 282   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 283 }
 284
 285 void Renderer::GetBlendEquation( BlendEquation::Type& equationRgb,
 286                                  BlendEquation::Type& equationAlpha ) const
 287 {
 288   // These are not animatable, the cached values are up-to-date.
 289   equationRgb   = mBlendingOptions.GetBlendEquationRgb();
 290   equationAlpha = mBlendingOptions.GetBlendEquationAlpha();
 291 }
 292
 293 void Renderer::SetBlendColor( const Vector4& color )
 294 {
 295   if( !mBlendColor )
 296   {
 297     mBlendColor = new Vector4();
 298   }
 299   if( *mBlendColor != color )
 300   {
 301     *mBlendColor = color;
 302     SetBlendColorMessage( GetEventThreadServices(), *mSceneObject, *mBlendColor );
 303   }
 304 }
 305
 306 Vector4 Renderer::GetBlendColor() const
 307 {
 308   if( mBlendColor )
 309   {
 310     return *mBlendColor;
 311   }
 312   return Color::TRANSPARENT; // GL default
 313 }
 314
 315 void Renderer::SetIndexedDrawFirstElement( size_t firstElement )
 316 {
 317   if( firstElement != mIndexedDrawFirstElement )
 318   {
 319     mIndexedDrawFirstElement = firstElement;
 320     SetIndexedDrawFirstElementMessage( GetEventThreadServices(), *mSceneObject, mIndexedDrawFirstElement );
 321   }
 322 }
 323
 324 void Renderer::SetIndexedDrawElementsCount( size_t elementsCount )
 325 {
 326   if( elementsCount != mIndexedDrawElementCount )
 327   {
 328     mIndexedDrawElementCount = elementsCount;
 329     SetIndexedDrawElementsCountMessage( GetEventThreadServices(), *mSceneObject, mIndexedDrawElementCount );
 330   }
 331 }
 332
 333
 334 void Renderer::EnablePreMultipliedAlpha( bool preMultipled )
 335 {
 336   if(  mPremultipledAlphaEnabled != preMultipled )
 337   {
 338     if( preMultipled )
 339     {
 340       SetBlendFunc( BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE );
 341     }
 342     mPremultipledAlphaEnabled = preMultipled;
 343     SetEnablePreMultipliedAlphaMessage( GetEventThreadServices(), *mSceneObject, mPremultipledAlphaEnabled );
 344   }
 345 }
 346
 347 bool Renderer::IsPreMultipliedAlphaEnabled() const
 348 {
 349   return mPremultipledAlphaEnabled;
 350 }
 351
 352 SceneGraph::Renderer* Renderer::GetRendererSceneObject()
 353 {
 354   return mSceneObject;
 355 }
 356
 357 unsigned int Renderer::GetDefaultPropertyCount() const
 358 {
 359   return RENDERER_IMPL.GetDefaultPropertyCount();
 360 }
 361
 362 void Renderer::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
 363 {
 364   RENDERER_IMPL.GetDefaultPropertyIndices( indices );
 365 }
 366
 367 const char* Renderer::GetDefaultPropertyName(Property::Index index) const
 368 {
 369   return RENDERER_IMPL.GetDefaultPropertyName( index );
 370 }
 371
 372 Property::Index Renderer::GetDefaultPropertyIndex( const std::string& name ) const
 373 {
 374   return RENDERER_IMPL.GetDefaultPropertyIndex( name );
 375 }
 376
 377 bool Renderer::IsDefaultPropertyWritable( Property::Index index ) const
 378 {
 379   return RENDERER_IMPL.IsDefaultPropertyWritable( index );
 380 }
 381
 382 bool Renderer::IsDefaultPropertyAnimatable( Property::Index index ) const
 383 {
 384   return RENDERER_IMPL.IsDefaultPropertyAnimatable( index );
 385 }
 386
 387 bool Renderer::IsDefaultPropertyAConstraintInput( Property::Index index ) const
 388 {
 389   return RENDERER_IMPL.IsDefaultPropertyAConstraintInput( index );
 390 }
 391
 392 Property::Type Renderer::GetDefaultPropertyType( Property::Index index ) const
 393 {
 394   return RENDERER_IMPL.GetDefaultPropertyType( index );
 395 }
 396
 397 void Renderer::SetDefaultProperty( Property::Index index,
 398                                    const Property::Value& propertyValue )
 399 {
 400   switch( index )
 401   {
 402     case Dali::Renderer::Property::DEPTH_INDEX:
 403     {
 404       SetDepthIndex( propertyValue.Get<int>() );
 405       break;
 406     }
 407     case Dali::Renderer::Property::FACE_CULLING_MODE:
 408     {
 409       FaceCullingMode::Type convertedValue = mFaceCullingMode;
 410       if( Scripting::GetEnumerationProperty< FaceCullingMode::Type >( propertyValue, FACE_CULLING_MODE_TABLE, FACE_CULLING_MODE_TABLE_COUNT, convertedValue ) )
 411       {
 412         mFaceCullingMode = convertedValue;
 413         SetFaceCullingModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 414       }
 415       break;
 416     }
 417     case Dali::Renderer::Property::BLEND_MODE:
 418     {
 419       BlendMode::Type convertedValue = mBlendMode;
 420       if( Scripting::GetEnumerationProperty< BlendMode::Type >( propertyValue, BLEND_MODE_TABLE, BLEND_MODE_TABLE_COUNT, convertedValue ) )
 421       {
 422         SetBlendMode( convertedValue );
 423       }
 424       break;
 425     }
 426     case Dali::Renderer::Property::BLEND_EQUATION_RGB:
 427     {
 428       BlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationRgb();
 429
 430       if( Scripting::GetEnumerationProperty< BlendEquation::Type >( propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue ) )
 431       {
 432         BlendEquation::Type alphaEquation = mBlendingOptions.GetBlendEquationAlpha();
 433         mBlendingOptions.SetBlendEquation( convertedValue, alphaEquation );
 434         SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 435       }
 436       break;
 437     }
 438     case Dali::Renderer::Property::BLEND_EQUATION_ALPHA:
 439     {
 440       BlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationAlpha();
 441
 442       if( Scripting::GetEnumerationProperty< BlendEquation::Type >( propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue ) )
 443       {
 444         BlendEquation::Type rgbEquation = mBlendingOptions.GetBlendEquationRgb();
 445         mBlendingOptions.SetBlendEquation( rgbEquation, convertedValue );
 446         SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 447       }
 448       break;
 449     }
 450     case Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB:
 451     {
 452       BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
 453       GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 454
 455       if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, sourceFactorRgb ) )
 456       {
 457         SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 458       }
 459       break;
 460     }
 461     case Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB:
 462     {
 463       BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
 464       GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 465
 466       if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, destinationFactorRgb ) )
 467       {
 468         SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 469       }
 470       break;
 471     }
 472     case Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA:
 473     {
 474       BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
 475       GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 476
 477       if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, sourceFactorAlpha ) )
 478       {
 479         SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 480       }
 481       break;
 482     }
 483     case Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA:
 484     {
 485       BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
 486       GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 487
 488       if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, destinationFactorAlpha ) )
 489       {
 490         SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
 491       }
 492       break;
 493     }
 494     case Dali::Renderer::Property::BLEND_COLOR:
 495     {
 496       Vector4 blendColor;
 497       if( propertyValue.Get( blendColor ) )
 498       {
 499         SetBlendColor( blendColor );
 500       }
 501       break;
 502     }
 503     case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA:
 504     {
 505       bool preMultipled;
 506       if( propertyValue.Get( preMultipled ) )
 507       {
 508         EnablePreMultipliedAlpha( preMultipled );
 509       }
 510       break;
 511     }
 512     case Dali::Renderer::Property::INDEX_RANGE_FIRST:
 513     {
 514       int firstElement;
 515       if( propertyValue.Get( firstElement ) )
 516       {
 517         SetIndexedDrawFirstElement( firstElement );
 518       }
 519       break;
 520     }
 521     case Dali::Renderer::Property::INDEX_RANGE_COUNT:
 522     {
 523       int elementsCount;
 524       if( propertyValue.Get( elementsCount ) )
 525       {
 526         SetIndexedDrawElementsCount( elementsCount );
 527       }
 528       break;
 529     }
 530     case Dali::Renderer::Property::DEPTH_WRITE_MODE:
 531     {
 532       DepthWriteMode::Type convertedValue = mDepthWriteMode;
 533       if( Scripting::GetEnumerationProperty< DepthWriteMode::Type >( propertyValue, DEPTH_WRITE_MODE_TABLE, DEPTH_WRITE_MODE_TABLE_COUNT, convertedValue ) )
 534       {
 535         mDepthWriteMode = convertedValue;
 536         SetDepthWriteModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 537       }
 538       break;
 539     }
 540     case Dali::Renderer::Property::DEPTH_FUNCTION:
 541     {
 542       DepthFunction::Type convertedValue = mDepthFunction;
 543       if( Scripting::GetEnumerationProperty< DepthFunction::Type >( propertyValue, DEPTH_FUNCTION_TABLE, DEPTH_FUNCTION_TABLE_COUNT, convertedValue ) )
 544       {
 545         mDepthFunction = convertedValue;
 546         SetDepthFunctionMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 547       }
 548       break;
 549     }
 550     case Dali::Renderer::Property::DEPTH_TEST_MODE:
 551     {
 552       DepthTestMode::Type convertedValue = mDepthTestMode;
 553       if( Scripting::GetEnumerationProperty< DepthTestMode::Type >( propertyValue, DEPTH_TEST_MODE_TABLE, DEPTH_TEST_MODE_TABLE_COUNT, convertedValue ) )
 554       {
 555         mDepthTestMode = convertedValue;
 556         SetDepthTestModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 557       }
 558       break;
 559     }
 560     case Dali::Renderer::Property::RENDER_MODE:
 561     {
 562       RenderMode::Type convertedValue = mStencilParameters.renderMode;
 563       if( Scripting::GetEnumerationProperty< RenderMode::Type >( propertyValue, RENDER_MODE_TABLE, RENDER_MODE_TABLE_COUNT, convertedValue ) )
 564       {
 565         mStencilParameters.renderMode = convertedValue;
 566         SetRenderModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 567       }
 568       break;
 569     }
 570     case Dali::Renderer::Property::STENCIL_FUNCTION:
 571     {
 572       StencilFunction::Type convertedValue = mStencilParameters.stencilFunction;
 573       if( Scripting::GetEnumerationProperty< StencilFunction::Type >( propertyValue, STENCIL_FUNCTION_TABLE, STENCIL_FUNCTION_TABLE_COUNT, convertedValue ) )
 574       {
 575         mStencilParameters.stencilFunction = convertedValue;
 576         SetStencilFunctionMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 577       }
 578       break;
 579     }
 580     case Dali::Renderer::Property::STENCIL_FUNCTION_MASK:
 581     {
 582       int stencilFunctionMask;
 583       if( propertyValue.Get( stencilFunctionMask ) )
 584       {
 585         if( stencilFunctionMask != mStencilParameters.stencilFunctionMask )
 586         {
 587           mStencilParameters.stencilFunctionMask = stencilFunctionMask;
 588           SetStencilFunctionMaskMessage( GetEventThreadServices(), *mSceneObject, stencilFunctionMask );
 589         }
 590       }
 591       break;
 592     }
 593     case Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE:
 594     {
 595       int stencilFunctionReference;
 596       if( propertyValue.Get( stencilFunctionReference ) )
 597       {
 598         if( stencilFunctionReference != mStencilParameters.stencilFunctionReference )
 599         {
 600           mStencilParameters.stencilFunctionReference = stencilFunctionReference;
 601           SetStencilFunctionReferenceMessage( GetEventThreadServices(), *mSceneObject, stencilFunctionReference );
 602         }
 603       }
 604       break;
 605     }
 606     case Dali::Renderer::Property::STENCIL_MASK:
 607     {
 608       int stencilMask;
 609       if( propertyValue.Get( stencilMask ) )
 610       {
 611         if( stencilMask != mStencilParameters.stencilMask )
 612         {
 613           mStencilParameters.stencilMask = stencilMask;
 614           SetStencilMaskMessage( GetEventThreadServices(), *mSceneObject, stencilMask );
 615         }
 616       }
 617       break;
 618     }
 619     case Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL:
 620     {
 621       StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnFail;
 622       if( Scripting::GetEnumerationProperty< StencilOperation::Type >( propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue ) )
 623       {
 624         mStencilParameters.stencilOperationOnFail = convertedValue;
 625         SetStencilOperationOnFailMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 626       }
 627       break;
 628     }
 629     case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL:
 630     {
 631       StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnZFail;
 632       if( Scripting::GetEnumerationProperty< StencilOperation::Type >( propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue ) )
 633       {
 634         mStencilParameters.stencilOperationOnZFail = convertedValue;
 635         SetStencilOperationOnZFailMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 636       }
 637       break;
 638     }
 639     case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS:
 640     {
 641       StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnZPass;
 642       if( Scripting::GetEnumerationProperty< StencilOperation::Type >( propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue ) )
 643       {
 644         mStencilParameters.stencilOperationOnZPass = convertedValue;
 645         SetStencilOperationOnZPassMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
 646       }
 647       break;
 648     }
 649   }
 650 }
 651
 652 void Renderer::SetSceneGraphProperty( Property::Index index,
 653                                       const PropertyMetadata& entry,
 654                                       const Property::Value& value )
 655 {
 656   RENDERER_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value );
 657   OnPropertySet(index, value);
 658 }
 659
 660 Property::Value Renderer::GetDefaultProperty( Property::Index index ) const
 661 {
 662   Property::Value value;
 663   switch( index )
 664   {
 665     case Dali::Renderer::Property::DEPTH_INDEX:
 666     {
 667       value = GetDepthIndex();
 668       break;
 669     }
 670     case Dali::Renderer::Property::FACE_CULLING_MODE:
 671     {
 672       value = mFaceCullingMode;
 673       break;
 674     }
 675     case Dali::Renderer::Property::BLEND_MODE:
 676     {
 677       value = mBlendMode;
 678       break;
 679     }
 680     case Dali::Renderer::Property::BLEND_EQUATION_RGB:
 681     {
 682       value = static_cast<int>( mBlendingOptions.GetBlendEquationRgb() );
 683       break;
 684     }
 685     case Dali::Renderer::Property::BLEND_EQUATION_ALPHA:
 686     {
 687       value = static_cast<int>( mBlendingOptions.GetBlendEquationAlpha() );
 688       break;
 689     }
 690     case Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB:
 691     {
 692       BlendFactor::Type srcFactorRgb;
 693       BlendFactor::Type destFactorRgb;
 694       BlendFactor::Type srcFactorAlpha;
 695       BlendFactor::Type destFactorAlpha;
 696       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 697       value = static_cast<int>( srcFactorRgb );
 698       break;
 699     }
 700     case Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB:
 701     {
 702       BlendFactor::Type srcFactorRgb;
 703       BlendFactor::Type destFactorRgb;
 704       BlendFactor::Type srcFactorAlpha;
 705       BlendFactor::Type destFactorAlpha;
 706       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 707       value = static_cast<int>( destFactorRgb );
 708       break;
 709     }
 710     case Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA:
 711     {
 712       BlendFactor::Type srcFactorRgb;
 713       BlendFactor::Type destFactorRgb;
 714       BlendFactor::Type srcFactorAlpha;
 715       BlendFactor::Type destFactorAlpha;
 716       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 717       value = static_cast<int>( srcFactorAlpha );
 718       break;
 719     }
 720     case Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA:
 721     {
 722       BlendFactor::Type srcFactorRgb;
 723       BlendFactor::Type destFactorRgb;
 724       BlendFactor::Type srcFactorAlpha;
 725       BlendFactor::Type destFactorAlpha;
 726       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 727       value = static_cast<int>( destFactorAlpha );
 728       break;
 729     }
 730     case Dali::Renderer::Property::BLEND_COLOR:
 731     {
 732       if( mBlendColor )
 733       {
 734         value = *mBlendColor;
 735       }
 736       else
 737       {
 738         value = Color::TRANSPARENT;
 739       }
 740       break;
 741     }
 742     case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA:
 743     {
 744       value = IsPreMultipliedAlphaEnabled();
 745       break;
 746     }
 747     case Dali::Renderer::Property::INDEX_RANGE_FIRST:
 748     {
 749       value = static_cast<int>( mIndexedDrawFirstElement );
 750       break;
 751     }
 752     case Dali::Renderer::Property::INDEX_RANGE_COUNT:
 753     {
 754       value = static_cast<int>( mIndexedDrawElementCount );
 755       break;
 756     }
 757     case Dali::Renderer::Property::DEPTH_WRITE_MODE:
 758     {
 759       value = mDepthWriteMode;
 760       break;
 761     }
 762     case Dali::Renderer::Property::DEPTH_FUNCTION:
 763     {
 764       value = mDepthFunction;
 765       break;
 766     }
 767     case Dali::Renderer::Property::DEPTH_TEST_MODE:
 768     {
 769       value = mDepthTestMode;
 770       break;
 771     }
 772     case Dali::Renderer::Property::STENCIL_FUNCTION:
 773     {
 774       value = mStencilParameters.stencilFunction;
 775       break;
 776     }
 777     case Dali::Renderer::Property::STENCIL_FUNCTION_MASK:
 778     {
 779       value = mStencilParameters.stencilFunctionMask;
 780       break;
 781     }
 782     case Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE:
 783     {
 784       value = mStencilParameters.stencilFunctionReference;
 785       break;
 786     }
 787     case Dali::Renderer::Property::STENCIL_MASK:
 788     {
 789       value = mStencilParameters.stencilMask;
 790       break;
 791     }
 792     case Dali::Renderer::Property::RENDER_MODE:
 793     {
 794       value = mStencilParameters.renderMode;
 795       break;
 796     }
 797     case Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL:
 798     {
 799       value = mStencilParameters.stencilOperationOnFail;
 800       break;
 801     }
 802     case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL:
 803     {
 804       value = mStencilParameters.stencilOperationOnZFail;
 805       break;
 806     }
 807     case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS:
 808     {
 809       value = mStencilParameters.stencilOperationOnZPass;
 810       break;
 811     }
 812   }
 813   return value;
 814 }
 815
 816 const SceneGraph::PropertyOwner* Renderer::GetPropertyOwner() const
 817 {
 818   return mSceneObject;
 819 }
 820
 821 const SceneGraph::PropertyOwner* Renderer::GetSceneObject() const
 822 {
 823   return mSceneObject;
 824 }
 825
 826 const SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty( Property::Index index ) const
 827 {
 828   DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" );
 829   const SceneGraph::PropertyBase* property = NULL;
 830
 831   property = RENDERER_IMPL.GetRegisteredSceneGraphProperty(
 832     this,
 833     &Renderer::FindAnimatableProperty,
 834     &Renderer::FindCustomProperty,
 835     index );
 836
 837   return property;
 838 }
 839
 840 const PropertyInputImpl* Renderer::GetSceneObjectInputProperty( Property::Index index ) const
 841 {
 842   const PropertyInputImpl* property = NULL;
 843
 844   const SceneGraph::PropertyBase* baseProperty =
 845     RENDERER_IMPL.GetRegisteredSceneGraphProperty( this,
 846                                                    &Renderer::FindAnimatableProperty,
 847                                                    &Renderer::FindCustomProperty,
 848                                                    index );
 849   property = static_cast<const PropertyInputImpl*>( baseProperty );
 850
 851   return property;
 852 }
 853
 854 int Renderer::GetPropertyComponentIndex( Property::Index index ) const
 855 {
 856   return Property::INVALID_COMPONENT_INDEX;
 857 }
 858
 859 Renderer::Renderer()
 860 : mSceneObject(NULL ),
 861   mBlendColor( NULL ),
 862   mDepthIndex( 0 ),
 863   mIndexedDrawFirstElement( 0 ),
 864   mIndexedDrawElementCount( 0 ),
 865   mStencilParameters( RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP ),
 866   mBlendingOptions(),
 867   mDepthFunction( DepthFunction::LESS ),
 868   mFaceCullingMode( FaceCullingMode::NONE ),
 869   mBlendMode( BlendMode::AUTO ),
 870   mDepthWriteMode( DepthWriteMode::AUTO ),
 871   mDepthTestMode( DepthTestMode::AUTO ),
 872   mPremultipledAlphaEnabled( false )
 873 {
 874 }
 875
 876 void Renderer::Initialize()
 877 {
 878   EventThreadServices& eventThreadServices = GetEventThreadServices();
 879   SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 880
 881   mSceneObject = SceneGraph::Renderer::New();
 882   AddMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject );
 883
 884   eventThreadServices.RegisterObject( this );
 885 }
 886
 887 Renderer::~Renderer()
 888 {
 889   if( EventThreadServices::IsCoreRunning() )
 890   {
 891     EventThreadServices& eventThreadServices = GetEventThreadServices();
 892     SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 893     RemoveMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject );
 894
 895     eventThreadServices.UnregisterObject( this );
 896   }
 897 }
 898
 899 } // namespace Internal
 900 } // namespace Dali