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 };
 101
 102 }
 103
 104 namespace Dali
 105 {
 106 namespace Internal
 107 {
 108 namespace SceneGraph
 109 {
 110
 111 Renderer* Renderer::New()
 112 {
 113   return new ( gRendererMemoryPool.AllocateRawThreadSafe() ) Renderer();
 114 }
 115
 116 Renderer::Renderer()
 117 :mSceneController( 0 ),
 118  mRenderer( NULL ),
 119  mTextureSet( NULL ),
 120  mGeometry( NULL ),
 121  mShader( NULL ),
 122  mBlendColor( NULL ),
 123  mBlendBitmask( 0u ),
 124  mFaceCullingMode( Dali::Renderer::NONE ),
 125  mBlendingMode( Dali::BlendingMode::AUTO ),
 126  mIndexedDrawFirstElement( 0 ),
 127  mIndexedDrawElementsCount( 0 ),
 128  mReferenceCount( 0 ),
 129  mRegenerateUniformMap( 0 ),
 130  mResendFlag( 0 ),
 131  mResourcesReady( false ),
 132  mFinishedResourceAcquisition( false ),
 133  mDepthIndex( 0 )
 134 {
 135   mUniformMapChanged[0] = false;
 136   mUniformMapChanged[1] = false;
 137
 138   // Observe our own PropertyOwner's uniform map
 139   AddUniformMapObserver( *this );
 140 }
 141
 142 Renderer::~Renderer()
 143 {
 144   if (mTextureSet)
 145   {
 146     mTextureSet->RemoveObserver(this);
 147     mTextureSet=NULL;
 148   }
 149   if( mShader )
 150   {
 151     mShader->RemoveConnectionObserver(*this);
 152     mShader=NULL;
 153   }
 154
 155 }
 156
 157 void Renderer::operator delete( void* ptr )
 158 {
 159   gRendererMemoryPool.FreeThreadSafe( static_cast<Renderer*>( ptr ) );
 160 }
 161
 162
 163 void Renderer::PrepareRender( BufferIndex updateBufferIndex )
 164 {
 165   mResourcesReady = false;
 166   mFinishedResourceAcquisition = false;
 167
 168   // Can only be considered ready when all the scene graph objects are connected to the renderer
 169   if( mGeometry && mShader )
 170   {
 171     if( mTextureSet )
 172     {
 173       mTextureSet->GetResourcesStatus( mResourcesReady, mFinishedResourceAcquisition );
 174     }
 175     else
 176     {
 177       mResourcesReady = true;
 178       mFinishedResourceAcquisition = true;
 179     }
 180   }
 181
 182   if( mRegenerateUniformMap > UNIFORM_MAP_READY )
 183   {
 184     DALI_ASSERT_DEBUG( mGeometry != NULL && "No geometry available in PrepareRender()" );
 185     DALI_ASSERT_DEBUG( mShader != NULL && "No shader available in PrepareRender()" );
 186
 187     if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
 188     {
 189       CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
 190       localMap.Resize(0);
 191
 192       const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
 193       AddMappings( localMap, rendererUniformMap );
 194       AddMappings( localMap, mShader->GetUniformMap() );
 195     }
 196     else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
 197     {
 198       // Copy old map into current map
 199       CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
 200       CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
 201
 202       localMap.Resize( oldMap.Count() );
 203
 204       unsigned int index=0;
 205       for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
 206       {
 207         localMap[index] = *iter;
 208       }
 209     }
 210
 211     mUniformMapChanged[updateBufferIndex] = true;
 212     mRegenerateUniformMap--;
 213   }
 214
 215   if( mResendFlag == 0 )
 216   {
 217     return;
 218   }
 219
 220   if( mResendFlag & RESEND_DATA_PROVIDER )
 221   {
 222     RenderDataProvider* dataProvider = NewRenderDataProvider();
 223
 224     typedef MessageValue1< Render::Renderer, OwnerPointer<RenderDataProvider> > DerivedType;
 225     unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 226     new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider );
 227     mResendFlag &= ~RESEND_DATA_PROVIDER;
 228   }
 229
 230   if( mResendFlag & RESEND_GEOMETRY )
 231   {
 232     typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType;
 233     unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 234
 235     new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry );
 236     mResendFlag &= ~RESEND_GEOMETRY;
 237   }
 238
 239   if( mResendFlag & RESEND_FACE_CULLING_MODE )
 240   {
 241     typedef MessageValue1< Render::Renderer, Dali::Renderer::FaceCullingMode > DerivedType;
 242     unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 243     new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
 244     mResendFlag &= ~RESEND_FACE_CULLING_MODE;
 245   }
 246
 247   if( mResendFlag & RESEND_BLEND_BIT_MASK )
 248   {
 249     typedef MessageValue1< Render::Renderer, unsigned int > DerivedType;
 250     unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 251     new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
 252     mResendFlag &= ~RESEND_BLEND_BIT_MASK;
 253   }
 254
 255   if( mResendFlag & RESEND_BLEND_COLOR )
 256   {
 257     typedef MessageValue1< Render::Renderer, const Vector4* > DerivedType;
 258     unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 259     new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, mBlendColor );
 260     mResendFlag &= ~RESEND_BLEND_COLOR;
 261   }
 262
 263   if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA  )
 264   {
 265     typedef MessageValue1< Render::Renderer, bool > DerivedType;
 266     unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 267     new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
 268     mResendFlag &= ~RESEND_PREMULTIPLIED_ALPHA;
 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     mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT;
 277   }
 278
 279   if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
 280   {
 281     typedef MessageValue1< Render::Renderer, size_t > DerivedType;
 282     unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
 283     new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
 284     mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT;
 285   }
 286 }
 287
 288 void Renderer::SetTextures( TextureSet* textureSet )
 289 {
 290   DALI_ASSERT_DEBUG( textureSet != NULL && "Texture set pointer is NULL" );
 291
 292   if( mTextureSet )
 293   {
 294     mTextureSet->RemoveObserver(this);
 295   }
 296
 297   mTextureSet = textureSet;
 298   mTextureSet->AddObserver( this );
 299   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 300   mResendFlag |= RESEND_DATA_PROVIDER;
 301 }
 302
 303 void Renderer::SetShader( Shader* shader )
 304 {
 305   DALI_ASSERT_DEBUG( shader != NULL && "Shader pointer is NULL" );
 306
 307   if( mShader )
 308   {
 309     mShader->RemoveConnectionObserver(*this);
 310   }
 311
 312   mShader = shader;
 313   mShader->AddConnectionObserver( *this );
 314   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 315   mResendFlag |= RESEND_DATA_PROVIDER;
 316 }
 317
 318 void Renderer::SetGeometry( Render::Geometry* geometry )
 319 {
 320   DALI_ASSERT_DEBUG( geometry != NULL && "Geometry pointer is NULL");
 321   mGeometry = geometry;
 322
 323   if( mRenderer )
 324   {
 325     mResendFlag |= RESEND_GEOMETRY;
 326   }
 327 }
 328
 329 void Renderer::SetDepthIndex( int depthIndex )
 330 {
 331   mDepthIndex = depthIndex;
 332 }
 333
 334 void Renderer::SetFaceCullingMode( unsigned int faceCullingMode )
 335 {
 336   mFaceCullingMode = static_cast<Dali::Renderer::FaceCullingMode>(faceCullingMode);
 337   mResendFlag |= RESEND_FACE_CULLING_MODE;
 338 }
 339
 340 void Renderer::SetBlendingMode( unsigned int blendingMode )
 341 {
 342   mBlendingMode = static_cast< BlendingMode::Type >( blendingMode );
 343 }
 344
 345 void Renderer::SetBlendingOptions( unsigned int options )
 346 {
 347   if( mBlendBitmask != options)
 348   {
 349     mBlendBitmask = options;
 350     mResendFlag |= RESEND_BLEND_BIT_MASK;
 351   }
 352 }
 353
 354 void Renderer::SetBlendColor( const Vector4& blendColor )
 355 {
 356   if( !mBlendColor )
 357   {
 358     mBlendColor = new Vector4( blendColor );
 359   }
 360   else
 361   {
 362     *mBlendColor = blendColor;
 363   }
 364
 365   mResendFlag |= RESEND_BLEND_COLOR;
 366 }
 367
 368 void Renderer::SetIndexedDrawFirstElement( size_t firstElement )
 369 {
 370   mIndexedDrawFirstElement = firstElement;
 371   mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
 372 }
 373
 374 void Renderer::SetIndexedDrawElementsCount( size_t elementsCount )
 375 {
 376   mIndexedDrawElementsCount = elementsCount;
 377   mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
 378 }
 379
 380 void Renderer::EnablePreMultipliedAlpha( bool preMultipled )
 381 {
 382   mPremultipledAlphaEnabled = preMultipled;
 383   mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
 384 }
 385
 386 //Called when a node with this renderer is added to the stage
 387 void Renderer::OnStageConnect()
 388 {
 389   ++mReferenceCount;
 390   if( !mRenderer)
 391   {
 392     RenderDataProvider* dataProvider = NewRenderDataProvider();
 393
 394     mRenderer = Render::Renderer::New( dataProvider, mGeometry,
 395                                        mBlendBitmask, mBlendColor,
 396                                        static_cast< Dali::Renderer::FaceCullingMode >( mFaceCullingMode ),
 397                                        mPremultipledAlphaEnabled );
 398     mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer );
 399     mResendFlag = 0;
 400   }
 401 }
 402
 403 //Called when the node with this renderer has gone out of the stage
 404 void Renderer::OnStageDisconnect()
 405 {
 406   --mReferenceCount;
 407   if( mReferenceCount == 0 )
 408   {
 409     mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
 410     mRenderer = NULL;
 411   }
 412 }
 413
 414 //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created )
 415 void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
 416 {
 417   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 418   mSceneController = &sceneController;
 419 }
 420
 421
 422 //Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
 423 void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
 424 {
 425   //Remove renderer from RenderManager
 426   if( mRenderer )
 427   {
 428     mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
 429     mRenderer = NULL;
 430     mSceneController = NULL;
 431   }
 432 }
 433
 434 RenderDataProvider* Renderer::NewRenderDataProvider()
 435 {
 436   RenderDataProvider* dataProvider = new RenderDataProvider();
 437
 438   dataProvider->mUniformMapDataProvider = this;
 439   dataProvider->mShader = mShader;
 440
 441   if( mTextureSet )
 442   {
 443     size_t textureCount( mTextureSet->GetTextureCount() );
 444     dataProvider->mTextures.resize( textureCount );
 445     for( unsigned int i(0); i<textureCount; ++i )
 446     {
 447       dataProvider->mTextures[i] = Render::Texture( mTextureSet->GetTextureId(i),
 448                                                     mTextureSet->GetTextureSampler(i));
 449     }
 450   }
 451
 452   return dataProvider;
 453 }
 454
 455 Render::Renderer& Renderer::GetRenderer()
 456 {
 457   return *mRenderer;
 458 }
 459
 460 const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) const
 461 {
 462   return mCollectedUniformMap[bufferIndex];
 463 };
 464
 465 void Renderer::GetReadyAndComplete( bool& ready, bool& complete ) const
 466 {
 467   ready = mResourcesReady;
 468   complete = mFinishedResourceAcquisition;
 469 }
 470
 471 Renderer::Opacity Renderer::GetOpacity( BufferIndex updateBufferIndex, const Node& node ) const
 472 {
 473   Renderer::Opacity opacity = Renderer::OPAQUE;
 474
 475   switch( mBlendingMode )
 476   {
 477     case BlendingMode::ON: // If the renderer should always be use blending
 478     {
 479       opacity = Renderer::TRANSLUCENT;
 480       break;
 481     }
 482     case BlendingMode::AUTO:
 483     {
 484       bool shaderRequiresBlending( mShader->GeometryHintEnabled( Dali::ShaderEffect::HINT_BLENDING ) );
 485       if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
 486       {
 487         opacity = Renderer::TRANSLUCENT;
 488       }
 489       else // renderer should determine opacity using the actor color
 490       {
 491         float alpha = node.GetWorldColor( updateBufferIndex ).a;
 492         if( alpha <= FULLY_TRANSPARENT )
 493         {
 494           opacity = TRANSPARENT;
 495         }
 496         else if( alpha <= FULLY_OPAQUE )
 497         {
 498           opacity = TRANSLUCENT;
 499         }
 500       }
 501       break;
 502     }
 503     case BlendingMode::OFF: // the renderer should never use blending
 504     default:
 505     {
 506       opacity = Renderer::OPAQUE;
 507       break;
 508     }
 509   }
 510
 511
 512   return opacity;
 513 }
 514
 515 void Renderer::TextureSetChanged()
 516 {
 517   mResendFlag |= RESEND_DATA_PROVIDER;
 518 }
 519
 520 void Renderer::ConnectionsChanged( PropertyOwner& object )
 521 {
 522   // One of our child objects has changed it's connections. Ensure the uniform
 523   // map gets regenerated during PrepareRender
 524   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 525
 526   // Ensure the child object pointers get re-sent to the renderer
 527   mResendFlag |= RESEND_DATA_PROVIDER;
 528 }
 529
 530 void Renderer::ConnectedUniformMapChanged()
 531 {
 532   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 533 }
 534
 535 void Renderer::UniformMappingsChanged( const UniformMap& mappings )
 536 {
 537   // The mappings are either from PropertyOwner base class, or the Actor
 538   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 539 }
 540
 541 void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
 542 {
 543   if( reinterpret_cast<PropertyOwner*>(mTextureSet) == &owner )
 544   {
 545     mTextureSet = NULL;
 546   }
 547   else if( reinterpret_cast<PropertyOwner*>(mShader) == &owner )
 548   {
 549     mShader = NULL;
 550   }
 551 }
 552
 553 } // namespace SceneGraph
 554 } // namespace Internal
 555 } // namespace Dali