2 * Copyright (c) 2018 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #pragma GCC diagnostic push
18 #pragma GCC diagnostic ignored "-Wunused-variable"
19 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
20 #pragma GCC diagnostic ignored "-Wunused-function"
23 #include "scene-graph-renderer.h"
26 #include <dali/internal/common/internal-constants.h>
27 #include <dali/internal/common/memory-pool-object-allocator.h>
28 #include <dali/internal/update/nodes/node.h>
29 #include <dali/internal/update/rendering/data-providers/node-data-provider.h>
30 #include <dali/internal/update/rendering/scene-graph-geometry.h>
31 #include <dali/internal/update/rendering/scene-graph-property-buffer.h>
32 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
33 #include <dali/internal/update/rendering/scene-graph-shader.h>
35 #include <dali/graphics-api/graphics-api-controller.h>
36 #include <dali/graphics-api/graphics-api-render-command.h>
37 #include <dali/graphics-api/graphics-api-shader.h>
38 #include <dali/graphics-api/graphics-api-shader-details.h>
47 * Helper to set view and projection matrices once per program
48 * @param program to set the matrices to
49 * @param modelMatrix to set
50 * @param viewMatrix to set
51 * @param projectionMatrix to set
52 * @param modelViewMatrix to set
53 * @param modelViewProjectionMatrix to set
55 inline void SetMatrices(
56 const Dali::Matrix& modelMatrix,
57 const Dali::Matrix& viewMatrix,
58 const Dali::Matrix& projectionMatrix,
59 const Dali::Matrix& modelViewMatrix )
66 namespace // unnamed namespace
69 const unsigned int UNIFORM_MAP_READY = 0;
70 const unsigned int COPY_UNIFORM_MAP = 1;
71 const unsigned int REGENERATE_UNIFORM_MAP = 2;
73 //Memory pool used to allocate new renderers. Memory used by this pool will be released when shutting down DALi
74 Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Renderer> gRendererMemoryPool;
76 void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, const Dali::Internal::SceneGraph::UniformMap& uniformMap )
78 // Iterate thru uniformMap.
79 // Any maps that aren't in localMap should be added in a single step
80 Dali::Internal::SceneGraph::CollectedUniformMap newUniformMappings;
82 for( unsigned int i=0, count=uniformMap.Count(); i<count; ++i )
84 Dali::Internal::SceneGraph::UniformPropertyMapping::Hash nameHash = uniformMap[i].uniformNameHash;
87 for( Dali::Internal::SceneGraph::CollectedUniformMap::Iterator iter = localMap.Begin() ; iter != localMap.End() ; ++iter )
89 const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter);
90 if( map->uniformNameHash == nameHash )
92 if( map->uniformName == uniformMap[i].uniformName )
101 // it's a new mapping. Add raw ptr to temporary list
102 newUniformMappings.PushBack( &uniformMap[i] );
106 if( newUniformMappings.Count() > 0 )
108 localMap.Reserve( localMap.Count() + newUniformMappings.Count() );
110 for( Dali::Internal::SceneGraph::CollectedUniformMap::Iterator iter = newUniformMappings.Begin(),
111 end = newUniformMappings.End() ;
115 const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter);
116 localMap.PushBack( map );
121 // Flags for re-sending data to renderer.
124 RESEND_DATA_PROVIDER = 1 << 0,
125 RESEND_GEOMETRY = 1 << 1,
126 RESEND_FACE_CULLING_MODE = 1 << 2,
127 RESEND_BLEND_COLOR = 1 << 3,
128 RESEND_BLEND_BIT_MASK = 1 << 4,
129 RESEND_PREMULTIPLIED_ALPHA = 1 << 5,
130 RESEND_INDEXED_DRAW_FIRST_ELEMENT = 1 << 6,
131 RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 7,
132 RESEND_DEPTH_WRITE_MODE = 1 << 8,
133 RESEND_DEPTH_TEST_MODE = 1 << 9,
134 RESEND_DEPTH_FUNCTION = 1 << 10,
135 RESEND_RENDER_MODE = 1 << 11,
136 RESEND_STENCIL_FUNCTION = 1 << 12,
137 RESEND_STENCIL_FUNCTION_MASK = 1 << 13,
138 RESEND_STENCIL_FUNCTION_REFERENCE = 1 << 14,
139 RESEND_STENCIL_MASK = 1 << 15,
140 RESEND_STENCIL_OPERATION_ON_FAIL = 1 << 16,
141 RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 17,
142 RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 18,
143 RESEND_WRITE_TO_COLOR_BUFFER = 1 << 19,
146 } // Anonymous namespace
155 Renderer* Renderer::New()
157 return new ( gRendererMemoryPool.AllocateRawThreadSafe() ) Renderer();
161 : mRenderDataProvider(),
166 mStencilParameters( RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP ),
167 mIndexedDrawFirstElement( 0u ),
168 mIndexedDrawElementsCount( 0u ),
170 mRegenerateUniformMap( 0u ),
172 mDepthFunction( DepthFunction::LESS ),
173 mFaceCullingMode( FaceCullingMode::NONE ),
174 mBlendMode( BlendMode::AUTO ),
175 mDepthWriteMode( DepthWriteMode::AUTO ),
176 mDepthTestMode( DepthTestMode::AUTO ),
177 mPremultipledAlphaEnabled( false ),
181 mUniformMapChanged[0] = false;
182 mUniformMapChanged[1] = false;
184 // Observe our own PropertyOwner's uniform map
185 AddUniformMapObserver( *this );
188 Renderer::~Renderer()
192 mTextureSet->RemoveObserver( this );
197 mShader->RemoveConnectionObserver( *this );
202 void Renderer::operator delete( void* ptr )
204 gRendererMemoryPool.FreeThreadSafe( static_cast<Renderer*>( ptr ) );
208 void* AllocateUniformBufferMemory( size_t size )
215 void Renderer::PrepareRender( Graphics::API::Controller& controller, BufferIndex updateBufferIndex )
218 auto gfxShader = mShader->GetGfxObject();
220 if( !mGfxRenderCommand )
222 mGfxRenderCommand = controller.AllocateRenderCommand();
226 * Prepare vertex attribute buffer bindings
228 uint32_t bindingIndex { 0u };
229 uint32_t locationIndex { 0u };
230 auto vertexAttributeBindings = Graphics::API::RenderCommand::NewVertexAttributeBufferBindings();
231 for( auto&& vertexBuffer : mGeometry->GetVertexBuffers() )
233 auto attributeCountInForBuffer = vertexBuffer->GetAttributeCount();
235 // update vertex buffer if necessary
236 vertexBuffer->Update( controller );
238 for( auto i = 0u; i < attributeCountInForBuffer; ++i )
240 // create binding per attribute
241 auto binding = Graphics::API::RenderCommand::VertexAttributeBufferBinding{}
242 .SetOffset( (vertexBuffer->GetFormat()->components[i]).offset )
243 .SetBinding( bindingIndex )
244 .SetBuffer( vertexBuffer->GetGfxObject() )
245 .SetInputAttributeRate( Graphics::API::RenderCommand::InputAttributeRate::PER_VERTEX )
246 .SetLocation( locationIndex + i )
247 .SetStride( vertexBuffer->GetFormat()->size );
248 vertexAttributeBindings.emplace_back( binding );
253 * REGENERATE UNIFORM MAP
255 if( mRegenerateUniformMap > UNIFORM_MAP_READY )
257 if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
259 CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
262 const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
263 AddMappings( localMap, rendererUniformMap );
267 AddMappings( localMap, mShader->GetUniformMap() );
270 else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
272 // Copy old map into current map
273 CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
274 CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
276 localMap.Resize( oldMap.Count() );
278 unsigned int index = 0;
279 for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
281 localMap[index] = *iter;
285 mUniformMapChanged[updateBufferIndex] = true;
286 mRegenerateUniformMap--;
289 auto& shader = mShader->GetGfxObject().Get();
290 auto uboCount = shader.GetUniformBlockCount();
292 auto pushConstantsBindings = Graphics::API::RenderCommand::NewPushConstantsBindings( uboCount );
294 // allocate new command ( may be not necessary at all )
295 // mGfxRenderCommand = Graphics::API::RenderCommandBuilder().Build();
297 // see if we need to reallocate memory for each UBO
298 // todo: do it only when shader has changed
299 if( mUboMemory.size() != uboCount )
301 mUboMemory.resize(uboCount);
304 for( auto i = 0u; i < uboCount; ++i )
306 Graphics::API::ShaderDetails::UniformBlockInfo ubInfo;
308 std::cout<<sizeof(ubInfo) << std::endl;
310 shader.GetUniformBlock( i, ubInfo );
312 if( mUboMemory[i].size() != ubInfo.size )
314 mUboMemory[i].resize( ubInfo.size );
317 // Set push constant bindings
318 auto &pushBinding = pushConstantsBindings[i];
319 pushBinding.data = mUboMemory[i].data();
320 pushBinding.size = uint32_t(mUboMemory[i].size());
321 pushBinding.binding = ubInfo.binding;
324 // add built-in uniforms
327 for( auto&& i : mCollectedUniformMap )
331 auto uniformInfo = Graphics::API::ShaderDetails::UniformInfo{};
332 if( shader.GetNamedUniform( j->uniformName, uniformInfo ) )
334 // write into correct uniform buffer
335 auto dst = (mUboMemory[uniformInfo.bufferIndex].data()+uniformInfo.offset);
336 switch( j->propertyPtr->GetType() )
338 case Property::Type::FLOAT:
339 case Property::Type::INTEGER:
340 case Property::Type::BOOLEAN:
342 std::cout << uniformInfo.name << ":["<<uniformInfo.bufferIndex<<"]: " << "Writing 32bit offset: " << uniformInfo.offset << ", size: " << sizeof(float) << std::endl;
343 memcpy( dst, &j->propertyPtr->GetFloat( updateBufferIndex ), sizeof(float) );
346 case Property::Type::VECTOR2:
348 std::cout << uniformInfo.name << ":["<<uniformInfo.bufferIndex<<"]: " << "Writing vec2 offset: " << uniformInfo.offset << ", size: " << sizeof(Vector2) << std::endl;
349 memcpy( dst, &j->propertyPtr->GetVector2( updateBufferIndex ), sizeof(Vector2) );
352 case Property::Type::VECTOR3:
354 std::cout << uniformInfo.name << ":["<<uniformInfo.bufferIndex<<"]: " << "Writing vec3 offset: " << uniformInfo.offset << ", size: " << sizeof(Vector3) << std::endl;
355 memcpy( dst, &j->propertyPtr->GetVector3( updateBufferIndex ), sizeof(Vector3) );
358 case Property::Type::VECTOR4:
360 std::cout << uniformInfo.name << ":["<<uniformInfo.bufferIndex<<"]: " << "Writing vec4 offset: " << uniformInfo.offset << ", size: " << sizeof(Vector4) << std::endl;
361 memcpy( dst, &j->propertyPtr->GetVector4( updateBufferIndex ), sizeof(Vector4) );
364 case Property::Type::MATRIX:
366 std::cout << uniformInfo.name << ":["<<uniformInfo.bufferIndex<<"]: " << "Writing mat4 offset: " << uniformInfo.offset << ", size: " << sizeof(Matrix) << std::endl;
367 memcpy( dst, &j->propertyPtr->GetMatrix( updateBufferIndex ), sizeof(Matrix) );
370 case Property::Type::MATRIX3:
372 std::cout << uniformInfo.name << ":["<<uniformInfo.bufferIndex<<"]: " << "Writing mat3 offset: " << uniformInfo.offset << ", size: " << sizeof(Matrix3) << std::endl;
373 memcpy( dst, &j->propertyPtr->GetMatrix3( updateBufferIndex ), sizeof(Matrix3) );
386 auto textureBindings = Graphics::API::RenderCommand::NewTextureBindings();
387 auto samplers = shader.GetSamplers();
389 for( auto i = 0u; i < mTextureSet->GetTextureCount(); ++i )
391 auto texture = mTextureSet->GetTexture( i );
392 auto gfxTexture = texture->GetGfxObject();
393 auto binding = Graphics::API::RenderCommand::TextureBinding{}
394 .SetBinding( samplers[i].binding )
395 .SetTexture( texture->GetGfxObject() )
396 .SetSampler( nullptr );
398 textureBindings.emplace_back( binding );
401 // Build render command
402 // todo: this may be deferred until all render items are sorted, otherwise
403 // certain optimisations cannot be done
405 const auto& vb = mGeometry->GetVertexBuffers()[0];
407 mGfxRenderCommand->PushConstants( std::move(pushConstantsBindings) );
408 mGfxRenderCommand->BindVertexBuffers( std::move(vertexAttributeBindings) );
409 mGfxRenderCommand->BindTextures( std::move(textureBindings) );
410 mGfxRenderCommand->BindRenderState( std::move( Graphics::API::RenderCommand::RenderState{}
411 .SetShader( mShader->GetGfxObject() ) ) );
412 mGfxRenderCommand->Draw( std::move(Graphics::API::RenderCommand::DrawCommand{}
414 .SetDrawType( Graphics::API::RenderCommand::DrawType::VERTEX_DRAW )
415 .SetFirstInstance(0u)
416 .SetVertexCount( vb->GetElementCount() )
417 .SetInstanceCount( 1u )));
419 std::cout << "done\n";
422 void Renderer::WriteUniform( const std::string& name, const void* data, uint32_t size )
424 auto& gfxShader = mShader->GetGfxObject().Get();
425 auto uniformInfo = Graphics::API::ShaderDetails::UniformInfo{};
426 if( gfxShader.GetNamedUniform( name, uniformInfo ) )
428 auto dst = (mUboMemory[uniformInfo.bufferIndex].data()+uniformInfo.offset);
429 memcpy( dst, data, size );
433 void Renderer::PrepareRender( BufferIndex updateBufferIndex )
436 if( mRegenerateUniformMap > UNIFORM_MAP_READY )
438 if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
440 CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
443 const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
444 AddMappings( localMap, rendererUniformMap );
448 AddMappings( localMap, mShader->GetUniformMap() );
451 else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
453 // Copy old map into current map
454 CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
455 CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
457 localMap.Resize( oldMap.Count() );
459 unsigned int index=0;
460 for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
462 localMap[index] = *iter;
466 mUniformMapChanged[updateBufferIndex] = true;
467 mRegenerateUniformMap--;
470 if( mResendFlag != 0 )
472 // This used to send messages to obsolete Render::Renderer at this point
477 void Renderer::SetTextures( TextureSet* textureSet )
479 DALI_ASSERT_DEBUG( textureSet != NULL && "Texture set pointer is NULL" );
483 mTextureSet->RemoveObserver(this);
486 mTextureSet = textureSet;
487 mTextureSet->AddObserver( this );
488 mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
489 mResendFlag |= RESEND_DATA_PROVIDER;
492 void Renderer::SetShader( Shader* shader )
494 DALI_ASSERT_DEBUG( shader != NULL && "Shader pointer is NULL" );
498 mShader->RemoveConnectionObserver(*this);
502 mShader->AddConnectionObserver( *this );
503 mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
504 mResendFlag |= RESEND_DATA_PROVIDER;
507 void Renderer::SetGeometry( SceneGraph::Geometry* geometry )
509 DALI_ASSERT_DEBUG( geometry != NULL && "Geometry pointer is NULL");
510 mGeometry = geometry;
513 void Renderer::SetDepthIndex( int depthIndex )
515 mDepthIndex = depthIndex;
518 void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode )
520 mFaceCullingMode = faceCullingMode;
521 mResendFlag |= RESEND_FACE_CULLING_MODE;
524 void Renderer::SetBlendMode( BlendMode::Type blendingMode )
526 mBlendMode = blendingMode;
529 void Renderer::SetBlendingOptions( unsigned int options )
531 if( mBlendBitmask != options)
533 mBlendBitmask = options;
534 mResendFlag |= RESEND_BLEND_BIT_MASK;
538 void Renderer::SetBlendColor( const Vector4& blendColor )
540 if( blendColor == Color::TRANSPARENT )
548 mBlendColor = new Vector4( blendColor );
552 *mBlendColor = blendColor;
556 mResendFlag |= RESEND_BLEND_COLOR;
559 void Renderer::SetIndexedDrawFirstElement( size_t firstElement )
561 mIndexedDrawFirstElement = firstElement;
562 mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
565 void Renderer::SetIndexedDrawElementsCount( size_t elementsCount )
567 mIndexedDrawElementsCount = elementsCount;
568 mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
571 void Renderer::EnablePreMultipliedAlpha( bool preMultipled )
573 mPremultipledAlphaEnabled = preMultipled;
574 mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
577 void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode )
579 mDepthWriteMode = depthWriteMode;
580 mResendFlag |= RESEND_DEPTH_WRITE_MODE;
583 void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode )
585 mDepthTestMode = depthTestMode;
586 mResendFlag |= RESEND_DEPTH_TEST_MODE;
589 void Renderer::SetDepthFunction( DepthFunction::Type depthFunction )
591 mDepthFunction = depthFunction;
592 mResendFlag |= RESEND_DEPTH_FUNCTION;
595 void Renderer::SetRenderMode( RenderMode::Type mode )
597 mStencilParameters.renderMode = mode;
598 mResendFlag |= RESEND_RENDER_MODE;
601 void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction )
603 mStencilParameters.stencilFunction = stencilFunction;
604 mResendFlag |= RESEND_STENCIL_FUNCTION;
607 void Renderer::SetStencilFunctionMask( int stencilFunctionMask )
609 mStencilParameters.stencilFunctionMask = stencilFunctionMask;
610 mResendFlag |= RESEND_STENCIL_FUNCTION_MASK;
613 void Renderer::SetStencilFunctionReference( int stencilFunctionReference )
615 mStencilParameters.stencilFunctionReference = stencilFunctionReference;
616 mResendFlag |= RESEND_STENCIL_FUNCTION_REFERENCE;
619 void Renderer::SetStencilMask( int stencilMask )
621 mStencilParameters.stencilMask = stencilMask;
622 mResendFlag |= RESEND_STENCIL_MASK;
625 void Renderer::SetStencilOperationOnFail( StencilOperation::Type stencilOperationOnFail )
627 mStencilParameters.stencilOperationOnFail = stencilOperationOnFail;
628 mResendFlag |= RESEND_STENCIL_OPERATION_ON_FAIL;
631 void Renderer::SetStencilOperationOnZFail( StencilOperation::Type stencilOperationOnZFail )
633 mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail;
634 mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_FAIL;
637 void Renderer::SetStencilOperationOnZPass( StencilOperation::Type stencilOperationOnZPass )
639 mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass;
640 mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_PASS;
643 //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created )
644 void Renderer::ConnectToSceneGraph( BufferIndex bufferIndex )
646 mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
648 mRenderDataProvider = std::make_unique< RenderDataProvider >();
650 mRenderDataProvider->mUniformMapDataProvider = this;
651 mRenderDataProvider->mShader = mShader;
655 size_t textureCount = mTextureSet->GetTextureCount();
656 mRenderDataProvider->mTextures.resize( textureCount );
657 mRenderDataProvider->mSamplers.resize( textureCount );
658 for( unsigned int i(0); i<textureCount; ++i )
660 mRenderDataProvider->mTextures[i] = mTextureSet->GetTexture(i);
661 mRenderDataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i);
666 //Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
667 void Renderer::DisconnectFromSceneGraph( BufferIndex bufferIndex )
671 const Vector4& Renderer::GetBlendColor() const
677 return Color::TRANSPARENT;
680 const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) const
682 return mCollectedUniformMap[bufferIndex];
685 Renderer::Opacity Renderer::GetOpacity( BufferIndex updateBufferIndex, const Node& node ) const
687 Renderer::Opacity opacity = Renderer::OPAQUE;
691 case BlendMode::ON: // If the renderer should always be use blending
693 opacity = Renderer::TRANSLUCENT;
696 case BlendMode::AUTO:
698 bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT ) );
699 if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
701 opacity = Renderer::TRANSLUCENT;
703 else // renderer should determine opacity using the actor color
705 float alpha = node.GetWorldColor( updateBufferIndex ).a;
706 if( alpha <= FULLY_TRANSPARENT )
708 opacity = TRANSPARENT;
710 else if( alpha <= FULLY_OPAQUE )
712 opacity = TRANSLUCENT;
717 case BlendMode::OFF: // the renderer should never use blending
720 opacity = Renderer::OPAQUE;
728 void Renderer::TextureSetChanged()
730 mResendFlag |= RESEND_DATA_PROVIDER;
733 void Renderer::TextureSetDeleted()
737 mResendFlag |= RESEND_DATA_PROVIDER;
739 void Renderer::ConnectionsChanged( PropertyOwner& object )
741 // One of our child objects has changed it's connections. Ensure the uniform
742 // map gets regenerated during PrepareRender
743 mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
745 // Ensure the child object pointers get re-sent to the renderer
746 mResendFlag |= RESEND_DATA_PROVIDER;
749 void Renderer::ConnectedUniformMapChanged()
751 mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
754 void Renderer::UniformMappingsChanged( const UniformMap& mappings )
756 // The mappings are either from PropertyOwner base class, or the Actor
757 mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
760 void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
762 if( reinterpret_cast<PropertyOwner*>(mShader) == &owner )
768 } // namespace SceneGraph
769 } // namespace Internal
772 #pragma GCC diagnostic pop