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