X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Frendering%2Fscene-graph-renderer.cpp;h=d42e96090e167639ad301f73ca14d9b9e0a05d81;hb=b43741a90b40ca9dfbd33d6a9d390d3c09230e89;hp=243635fecba5f7c4dad951602103dd1f2ae82194;hpb=e72a3bcda27e5c2af336b1c7cf4a6d5090720e11;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp old mode 100644 new mode 100755 index 243635f..d42e960 --- a/dali/internal/update/rendering/scene-graph-renderer.cpp +++ b/dali/internal/update/rendering/scene-graph-renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * Copyright (c) 2018 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -30,30 +30,36 @@ #include #include +namespace Dali +{ +namespace Internal +{ +namespace SceneGraph +{ namespace // unnamed namespace { -const unsigned int UNIFORM_MAP_READY = 0; -const unsigned int COPY_UNIFORM_MAP = 1; -const unsigned int REGENERATE_UNIFORM_MAP = 2; +const uint32_t UNIFORM_MAP_READY = 0; +const uint32_t COPY_UNIFORM_MAP = 1; +const uint32_t REGENERATE_UNIFORM_MAP = 2; //Memory pool used to allocate new renderers. Memory used by this pool will be released when shutting down DALi -Dali::Internal::MemoryPoolObjectAllocator gRendererMemoryPool; +MemoryPoolObjectAllocator gRendererMemoryPool; -void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, const Dali::Internal::SceneGraph::UniformMap& uniformMap ) +void AddMappings( CollectedUniformMap& localMap, const UniformMap& uniformMap ) { // Iterate thru uniformMap. // Any maps that aren't in localMap should be added in a single step - Dali::Internal::SceneGraph::CollectedUniformMap newUniformMappings; + CollectedUniformMap newUniformMappings; - for( unsigned int i=0, count=uniformMap.Count(); iuniformNameHash == nameHash ) { if( map->uniformName == uniformMap[i].uniformName ) @@ -74,12 +80,12 @@ void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, con { localMap.Reserve( localMap.Count() + newUniformMappings.Count() ); - for( Dali::Internal::SceneGraph::CollectedUniformMap::Iterator iter = newUniformMappings.Begin(), + for( CollectedUniformMap::Iterator iter = newUniformMappings.Begin(), end = newUniformMappings.End() ; iter != end ; ++iter ) { - const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter); + const UniformPropertyMapping* map = (*iter); localMap.PushBack( map ); } } @@ -88,37 +94,29 @@ void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, con // Flags for re-sending data to renderer. enum Flags { - RESEND_DATA_PROVIDER = 1 << 0, - RESEND_GEOMETRY = 1 << 1, - RESEND_FACE_CULLING_MODE = 1 << 2, - RESEND_BLEND_COLOR = 1 << 3, - RESEND_BLEND_BIT_MASK = 1 << 4, - RESEND_PREMULTIPLIED_ALPHA = 1 << 5, - RESEND_INDEXED_DRAW_FIRST_ELEMENT = 1 << 6, - RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 7, - RESEND_DEPTH_WRITE_MODE = 1 << 8, - RESEND_DEPTH_TEST_MODE = 1 << 9, - RESEND_DEPTH_FUNCTION = 1 << 10, - RESEND_RENDER_MODE = 1 << 11, - RESEND_STENCIL_FUNCTION = 1 << 12, - RESEND_STENCIL_FUNCTION_MASK = 1 << 13, - RESEND_STENCIL_FUNCTION_REFERENCE = 1 << 14, - RESEND_STENCIL_MASK = 1 << 15, - RESEND_STENCIL_OPERATION_ON_FAIL = 1 << 16, - RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 17, - RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 18, - RESEND_WRITE_TO_COLOR_BUFFER = 1 << 19, + RESEND_GEOMETRY = 1 << 0, + RESEND_FACE_CULLING_MODE = 1 << 1, + RESEND_BLEND_COLOR = 1 << 2, + RESEND_BLEND_BIT_MASK = 1 << 3, + RESEND_PREMULTIPLIED_ALPHA = 1 << 4, + RESEND_INDEXED_DRAW_FIRST_ELEMENT = 1 << 5, + RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 6, + RESEND_DEPTH_WRITE_MODE = 1 << 7, + RESEND_DEPTH_TEST_MODE = 1 << 8, + RESEND_DEPTH_FUNCTION = 1 << 9, + RESEND_RENDER_MODE = 1 << 10, + RESEND_STENCIL_FUNCTION = 1 << 11, + RESEND_STENCIL_FUNCTION_MASK = 1 << 12, + RESEND_STENCIL_FUNCTION_REFERENCE = 1 << 13, + RESEND_STENCIL_MASK = 1 << 14, + RESEND_STENCIL_OPERATION_ON_FAIL = 1 << 15, + RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 16, + RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 17, + RESEND_WRITE_TO_COLOR_BUFFER = 1 << 18 }; } // Anonymous namespace -namespace Dali -{ -namespace Internal -{ -namespace SceneGraph -{ - Renderer* Renderer::New() { return new ( gRendererMemoryPool.AllocateRawThreadSafe() ) Renderer(); @@ -130,6 +128,7 @@ Renderer::Renderer() mTextureSet( NULL ), mGeometry( NULL ), mShader( NULL ), + mRenderDataProvider( NULL ), mBlendColor( NULL ), mStencilParameters( RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP ), mIndexedDrawFirstElement( 0u ), @@ -142,9 +141,10 @@ Renderer::Renderer() mBlendMode( BlendMode::AUTO ), mDepthWriteMode( DepthWriteMode::AUTO ), mDepthTestMode( DepthTestMode::AUTO ), - mResourcesReady( false ), - mFinishedResourceAcquisition( false ), + mRenderingBehavior( DevelRenderer::Rendering::IF_REQUIRED ), mPremultipledAlphaEnabled( false ), + mDirty( false ), + mOpacity( 1.0f ), mDepthIndex( 0 ) { mUniformMapChanged[0] = false; @@ -176,21 +176,14 @@ void Renderer::operator delete( void* ptr ) void Renderer::PrepareRender( BufferIndex updateBufferIndex ) { - mResourcesReady = false; - mFinishedResourceAcquisition = false; - - // Can only be considered ready when all the scene graph objects are connected to the renderer - if( mGeometry && mShader ) + SetDirty( false ); + if( mRegenerateUniformMap == UNIFORM_MAP_READY ) { - mResourcesReady = true; - mFinishedResourceAcquisition = true; + mUniformMapChanged[updateBufferIndex] = false; } - - if( mRegenerateUniformMap > UNIFORM_MAP_READY ) + else { - DALI_ASSERT_DEBUG( mGeometry != NULL && "No geometry available in PrepareRender()" ); - DALI_ASSERT_DEBUG( mShader != NULL && "No shader available in PrepareRender()" ); - + mDirty = true; if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP) { CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ]; @@ -212,7 +205,7 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex ) localMap.Resize( oldMap.Count() ); - unsigned int index=0; + uint32_t index=0; for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index ) { localMap[index] = *iter; @@ -225,139 +218,130 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex ) if( mResendFlag != 0 ) { - if( mResendFlag & RESEND_DATA_PROVIDER ) - { - RenderDataProvider* dataProvider = NewRenderDataProvider(); - - typedef MessageValue1< Render::Renderer, OwnerPointer > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider ); - } - + mDirty = true; if( mResendFlag & RESEND_GEOMETRY ) { typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry ); } if( mResendFlag & RESEND_FACE_CULLING_MODE ) { typedef MessageValue1< Render::Renderer, FaceCullingMode::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode ); } if( mResendFlag & RESEND_BLEND_BIT_MASK ) { - typedef MessageValue1< Render::Renderer, unsigned int > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + typedef MessageValue1< Render::Renderer, uint32_t > DerivedType; + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask ); } if( mResendFlag & RESEND_BLEND_COLOR ) { - typedef MessageValue1< Render::Renderer, const Vector4* > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, mBlendColor ); + typedef MessageValue1< Render::Renderer, Vector4 > DerivedType; + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, GetBlendColor() ); } if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA ) { typedef MessageValue1< Render::Renderer, bool > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled ); } if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT ) { - typedef MessageValue1< Render::Renderer, size_t > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + typedef MessageValue1< Render::Renderer, uint32_t > DerivedType; + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement ); } if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT ) { - typedef MessageValue1< Render::Renderer, size_t > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + typedef MessageValue1< Render::Renderer, uint32_t > DerivedType; + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount ); } if( mResendFlag & RESEND_DEPTH_WRITE_MODE ) { typedef MessageValue1< Render::Renderer, DepthWriteMode::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode ); } if( mResendFlag & RESEND_DEPTH_TEST_MODE ) { typedef MessageValue1< Render::Renderer, DepthTestMode::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode ); } if( mResendFlag & RESEND_DEPTH_FUNCTION ) { typedef MessageValue1< Render::Renderer, DepthFunction::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction ); } if( mResendFlag & RESEND_RENDER_MODE ) { typedef MessageValue1< Render::Renderer, RenderMode::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode ); } if( mResendFlag & RESEND_STENCIL_FUNCTION ) { typedef MessageValue1< Render::Renderer, StencilFunction::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction ); } if( mResendFlag & RESEND_STENCIL_FUNCTION_MASK ) { typedef MessageValue1< Render::Renderer, int > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask ); } if( mResendFlag & RESEND_STENCIL_FUNCTION_REFERENCE ) { typedef MessageValue1< Render::Renderer, int > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference ); } if( mResendFlag & RESEND_STENCIL_MASK ) { typedef MessageValue1< Render::Renderer, int > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask ); } if( mResendFlag & RESEND_STENCIL_OPERATION_ON_FAIL ) { typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail ); } if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_FAIL ) { typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail ); } if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_PASS ) { typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass ); } @@ -377,7 +361,8 @@ void Renderer::SetTextures( TextureSet* textureSet ) mTextureSet = textureSet; mTextureSet->AddObserver( this ); mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; - mResendFlag |= RESEND_DATA_PROVIDER; + + UpdateTextureSet(); } void Renderer::SetShader( Shader* shader ) @@ -392,7 +377,12 @@ void Renderer::SetShader( Shader* shader ) mShader = shader; mShader->AddConnectionObserver( *this ); mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; - mResendFlag |= RESEND_DATA_PROVIDER; + mResendFlag |= RESEND_GEOMETRY; + + if( mRenderDataProvider ) + { + mRenderDataProvider->mShader = mShader; + } } void Renderer::SetGeometry( Render::Geometry* geometry ) @@ -409,6 +399,7 @@ void Renderer::SetGeometry( Render::Geometry* geometry ) void Renderer::SetDepthIndex( int depthIndex ) { mDepthIndex = depthIndex; + mDirty = true; } void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode ) @@ -417,12 +408,23 @@ void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode ) mResendFlag |= RESEND_FACE_CULLING_MODE; } +FaceCullingMode::Type Renderer::GetFaceCullingMode() const +{ + return mFaceCullingMode; +} + void Renderer::SetBlendMode( BlendMode::Type blendingMode ) { mBlendMode = blendingMode; + mDirty = true; +} + +BlendMode::Type Renderer::GetBlendMode() const +{ + return mBlendMode; } -void Renderer::SetBlendingOptions( unsigned int options ) +void Renderer::SetBlendingOptions( uint32_t options ) { if( mBlendBitmask != options) { @@ -431,56 +433,107 @@ void Renderer::SetBlendingOptions( unsigned int options ) } } +uint32_t Renderer::GetBlendingOptions() const +{ + return mBlendBitmask; +} + void Renderer::SetBlendColor( const Vector4& blendColor ) { - if( !mBlendColor ) + if( blendColor == Color::TRANSPARENT ) { - mBlendColor = new Vector4( blendColor ); + mBlendColor = NULL; } else { - *mBlendColor = blendColor; + if( !mBlendColor ) + { + mBlendColor = new Vector4( blendColor ); + } + else + { + *mBlendColor = blendColor; + } } mResendFlag |= RESEND_BLEND_COLOR; } -void Renderer::SetIndexedDrawFirstElement( size_t firstElement ) +Vector4 Renderer::GetBlendColor() const +{ + if( mBlendColor ) + { + return *mBlendColor; + } + return Color::TRANSPARENT; +} + +void Renderer::SetIndexedDrawFirstElement( uint32_t firstElement ) { mIndexedDrawFirstElement = firstElement; mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT; } -void Renderer::SetIndexedDrawElementsCount( size_t elementsCount ) +uint32_t Renderer::GetIndexedDrawFirstElement() const +{ + return mIndexedDrawFirstElement; +} + +void Renderer::SetIndexedDrawElementsCount( uint32_t elementsCount ) { mIndexedDrawElementsCount = elementsCount; mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT; } +uint32_t Renderer::GetIndexedDrawElementsCount() const +{ + return mIndexedDrawElementsCount; +} + void Renderer::EnablePreMultipliedAlpha( bool preMultipled ) { mPremultipledAlphaEnabled = preMultipled; mResendFlag |= RESEND_PREMULTIPLIED_ALPHA; } +bool Renderer::IsPreMultipliedAlphaEnabled() const +{ + return mPremultipledAlphaEnabled; +} + void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode ) { mDepthWriteMode = depthWriteMode; mResendFlag |= RESEND_DEPTH_WRITE_MODE; } +DepthWriteMode::Type Renderer::GetDepthWriteMode() const +{ + return mDepthWriteMode; +} + void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode ) { mDepthTestMode = depthTestMode; mResendFlag |= RESEND_DEPTH_TEST_MODE; } +DepthTestMode::Type Renderer::GetDepthTestMode() const +{ + return mDepthTestMode; +} + void Renderer::SetDepthFunction( DepthFunction::Type depthFunction ) { mDepthFunction = depthFunction; mResendFlag |= RESEND_DEPTH_FUNCTION; } +DepthFunction::Type Renderer::GetDepthFunction() const +{ + return mDepthFunction; +} + void Renderer::SetRenderMode( RenderMode::Type mode ) { mStencilParameters.renderMode = mode; @@ -529,17 +582,46 @@ void Renderer::SetStencilOperationOnZPass( StencilOperation::Type stencilOperati mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_PASS; } +const Render::Renderer::StencilParameters& Renderer::GetStencilParameters() const +{ + return mStencilParameters; +} + +void Renderer::BakeOpacity( BufferIndex updateBufferIndex, float opacity ) +{ + mDirty = true; + mOpacity.Bake( updateBufferIndex, opacity ); +} + +float Renderer::GetOpacity( BufferIndex updateBufferIndex ) const +{ + return mOpacity[updateBufferIndex]; +} + +void Renderer::SetRenderingBehavior( DevelRenderer::Rendering::Type renderingBehavior ) +{ + mRenderingBehavior = renderingBehavior; + mDirty = true; +} + +DevelRenderer::Rendering::Type Renderer::GetRenderingBehavior() const +{ + return mRenderingBehavior; +} + //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created ) void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex ) { mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; mSceneController = &sceneController; - RenderDataProvider* dataProvider = NewRenderDataProvider(); - mRenderer = Render::Renderer::New( dataProvider, mGeometry, mBlendBitmask, mBlendColor, static_cast< FaceCullingMode::Type >( mFaceCullingMode ), - mPremultipledAlphaEnabled, mDepthWriteMode, mDepthTestMode, mDepthFunction, mStencilParameters ); + mRenderDataProvider = new RenderDataProvider( mOpacity ); + mRenderDataProvider->mUniformMapDataProvider = this; - mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer ); + mRenderer = Render::Renderer::New( mRenderDataProvider, mGeometry, mBlendBitmask, GetBlendColor(), static_cast< FaceCullingMode::Type >( mFaceCullingMode ), + mPremultipledAlphaEnabled, mDepthWriteMode, mDepthTestMode, mDepthFunction, mStencilParameters ); + OwnerPointer< Render::Renderer > transferOwnership( mRenderer ); + mSceneController->GetRenderMessageDispatcher().AddRenderer( transferOwnership ); } //Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced ) @@ -552,28 +634,31 @@ void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, Buffe mRenderer = NULL; } mSceneController = NULL; + mRenderDataProvider = NULL; } -RenderDataProvider* Renderer::NewRenderDataProvider() +void Renderer::UpdateTextureSet() { - RenderDataProvider* dataProvider = new RenderDataProvider(); - - dataProvider->mUniformMapDataProvider = this; - dataProvider->mShader = mShader; - - if( mTextureSet ) + if( mRenderDataProvider ) { - size_t textureCount = mTextureSet->GetTextureCount(); - dataProvider->mTextures.resize( textureCount ); - dataProvider->mSamplers.resize( textureCount ); - for( unsigned int i(0); iGetTextureCount(); + mRenderDataProvider->mTextures.resize( textureCount ); + mRenderDataProvider->mSamplers.resize( textureCount ); + for( uint32_t i = 0; imTextures[i] = mTextureSet->GetTexture(i); + mRenderDataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i); + } + } + else { - dataProvider->mTextures[i] = mTextureSet->GetTexture(i); - dataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i); + mRenderDataProvider->mTextures.clear(); + mRenderDataProvider->mSamplers.clear(); } + mDirty = true; } - - return dataProvider; } Render::Renderer& Renderer::GetRenderer() @@ -586,21 +671,23 @@ const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) co return mCollectedUniformMap[bufferIndex]; } -void Renderer::GetReadyAndComplete( bool& ready, bool& complete ) const -{ - ready = mResourcesReady; - complete = mFinishedResourceAcquisition; -} - -Renderer::Opacity Renderer::GetOpacity( BufferIndex updateBufferIndex, const Node& node ) const +Renderer::OpacityType Renderer::GetOpacityType( BufferIndex updateBufferIndex, const Node& node ) const { - Renderer::Opacity opacity = Renderer::OPAQUE; + Renderer::OpacityType opacityType = Renderer::OPAQUE; switch( mBlendMode ) { case BlendMode::ON: // If the renderer should always be use blending { - opacity = Renderer::TRANSLUCENT; + float alpha = node.GetWorldColor( updateBufferIndex ).a * mOpacity[updateBufferIndex]; + if( alpha <= FULLY_TRANSPARENT ) + { + opacityType = Renderer::TRANSPARENT; + } + else + { + opacityType = Renderer::TRANSLUCENT; + } break; } case BlendMode::AUTO: @@ -608,36 +695,46 @@ Renderer::Opacity Renderer::GetOpacity( BufferIndex updateBufferIndex, const Nod bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT ) ); if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) ) { - opacity = Renderer::TRANSLUCENT; + opacityType = Renderer::TRANSLUCENT; } - else // renderer should determine opacity using the actor color + + // renderer should determine opacity using the actor color + float alpha = node.GetWorldColor( updateBufferIndex ).a * mOpacity[updateBufferIndex]; + if( alpha <= FULLY_TRANSPARENT ) { - float alpha = node.GetWorldColor( updateBufferIndex ).a; - if( alpha <= FULLY_TRANSPARENT ) - { - opacity = TRANSPARENT; - } - else if( alpha <= FULLY_OPAQUE ) - { - opacity = TRANSLUCENT; - } + opacityType = Renderer::TRANSPARENT; + } + else if( alpha <= FULLY_OPAQUE ) + { + opacityType = Renderer::TRANSLUCENT; } break; } case BlendMode::OFF: // the renderer should never use blending default: { - opacity = Renderer::OPAQUE; + opacityType = Renderer::OPAQUE; break; } } - return opacity; + return opacityType; } void Renderer::TextureSetChanged() { - mResendFlag |= RESEND_DATA_PROVIDER; + mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; + + UpdateTextureSet(); +} + +void Renderer::TextureSetDeleted() +{ + mTextureSet = NULL; + + mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; + + UpdateTextureSet(); } void Renderer::ConnectionsChanged( PropertyOwner& object ) @@ -645,9 +742,6 @@ void Renderer::ConnectionsChanged( PropertyOwner& object ) // One of our child objects has changed it's connections. Ensure the uniform // map gets regenerated during PrepareRender mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; - - // Ensure the child object pointers get re-sent to the renderer - mResendFlag |= RESEND_DATA_PROVIDER; } void Renderer::ConnectedUniformMapChanged() @@ -663,14 +757,50 @@ void Renderer::UniformMappingsChanged( const UniformMap& mappings ) void Renderer::ObservedObjectDestroyed(PropertyOwner& owner) { - if( reinterpret_cast(mTextureSet) == &owner ) + if( reinterpret_cast(mShader) == &owner ) { - mTextureSet = NULL; + mShader = NULL; } - else if( reinterpret_cast(mShader) == &owner ) +} + +void Renderer::SetDirty( bool value ) +{ + mDirty = value; + if( mShader ) { - mShader = NULL; + mShader->SetPropertyDirty( value ); + } +} + +bool Renderer::IsDirty() const +{ + bool ret = false; + if( mShader ) + { + ret = mShader->IsPropertyDirty(); } + + // check native image + if( mTextureSet ) + { + uint32_t textureCount = mTextureSet->GetTextureCount(); + + if(textureCount > 0) + { + Dali::Internal::Render::Texture* texture; + for( uint32_t i = 0; i(mTextureSet)->GetTexture(i); + if( texture && texture->IsNativeImage() ) + { + ret = true; + break; + } + } + } + } + + return ret | mDirty; } } // namespace SceneGraph