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

   1 /*
   2  * Copyright (c) 2015 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/public-api/object/type-registry.h>
  23 #include <dali/devel-api/rendering/renderer.h> // Dali::Renderer
  24 #include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
  25 #include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
  26 #include <dali/internal/event/common/property-input-impl.h>
  27 #include <dali/internal/update/rendering/scene-graph-renderer.h>
  28 #include <dali/internal/update/manager/update-manager.h>
  29
  30 namespace Dali
  31 {
  32 namespace Internal
  33 {
  34
  35 namespace
  36 {
  37
  38 /**
  39  *            |name                              |type     |writable|animatable|constraint-input|enum for index-checking|
  40  */
  41 DALI_PROPERTY_TABLE_BEGIN
  42 DALI_PROPERTY( "depthIndex",                      INTEGER,   true, false,  false, Dali::Renderer::Property::DEPTH_INDEX )
  43 DALI_PROPERTY( "faceCullingMode",                 INTEGER,   true, false,  false, Dali::Renderer::Property::FACE_CULLING_MODE )
  44 DALI_PROPERTY( "blendingMode",                    INTEGER,   true, false,  false, Dali::Renderer::Property::BLENDING_MODE )
  45 DALI_PROPERTY( "blendEquationRgb",                INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_EQUATION_RGB )
  46 DALI_PROPERTY( "blendEquationAlpha",              INTEGER,   true, false,  false, Dali::Renderer::Property::BLEND_EQUATION_ALPHA )
  47 DALI_PROPERTY( "sourceBlendFactorRgb",            INTEGER,   true, false,  false, Dali::Renderer::Property::BLENDING_SRC_FACTOR_RGB )
  48 DALI_PROPERTY( "destinationBlendFactorRgb",       INTEGER,   true, false,  false, Dali::Renderer::Property::BLENDING_DEST_FACTOR_RGB )
  49 DALI_PROPERTY( "sourceBlendFactorAlpha",          INTEGER,   true, false,  false, Dali::Renderer::Property::BLENDING_SRC_FACTOR_ALPHA )
  50 DALI_PROPERTY( "destinationBlendFactorAlpha",     INTEGER,   true, false,  false, Dali::Renderer::Property::BLENDING_DEST_FACTOR_ALPHA )
  51 DALI_PROPERTY( "blendingColor",                   VECTOR4,   true, false,  false, Dali::Renderer::Property::BLENDING_COLOR )
  52 DALI_PROPERTY( "blendPreMultipliedAlpha",         BOOLEAN,   true, false,  false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA )
  53 DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
  54
  55 const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS };
  56
  57 BaseHandle Create()
  58 {
  59   return Dali::BaseHandle();
  60 }
  61
  62 TypeRegistration mType( typeid( Dali::Renderer ), typeid( Dali::Handle ), Create );
  63
  64 } // unnamed namespace
  65
  66 RendererPtr Renderer::New()
  67 {
  68   RendererPtr rendererPtr( new Renderer() );
  69   rendererPtr->Initialize();
  70   return rendererPtr;
  71 }
  72
  73 void Renderer::SetGeometry( Geometry& geometry )
  74 {
  75   mGeometryConnector.Set( geometry, OnStage() );
  76   const SceneGraph::Geometry* geometrySceneObject = geometry.GetGeometrySceneObject();
  77
  78   SetGeometryMessage( GetEventThreadServices(), *mSceneObject, *geometrySceneObject );
  79 }
  80
  81 Geometry* Renderer::GetGeometry() const
  82 {
  83   return mGeometryConnector.Get().Get();
  84 }
  85
  86 void Renderer::SetMaterial( Material& material )
  87 {
  88   mMaterialConnector.Set( material, OnStage() );
  89   const SceneGraph::Material* materialSceneObject = material.GetMaterialSceneObject();
  90   SetMaterialMessage( GetEventThreadServices(), *mSceneObject, *materialSceneObject );
  91 }
  92
  93 Material* Renderer::GetMaterial() const
  94 {
  95   return mMaterialConnector.Get().Get();
  96 }
  97
  98 void Renderer::SetDepthIndex( int depthIndex )
  99 {
 100   if ( mDepthIndex != depthIndex )
 101   {
 102     mDepthIndex = depthIndex;
 103     SetDepthIndexMessage( GetEventThreadServices(), *mSceneObject, depthIndex );
 104   }
 105 }
 106
 107 int Renderer::GetDepthIndex() const
 108 {
 109   return mDepthIndex;
 110 }
 111
 112 void Renderer::SetFaceCullingMode( Dali::Renderer::FaceCullingMode cullingMode )
 113 {
 114   if( mFaceCullingMode != cullingMode )
 115   {
 116     mFaceCullingMode = cullingMode;
 117
 118     SetFaceCullingModeMessage( GetEventThreadServices(), *mSceneObject, mFaceCullingMode );
 119   }
 120 }
 121
 122 Dali::Renderer::FaceCullingMode Renderer::GetFaceCullingMode()
 123 {
 124   return mFaceCullingMode;
 125 }
 126
 127 void Renderer::SetBlendMode( BlendingMode::Type mode )
 128 {
 129   if( mBlendingMode != mode )
 130   {
 131     mBlendingMode = mode;
 132
 133     SetBlendingModeMessage( GetEventThreadServices(), *mSceneObject, mBlendingMode );
 134   }
 135 }
 136
 137 BlendingMode::Type Renderer::GetBlendMode() const
 138 {
 139   return mBlendingMode;
 140 }
 141
 142 void Renderer::SetBlendFunc( BlendingFactor::Type srcFactorRgba, BlendingFactor::Type destFactorRgba )
 143 {
 144   mBlendingOptions.SetBlendFunc( srcFactorRgba, destFactorRgba, srcFactorRgba, destFactorRgba );
 145   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 146 }
 147
 148 void Renderer::SetBlendFunc( BlendingFactor::Type srcFactorRgb,
 149                              BlendingFactor::Type destFactorRgb,
 150                              BlendingFactor::Type srcFactorAlpha,
 151                              BlendingFactor::Type destFactorAlpha )
 152 {
 153   mBlendingOptions.SetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 154   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 155 }
 156
 157 void Renderer::GetBlendFunc( BlendingFactor::Type& srcFactorRgb,
 158                              BlendingFactor::Type& destFactorRgb,
 159                              BlendingFactor::Type& srcFactorAlpha,
 160                              BlendingFactor::Type& destFactorAlpha ) const
 161 {
 162   srcFactorRgb    = mBlendingOptions.GetBlendSrcFactorRgb();
 163   destFactorRgb   = mBlendingOptions.GetBlendDestFactorRgb();
 164   srcFactorAlpha  = mBlendingOptions.GetBlendSrcFactorAlpha();
 165   destFactorAlpha = mBlendingOptions.GetBlendDestFactorAlpha();
 166 }
 167
 168 void Renderer::SetBlendEquation( BlendingEquation::Type equationRgba )
 169 {
 170   mBlendingOptions.SetBlendEquation( equationRgba, equationRgba );
 171   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 172 }
 173
 174 void Renderer::SetBlendEquation( BlendingEquation::Type equationRgb,
 175                                  BlendingEquation::Type equationAlpha )
 176 {
 177   mBlendingOptions.SetBlendEquation( equationRgb, equationAlpha );
 178   SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 179 }
 180
 181 void Renderer::GetBlendEquation( BlendingEquation::Type& equationRgb,
 182                                  BlendingEquation::Type& equationAlpha ) const
 183 {
 184   // These are not animatable, the cached values are up-to-date.
 185   equationRgb   = mBlendingOptions.GetBlendEquationRgb();
 186   equationAlpha = mBlendingOptions.GetBlendEquationAlpha();
 187 }
 188
 189 void Renderer::SetBlendColor( const Vector4& color )
 190 {
 191   if( !mBlendColor )
 192   {
 193     mBlendColor = new Vector4();
 194   }
 195   if( *mBlendColor != color )
 196   {
 197     *mBlendColor = color;
 198     SetBlendColorMessage( GetEventThreadServices(), *mSceneObject, *mBlendColor );
 199   }
 200 }
 201
 202 Vector4 Renderer::GetBlendColor() const
 203 {
 204   if( mBlendColor )
 205   {
 206     return *mBlendColor;
 207   }
 208   return Color::TRANSPARENT; // GL default
 209 }
 210
 211 void Renderer::EnablePreMultipliedAlpha( bool preMultipled )
 212 {
 213   if(  mPremultipledAlphaEnabled != preMultipled )
 214   {
 215     if( preMultipled )
 216     {
 217       SetBlendFunc( BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA, BlendingFactor::ONE, BlendingFactor::ONE );
 218     }
 219     mPremultipledAlphaEnabled = preMultipled;
 220     SetEnablePreMultipliedAlphaMessage( GetEventThreadServices(), *mSceneObject, mPremultipledAlphaEnabled );
 221   }
 222 }
 223
 224 bool Renderer::IsPreMultipliedAlphaEnabled() const
 225 {
 226   return mPremultipledAlphaEnabled;
 227 }
 228
 229 SceneGraph::Renderer* Renderer::GetRendererSceneObject()
 230 {
 231   return mSceneObject;
 232 }
 233
 234 unsigned int Renderer::GetDefaultPropertyCount() const
 235 {
 236   return RENDERER_IMPL.GetDefaultPropertyCount();
 237 }
 238
 239 void Renderer::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
 240 {
 241   RENDERER_IMPL.GetDefaultPropertyIndices( indices );
 242 }
 243
 244 const char* Renderer::GetDefaultPropertyName(Property::Index index) const
 245 {
 246   return RENDERER_IMPL.GetDefaultPropertyName( index );
 247 }
 248
 249 Property::Index Renderer::GetDefaultPropertyIndex( const std::string& name ) const
 250 {
 251   return RENDERER_IMPL.GetDefaultPropertyIndex( name );
 252 }
 253
 254 bool Renderer::IsDefaultPropertyWritable( Property::Index index ) const
 255 {
 256   return RENDERER_IMPL.IsDefaultPropertyWritable( index );
 257 }
 258
 259 bool Renderer::IsDefaultPropertyAnimatable( Property::Index index ) const
 260 {
 261   return RENDERER_IMPL.IsDefaultPropertyAnimatable( index );
 262 }
 263
 264 bool Renderer::IsDefaultPropertyAConstraintInput( Property::Index index ) const
 265 {
 266   return RENDERER_IMPL.IsDefaultPropertyAConstraintInput( index );
 267 }
 268
 269 Property::Type Renderer::GetDefaultPropertyType( Property::Index index ) const
 270 {
 271   return RENDERER_IMPL.GetDefaultPropertyType( index );
 272 }
 273
 274 void Renderer::SetDefaultProperty( Property::Index index,
 275                                    const Property::Value& propertyValue )
 276 {
 277   switch( index )
 278   {
 279     case Dali::Renderer::Property::DEPTH_INDEX:
 280     {
 281       SetDepthIndex( propertyValue.Get<int>() );
 282       break;
 283     }
 284     case Dali::Renderer::Property::FACE_CULLING_MODE:
 285     {
 286       int faceCullingMode;
 287       if( propertyValue.Get( faceCullingMode ) )
 288       {
 289         SetFaceCullingMode( Dali::Renderer::FaceCullingMode( faceCullingMode ) );
 290       }
 291       break;
 292     }
 293     case Dali::Renderer::Property::BLENDING_MODE:
 294     {
 295       int blendingMode;
 296       if( propertyValue.Get( blendingMode ) )
 297       {
 298         SetBlendMode( BlendingMode::Type( blendingMode ) );
 299       }
 300       break;
 301     }
 302     case Dali::Renderer::Property::BLEND_EQUATION_RGB:
 303     {
 304       int blendingEquation;
 305       if( propertyValue.Get( blendingEquation ) )
 306       {
 307         BlendingEquation::Type alphaEquation = mBlendingOptions.GetBlendEquationAlpha();
 308         mBlendingOptions.SetBlendEquation( static_cast<BlendingEquation::Type>( blendingEquation ), alphaEquation );
 309         SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 310       }
 311       break;
 312     }
 313     case Dali::Renderer::Property::BLEND_EQUATION_ALPHA:
 314     {
 315       int blendingEquation;
 316       if( propertyValue.Get( blendingEquation ) )
 317       {
 318         BlendingEquation::Type rgbEquation = mBlendingOptions.GetBlendEquationRgb();
 319         mBlendingOptions.SetBlendEquation( rgbEquation, static_cast<BlendingEquation::Type>( blendingEquation ) );
 320         SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
 321       }
 322       break;
 323     }
 324     case Dali::Renderer::Property::BLENDING_SRC_FACTOR_RGB:
 325     {
 326       int blendingFactor;
 327       if( propertyValue.Get( blendingFactor ) )
 328       {
 329         BlendingFactor::Type srcFactorRgb;
 330         BlendingFactor::Type destFactorRgb;
 331         BlendingFactor::Type srcFactorAlpha;
 332         BlendingFactor::Type destFactorAlpha;
 333         GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 334         SetBlendFunc( static_cast<BlendingFactor::Type>( blendingFactor ),
 335             destFactorRgb,
 336             srcFactorAlpha,
 337             destFactorAlpha );
 338       }
 339       break;
 340     }
 341     case Dali::Renderer::Property::BLENDING_DEST_FACTOR_RGB:
 342     {
 343       int blendingFactor;
 344       if( propertyValue.Get( blendingFactor ) )
 345       {
 346         BlendingFactor::Type srcFactorRgb;
 347         BlendingFactor::Type destFactorRgb;
 348         BlendingFactor::Type srcFactorAlpha;
 349         BlendingFactor::Type destFactorAlpha;
 350         GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 351         SetBlendFunc( srcFactorRgb,
 352             static_cast<BlendingFactor::Type>( blendingFactor ),
 353             srcFactorAlpha,
 354             destFactorAlpha );
 355       }
 356       break;
 357     }
 358     case Dali::Renderer::Property::BLENDING_SRC_FACTOR_ALPHA:
 359     {
 360       int blendingFactor;
 361       if( propertyValue.Get( blendingFactor ) )
 362       {
 363         BlendingFactor::Type srcFactorRgb;
 364         BlendingFactor::Type destFactorRgb;
 365         BlendingFactor::Type srcFactorAlpha;
 366         BlendingFactor::Type destFactorAlpha;
 367         GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 368         SetBlendFunc( srcFactorRgb,
 369             destFactorRgb,
 370             static_cast<BlendingFactor::Type>( blendingFactor ),
 371             destFactorAlpha );
 372       }
 373       break;
 374     }
 375     case Dali::Renderer::Property::BLENDING_DEST_FACTOR_ALPHA:
 376     {
 377       int blendingFactor;
 378       if( propertyValue.Get( blendingFactor ) )
 379       {
 380         BlendingFactor::Type srcFactorRgb;
 381         BlendingFactor::Type destFactorRgb;
 382         BlendingFactor::Type srcFactorAlpha;
 383         BlendingFactor::Type destFactorAlpha;
 384         GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 385         SetBlendFunc( srcFactorRgb,
 386             destFactorRgb,
 387             srcFactorAlpha,
 388             static_cast<BlendingFactor::Type>( blendingFactor ) );
 389       }
 390       break;
 391     }
 392     case Dali::Renderer::Property::BLENDING_COLOR:
 393     {
 394       Vector4 blendColor;
 395       if( propertyValue.Get( blendColor ) )
 396       {
 397         SetBlendColor( blendColor );
 398       }
 399       break;
 400     }
 401     case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA:
 402     {
 403       bool preMultipled;
 404       if( propertyValue.Get( preMultipled ) )
 405       {
 406         EnablePreMultipliedAlpha( preMultipled );
 407       }
 408       break;
 409     }
 410   }
 411 }
 412
 413 void Renderer::SetSceneGraphProperty( Property::Index index,
 414                                       const PropertyMetadata& entry,
 415                                       const Property::Value& value )
 416 {
 417   RENDERER_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value );
 418   OnPropertySet(index, value);
 419 }
 420
 421 Property::Value Renderer::GetDefaultProperty( Property::Index index ) const
 422 {
 423   Property::Value value;
 424   switch( index )
 425   {
 426     case Dali::Renderer::Property::DEPTH_INDEX:
 427     {
 428       value = GetDepthIndex();
 429       break;
 430     }
 431     case Dali::Renderer::Property::FACE_CULLING_MODE:
 432     {
 433       value = mFaceCullingMode;
 434       break;
 435     }
 436     case Dali::Renderer::Property::BLENDING_MODE:
 437     {
 438       value = mBlendingMode;
 439       break;
 440     }
 441     case Dali::Renderer::Property::BLEND_EQUATION_RGB:
 442     {
 443       value = static_cast<int>( mBlendingOptions.GetBlendEquationRgb() );
 444       break;
 445     }
 446     case Dali::Renderer::Property::BLEND_EQUATION_ALPHA:
 447     {
 448       value = static_cast<int>( mBlendingOptions.GetBlendEquationAlpha() );
 449       break;
 450     }
 451     case Dali::Renderer::Property::BLENDING_SRC_FACTOR_RGB:
 452     {
 453       BlendingFactor::Type srcFactorRgb;
 454       BlendingFactor::Type destFactorRgb;
 455       BlendingFactor::Type srcFactorAlpha;
 456       BlendingFactor::Type destFactorAlpha;
 457       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 458       value = static_cast<int>( srcFactorRgb );
 459       break;
 460     }
 461     case Dali::Renderer::Property::BLENDING_DEST_FACTOR_RGB:
 462     {
 463       BlendingFactor::Type srcFactorRgb;
 464       BlendingFactor::Type destFactorRgb;
 465       BlendingFactor::Type srcFactorAlpha;
 466       BlendingFactor::Type destFactorAlpha;
 467       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 468       value = static_cast<int>( destFactorRgb );
 469       break;
 470     }
 471     case Dali::Renderer::Property::BLENDING_SRC_FACTOR_ALPHA:
 472     {
 473       BlendingFactor::Type srcFactorRgb;
 474       BlendingFactor::Type destFactorRgb;
 475       BlendingFactor::Type srcFactorAlpha;
 476       BlendingFactor::Type destFactorAlpha;
 477       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 478       value = static_cast<int>( srcFactorAlpha );
 479       break;
 480     }
 481     case Dali::Renderer::Property::BLENDING_DEST_FACTOR_ALPHA:
 482     {
 483       BlendingFactor::Type srcFactorRgb;
 484       BlendingFactor::Type destFactorRgb;
 485       BlendingFactor::Type srcFactorAlpha;
 486       BlendingFactor::Type destFactorAlpha;
 487       GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 488       value = static_cast<int>( destFactorAlpha );
 489       break;
 490     }
 491     case Dali::Renderer::Property::BLENDING_COLOR:
 492     {
 493       if( mBlendColor )
 494       {
 495         value = *mBlendColor;
 496       }
 497       else
 498       {
 499         value = Color::TRANSPARENT;
 500       }
 501       break;
 502     }
 503     case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA:
 504     {
 505       value = IsPreMultipliedAlphaEnabled();
 506       break;
 507     }
 508   }
 509   return value;
 510 }
 511
 512 const SceneGraph::PropertyOwner* Renderer::GetPropertyOwner() const
 513 {
 514   return mSceneObject;
 515 }
 516
 517 const SceneGraph::PropertyOwner* Renderer::GetSceneObject() const
 518 {
 519   return mSceneObject;
 520 }
 521
 522 const SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty( Property::Index index ) const
 523 {
 524   DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" );
 525   const SceneGraph::PropertyBase* property = NULL;
 526
 527   if( OnStage() )
 528   {
 529     property = RENDERER_IMPL.GetRegisteredSceneGraphProperty(
 530       this,
 531       &Renderer::FindAnimatableProperty,
 532       &Renderer::FindCustomProperty,
 533       index );
 534   }
 535
 536   return property;
 537 }
 538
 539 const PropertyInputImpl* Renderer::GetSceneObjectInputProperty( Property::Index index ) const
 540 {
 541   const PropertyInputImpl* property = NULL;
 542
 543   if( OnStage() )
 544   {
 545     const SceneGraph::PropertyBase* baseProperty =
 546       RENDERER_IMPL.GetRegisteredSceneGraphProperty( this,
 547                                                      &Renderer::FindAnimatableProperty,
 548                                                      &Renderer::FindCustomProperty,
 549                                                      index );
 550     property = static_cast<const PropertyInputImpl*>( baseProperty );
 551   }
 552
 553   return property;
 554 }
 555
 556 int Renderer::GetPropertyComponentIndex( Property::Index index ) const
 557 {
 558   return Property::INVALID_COMPONENT_INDEX;
 559 }
 560
 561 bool Renderer::OnStage() const
 562 {
 563   return mOnStageCount > 0;
 564 }
 565
 566 void Renderer::Connect()
 567 {
 568   if( mOnStageCount == 0 )
 569   {
 570     OnStageConnectMessage( GetEventThreadServices(), *mSceneObject );
 571     mGeometryConnector.OnStageConnect();
 572     mMaterialConnector.OnStageConnect();
 573   }
 574   ++mOnStageCount;
 575 }
 576
 577 void Renderer::Disconnect()
 578 {
 579   --mOnStageCount;
 580   if( mOnStageCount == 0 )
 581   {
 582     OnStageDisconnectMessage( GetEventThreadServices(), *mSceneObject);
 583     mGeometryConnector.OnStageDisconnect();
 584     mMaterialConnector.OnStageDisconnect();
 585   }
 586 }
 587
 588 Renderer::Renderer()
 589 : mSceneObject(NULL),
 590   mBlendColor( NULL ),
 591   mDepthIndex(0),
 592   mOnStageCount(0),
 593   mFaceCullingMode(Dali::Renderer::NONE),
 594   mBlendingMode( Dali::BlendingMode::AUTO ),
 595   mBlendingOptions(),
 596   mPremultipledAlphaEnabled( false )
 597 {
 598 }
 599
 600 void Renderer::Initialize()
 601 {
 602   EventThreadServices& eventThreadServices = GetEventThreadServices();
 603   SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 604
 605   mSceneObject = SceneGraph::Renderer::New();
 606   AddMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject );
 607
 608   eventThreadServices.RegisterObject( this );
 609 }
 610
 611 Renderer::~Renderer()
 612 {
 613   if( EventThreadServices::IsCoreRunning() )
 614   {
 615     EventThreadServices& eventThreadServices = GetEventThreadServices();
 616     SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 617     RemoveMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject );
 618
 619     eventThreadServices.UnregisterObject( this );
 620   }
 621 }
 622
 623 } // namespace Internal
 624 } // namespace Dali