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