dali/internal/update/rendering/scene-graph-renderer.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 // CLASS HEADER
  18 #include "scene-graph-renderer.h"
  19
  20 // INTERNAL HEADERS
  21 #include <dali/internal/update/controllers/scene-controller.h>
  22 #include <dali/internal/render/renderers/render-geometry.h>
  23 #include <dali/internal/update/controllers/render-message-dispatcher.h>
  24 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
  25 #include <dali/internal/render/shaders/scene-graph-shader.h>
  26 #include <dali/internal/render/renderers/render-renderer.h>
  27 #include <dali/internal/render/data-providers/node-data-provider.h>
  28 #include <dali/internal/update/nodes/node.h>
  29 #include <dali/internal/render/queue/render-queue.h>
  30 #include <dali/internal/common/internal-constants.h>
  31 #include <dali/internal/common/memory-pool-object-allocator.h>
  32
  33
  34 namespace // unnamed namespace
  35 {
  36
  37 const unsigned int UNIFORM_MAP_READY      = 0;
  38 const unsigned int COPY_UNIFORM_MAP       = 1;
  39 const unsigned int REGENERATE_UNIFORM_MAP = 2;
  40
  41 //Memory pool used to allocate new renderers. Memory used by this pool will be released when shutting down DALi
  42 Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Renderer> gRendererMemoryPool;
  43
  44 void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, const Dali::Internal::SceneGraph::UniformMap& uniformMap )
  45 {
  46   // Iterate thru uniformMap.
  47   //   Any maps that aren't in localMap should be added in a single step
  48   Dali::Internal::SceneGraph::CollectedUniformMap newUniformMappings;
  49
  50   for( unsigned int i=0, count=uniformMap.Count(); i<count; ++i )
  51   {
  52     Dali::Internal::SceneGraph::UniformPropertyMapping::Hash nameHash = uniformMap[i].uniformNameHash;
  53     bool found = false;
  54
  55     for( Dali::Internal::SceneGraph::CollectedUniformMap::Iterator iter = localMap.Begin() ; iter != localMap.End() ; ++iter )
  56     {
  57       const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter);
  58       if( map->uniformNameHash == nameHash )
  59       {
  60         if( map->uniformName == uniformMap[i].uniformName )
  61         {
  62           found = true;
  63           break;
  64         }
  65       }
  66     }
  67     if( !found )
  68     {
  69       // it's a new mapping. Add raw ptr to temporary list
  70       newUniformMappings.PushBack( &uniformMap[i] );
  71     }
  72   }
  73
  74   if( newUniformMappings.Count() > 0 )
  75   {
  76     localMap.Reserve( localMap.Count() + newUniformMappings.Count() );
  77
  78     for( Dali::Internal::SceneGraph::CollectedUniformMap::Iterator iter = newUniformMappings.Begin(),
  79            end = newUniformMappings.End() ;
  80          iter != end ;
  81          ++iter )
  82     {
  83       const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter);
  84       localMap.PushBack( map );
  85     }
  86   }
  87 }
  88
  89 // flags for resending data to renderer
  90 enum Flags
  91 {
  92   RESEND_DATA_PROVIDER               = 1,
  93   RESEND_GEOMETRY                    = 1 << 1,
  94   RESEND_FACE_CULLING_MODE           = 1 << 2,
  95   RESEND_BLEND_COLOR                 = 1 << 3,
  96   RESEND_BLEND_BIT_MASK              = 1 << 4,
  97   RESEND_PREMULTIPLIED_ALPHA         = 1 << 5,
  98   RESEND_INDEXED_DRAW_FIRST_ELEMENT  = 1 << 6,
  99   RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 7,
 100   RESEND_DEPTH_WRITE_MODE            = 1 << 8,
 101   RESEND_DEPTH_TEST_MODE             = 1 << 9,
 102   RESEND_DEPTH_FUNCTION              = 1 << 10,
 103 };
 104
 105 }
 106
 107 namespace Dali
 108 {
 109 namespace Internal
 110 {
 111 namespace SceneGraph
 112 {
 113
 114 Renderer* Renderer::New()
 115 {
 116   return new ( gRendererMemoryPool.AllocateRawThreadSafe() ) Renderer();
 117 }
 118
 119 Renderer::Renderer()
 120 : mSceneController( 0 ),
 121   mRenderer( NULL ),
 122   mTextureSet( NULL ),
 123   mGeometry( NULL ),
 124   mShader( NULL ),
 125   mBlendColor( NULL ),
 126   mIndexedDrawFirstElement( 0u ),
 127   mIndexedDrawElementsCount( 0u ),
 128   mBlendBitmask( 0u ),
 129   mRegenerateUniformMap( 0u ),
 130   mResendFlag( 0u ),
 131   mDepthFunction( DepthFunction::LESS ),
 132   mFaceCullingMode( FaceCullingMode::NONE ),
 133   mBlendMode( BlendMode::AUTO ),
 134   mDepthWriteMode( DepthWriteMode::AUTO ),
 135   mDepthTestMode( DepthTestMode::AUTO ),
 136   mResourcesReady( false ),
 137   mFinishedResourceAcquisition( false ),
 138   mPremultipledAlphaEnabled( false ),
 139   mDepthIndex( 0 )
 140 {
 141   mUniformMapChanged[0] = false;
 142   mUniformMapChanged[1] = false;
 143
 144   // Observe our own PropertyOwner's uniform map
 145   AddUniformMapObserver( *this );
 146 }
 147
 148 Renderer::~Renderer()
 149 {
 150   if (mTextureSet)
 151   {
 152     mTextureSet->RemoveObserver(this);
 153     mTextureSet=NULL;
 154   }
 155   if( mShader )
 156   {
 157     mShader->RemoveConnectionObserver(*this);
 158     mShader=NULL;
 159   }
 160 }
 161
 162 void Renderer::operator delete( void* ptr )
 163 {
 164   gRendererMemoryPool.FreeThreadSafe( static_cast<Renderer*>( ptr ) );
 165 }
 166
 167
 168 void Renderer::PrepareRender( BufferIndex updateBufferIndex )
 169 {
 170   mResourcesReady = false;
 171   mFinishedResourceAcquisition = false;
 172
 173   // Can only be considered ready when all the scene graph objects are connected to the renderer
 174   if( mGeometry && mShader )
 175   {
 176     if( mTextureSet )
 177     {
 178       mTextureSet->GetResourcesStatus( mResourcesReady, mFinishedResourceAcquisition );
 179     }
 180     else
 181     {
 182       mResourcesReady = true;
 183       mFinishedResourceAcquisition = true;
 184     }
 185   }
 186
 187   if( mRegenerateUniformMap > UNIFORM_MAP_READY )
 188   {
 189     DALI_ASSERT_DEBUG( mGeometry != NULL && "No geometry available in PrepareRender()" );
 190     DALI_ASSERT_DEBUG( mShader != NULL && "No shader available in PrepareRender()" );
 191
 192     if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
 193     {
 194       CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
 195       localMap.Resize(0);
 196
 197       const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
 198       AddMappings( localMap, rendererUniformMap );
 199
 200       if( mShader )
 201       {
 202         AddMappings( localMap, mShader->GetUniformMap() );
 203       }
 204     }
 205     else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
 206     {
 207       // Copy old map into current map
 208       CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
 209       CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
 210
 211       localMap.Resize( oldMap.Count() );
 212
 213       unsigned int index=0;
 214       for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
 215       {
 216         localMap[index] = *iter;
 217       }
 218     }
 219
 220     mUniformMapChanged[updateBufferIndex] = true;
 221     mRegenerateUniformMap--;
 222   }
 223
 224   if( mResendFlag != 0 )
 225   {
 226     if( mResendFlag & RESEND_DATA_PROVIDER )
 227     {
 228       RenderDataProvider* dataProvider = NewRenderDataProvider();
 229
 230       typedef MessageValue1< Render::Renderer, OwnerPointer<RenderDataProvider> > DerivedType;
 231       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 232       new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider );
 233     }
 234
 235     if( mResendFlag & RESEND_GEOMETRY )
 236     {
 237       typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType;
 238       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 239
 240       new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry );
 241     }
 242
 243     if( mResendFlag & RESEND_FACE_CULLING_MODE )
 244     {
 245       typedef MessageValue1< Render::Renderer, FaceCullingMode::Type > DerivedType;
 246       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 247       new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
 248     }
 249
 250     if( mResendFlag & RESEND_BLEND_BIT_MASK )
 251     {
 252       typedef MessageValue1< Render::Renderer, unsigned int > DerivedType;
 253       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 254       new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
 255     }
 256
 257     if( mResendFlag & RESEND_BLEND_COLOR )
 258     {
 259       typedef MessageValue1< Render::Renderer, const Vector4* > DerivedType;
 260       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 261       new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, mBlendColor );
 262     }
 263
 264     if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA  )
 265     {
 266       typedef MessageValue1< Render::Renderer, bool > DerivedType;
 267       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 268       new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
 269     }
 270
 271     if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT )
 272     {
 273       typedef MessageValue1< Render::Renderer, size_t > DerivedType;
 274       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 275       new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement );
 276     }
 277
 278     if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
 279     {
 280       typedef MessageValue1< Render::Renderer, size_t > DerivedType;
 281       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 282       new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
 283     }
 284
 285     if( mResendFlag & RESEND_DEPTH_WRITE_MODE )
 286     {
 287       typedef MessageValue1< Render::Renderer, DepthWriteMode::Type > DerivedType;
 288       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 289       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode );
 290     }
 291
 292     if( mResendFlag & RESEND_DEPTH_TEST_MODE )
 293     {
 294       typedef MessageValue1< Render::Renderer, DepthTestMode::Type > DerivedType;
 295       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 296       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode );
 297     }
 298
 299     if( mResendFlag & RESEND_DEPTH_FUNCTION )
 300     {
 301       typedef MessageValue1< Render::Renderer, DepthFunction::Type > DerivedType;
 302       unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 303       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction );
 304     }
 305
 306     mResendFlag = 0;
 307   }
 308 }
 309
 310 void Renderer::SetTextures( TextureSet* textureSet )
 311 {
 312   DALI_ASSERT_DEBUG( textureSet != NULL && "Texture set pointer is NULL" );
 313
 314   if( mTextureSet )
 315   {
 316     mTextureSet->RemoveObserver(this);
 317   }
 318
 319   mTextureSet = textureSet;
 320   mTextureSet->AddObserver( this );
 321   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 322   mResendFlag |= RESEND_DATA_PROVIDER;
 323 }
 324
 325 void Renderer::SetShader( Shader* shader )
 326 {
 327   DALI_ASSERT_DEBUG( shader != NULL && "Shader pointer is NULL" );
 328
 329   if( mShader )
 330   {
 331     mShader->RemoveConnectionObserver(*this);
 332   }
 333
 334   mShader = shader;
 335   mShader->AddConnectionObserver( *this );
 336   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 337   mResendFlag |= RESEND_DATA_PROVIDER;
 338 }
 339
 340 void Renderer::SetGeometry( Render::Geometry* geometry )
 341 {
 342   DALI_ASSERT_DEBUG( geometry != NULL && "Geometry pointer is NULL");
 343   mGeometry = geometry;
 344
 345   if( mRenderer )
 346   {
 347     mResendFlag |= RESEND_GEOMETRY;
 348   }
 349 }
 350
 351 void Renderer::SetDepthIndex( int depthIndex )
 352 {
 353   mDepthIndex = depthIndex;
 354 }
 355
 356 void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode )
 357 {
 358   mFaceCullingMode = faceCullingMode;
 359   mResendFlag |= RESEND_FACE_CULLING_MODE;
 360 }
 361
 362 void Renderer::SetBlendMode( BlendMode::Type blendingMode )
 363 {
 364   mBlendMode = blendingMode;
 365 }
 366
 367 void Renderer::SetBlendingOptions( unsigned int options )
 368 {
 369   if( mBlendBitmask != options)
 370   {
 371     mBlendBitmask = options;
 372     mResendFlag |= RESEND_BLEND_BIT_MASK;
 373   }
 374 }
 375
 376 void Renderer::SetBlendColor( const Vector4& blendColor )
 377 {
 378   if( !mBlendColor )
 379   {
 380     mBlendColor = new Vector4( blendColor );
 381   }
 382   else
 383   {
 384     *mBlendColor = blendColor;
 385   }
 386
 387   mResendFlag |= RESEND_BLEND_COLOR;
 388 }
 389
 390 void Renderer::SetIndexedDrawFirstElement( size_t firstElement )
 391 {
 392   mIndexedDrawFirstElement = firstElement;
 393   mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
 394 }
 395
 396 void Renderer::SetIndexedDrawElementsCount( size_t elementsCount )
 397 {
 398   mIndexedDrawElementsCount = elementsCount;
 399   mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
 400 }
 401
 402 void Renderer::EnablePreMultipliedAlpha( bool preMultipled )
 403 {
 404   mPremultipledAlphaEnabled = preMultipled;
 405   mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
 406 }
 407
 408 void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode )
 409 {
 410   mDepthWriteMode = depthWriteMode;
 411   mResendFlag |= RESEND_DEPTH_WRITE_MODE;
 412 }
 413
 414 void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode )
 415 {
 416   mDepthTestMode = depthTestMode;
 417   mResendFlag |= RESEND_DEPTH_TEST_MODE;
 418 }
 419
 420 void Renderer::SetDepthFunction( DepthFunction::Type depthFunction )
 421 {
 422   mDepthFunction = depthFunction;
 423   mResendFlag |= RESEND_DEPTH_FUNCTION;
 424 }
 425
 426 //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created )
 427 void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
 428 {
 429   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 430   mSceneController = &sceneController;
 431   RenderDataProvider* dataProvider = NewRenderDataProvider();
 432
 433   mRenderer = Render::Renderer::New( dataProvider, mGeometry,
 434                                      mBlendBitmask, mBlendColor,
 435                                      static_cast< FaceCullingMode::Type >( mFaceCullingMode ),
 436                                      mPremultipledAlphaEnabled,
 437                                      mDepthWriteMode,
 438                                      mDepthTestMode,
 439                                      mDepthFunction );
 440   mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer );
 441 }
 442
 443 //Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
 444 void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
 445 {
 446   //Remove renderer from RenderManager
 447   if( mRenderer )
 448   {
 449     mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
 450     mRenderer = NULL;
 451   }
 452   mSceneController = NULL;
 453 }
 454
 455 RenderDataProvider* Renderer::NewRenderDataProvider()
 456 {
 457   RenderDataProvider* dataProvider = new RenderDataProvider();
 458
 459   dataProvider->mUniformMapDataProvider = this;
 460   dataProvider->mShader = mShader;
 461
 462   if( mTextureSet )
 463   {
 464     size_t textureCount( mTextureSet->GetTextureCount() );
 465     dataProvider->mTextures.resize( textureCount );
 466     dataProvider->mSamplers.resize( textureCount );
 467     for( unsigned int i(0); i<textureCount; ++i )
 468     {
 469       dataProvider->mTextures[i] = Render::Texture( mTextureSet->GetTextureId(i),0);
 470       dataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i);
 471     }
 472
 473     textureCount = mTextureSet->GetNewTextureCount();
 474     dataProvider->mNewTextures.resize( textureCount );
 475     dataProvider->mSamplers.resize( textureCount );
 476     for( unsigned int i(0); i<textureCount; ++i )
 477     {
 478       dataProvider->mNewTextures[i] = mTextureSet->GetNewTexture(i);
 479       dataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i);
 480     }
 481   }
 482
 483   return dataProvider;
 484 }
 485
 486 Render::Renderer& Renderer::GetRenderer()
 487 {
 488   return *mRenderer;
 489 }
 490
 491 const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) const
 492 {
 493   return mCollectedUniformMap[bufferIndex];
 494 }
 495
 496 void Renderer::GetReadyAndComplete( bool& ready, bool& complete ) const
 497 {
 498   ready = mResourcesReady;
 499   complete = mFinishedResourceAcquisition;
 500 }
 501
 502 Renderer::Opacity Renderer::GetOpacity( BufferIndex updateBufferIndex, const Node& node ) const
 503 {
 504   Renderer::Opacity opacity = Renderer::OPAQUE;
 505
 506   switch( mBlendMode )
 507   {
 508     case BlendMode::ON: // If the renderer should always be use blending
 509     {
 510       opacity = Renderer::TRANSLUCENT;
 511       break;
 512     }
 513     case BlendMode::AUTO:
 514     {
 515       bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT ) );
 516       if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
 517       {
 518         opacity = Renderer::TRANSLUCENT;
 519       }
 520       else // renderer should determine opacity using the actor color
 521       {
 522         float alpha = node.GetWorldColor( updateBufferIndex ).a;
 523         if( alpha <= FULLY_TRANSPARENT )
 524         {
 525           opacity = TRANSPARENT;
 526         }
 527         else if( alpha <= FULLY_OPAQUE )
 528         {
 529           opacity = TRANSLUCENT;
 530         }
 531       }
 532       break;
 533     }
 534     case BlendMode::OFF: // the renderer should never use blending
 535     default:
 536     {
 537       opacity = Renderer::OPAQUE;
 538       break;
 539     }
 540   }
 541
 542
 543   return opacity;
 544 }
 545
 546 void Renderer::TextureSetChanged()
 547 {
 548   mResendFlag |= RESEND_DATA_PROVIDER;
 549 }
 550
 551 void Renderer::ConnectionsChanged( PropertyOwner& object )
 552 {
 553   // One of our child objects has changed it's connections. Ensure the uniform
 554   // map gets regenerated during PrepareRender
 555   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 556
 557   // Ensure the child object pointers get re-sent to the renderer
 558   mResendFlag |= RESEND_DATA_PROVIDER;
 559 }
 560
 561 void Renderer::ConnectedUniformMapChanged()
 562 {
 563   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 564 }
 565
 566 void Renderer::UniformMappingsChanged( const UniformMap& mappings )
 567 {
 568   // The mappings are either from PropertyOwner base class, or the Actor
 569   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 570 }
 571
 572 void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
 573 {
 574   if( reinterpret_cast<PropertyOwner*>(mTextureSet) == &owner )
 575   {
 576     mTextureSet = NULL;
 577   }
 578   else if( reinterpret_cast<PropertyOwner*>(mShader) == &owner )
 579   {
 580     mShader = NULL;
 581   }
 582 }
 583
 584 } // namespace SceneGraph
 585 } // namespace Internal
 586 } // namespace Dali