X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Frendering%2Fscene-graph-renderer.cpp;h=6c93f9c50ca16eac9ce221775c45b578d0970f68;hb=d5e2b535713c01724dd3ff49309c861fbd1a467c;hp=ec8965fa6f3e223ec0e371b21ec95b941eea45f8;hpb=7c148d3457051e5d101756203ccc6df1a206eab0;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 index ec8965f..6c93f9c 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.cpp +++ b/dali/internal/update/rendering/scene-graph-renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 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. @@ -17,19 +17,18 @@ // CLASS HEADER #include "scene-graph-renderer.h" -// INTERNAL HEADERS -#include -#include +// INTERNAL INCLUDES +#include +#include #include +#include +#include #include -#include -#include #include -#include #include -#include -#include - +#include +#include +#include namespace // unnamed namespace { @@ -86,20 +85,31 @@ void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, con } } -// flags for resending data to renderer +// Flags for re-sending data to renderer. enum Flags { - RESEND_DATA_PROVIDER = 1, - 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_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 { @@ -114,23 +124,27 @@ Renderer* Renderer::New() } Renderer::Renderer() -:mSceneController( 0 ), - mRenderer( NULL ), - mTextureSet( NULL ), - mGeometry( NULL ), - mShader( NULL ), - mBlendColor( NULL ), - mBlendBitmask( 0u ), - mFaceCullingMode( Dali::Renderer::NONE ), - mBlendingMode( Dali::BlendingMode::AUTO ), - mIndexedDrawFirstElement( 0 ), - mIndexedDrawElementsCount( 0 ), - mReferenceCount( 0 ), - mRegenerateUniformMap( 0 ), - mResendFlag( 0 ), - mResourcesReady( false ), - mFinishedResourceAcquisition( false ), - mDepthIndex( 0 ) +: mSceneController( 0 ), + mRenderer( NULL ), + 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 ), + mIndexedDrawElementsCount( 0u ), + mBlendBitmask( 0u ), + mRegenerateUniformMap( 0u ), + mResendFlag( 0u ), + mDepthFunction( DepthFunction::LESS ), + mFaceCullingMode( FaceCullingMode::NONE ), + mBlendMode( BlendMode::AUTO ), + mDepthWriteMode( DepthWriteMode::AUTO ), + mDepthTestMode( DepthTestMode::AUTO ), + mPremultipledAlphaEnabled( false ), + mOpacity( 1.0f ), + mDepthIndex( 0 ) { mUniformMapChanged[0] = false; mUniformMapChanged[1] = false; @@ -141,17 +155,16 @@ Renderer::Renderer() Renderer::~Renderer() { - if (mTextureSet) + if( mTextureSet ) { - mTextureSet->RemoveObserver(this); - mTextureSet=NULL; + mTextureSet->RemoveObserver( this ); + mTextureSet = NULL; } if( mShader ) { - mShader->RemoveConnectionObserver(*this); - mShader=NULL; + mShader->RemoveConnectionObserver( *this ); + mShader = NULL; } - } void Renderer::operator delete( void* ptr ) @@ -162,28 +175,12 @@ 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 ) + if( mRegenerateUniformMap == UNIFORM_MAP_READY ) { - if( mTextureSet ) - { - mTextureSet->GetResourcesStatus( mResourcesReady, mFinishedResourceAcquisition ); - } - else - { - 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()" ); - if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP) { CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ]; @@ -191,7 +188,11 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex ) const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap(); AddMappings( localMap, rendererUniformMap ); - AddMappings( localMap, mShader->GetUniformMap() ); + + if( mShader ) + { + AddMappings( localMap, mShader->GetUniformMap() ); + } } else if( mRegenerateUniformMap == COPY_UNIFORM_MAP ) { @@ -212,76 +213,135 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex ) mRegenerateUniformMap--; } - if( mResendFlag == 0 ) + if( mResendFlag != 0 ) { - return; - } + if( mResendFlag & RESEND_GEOMETRY ) + { + typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry ); + } - if( mResendFlag & RESEND_DATA_PROVIDER ) - { - RenderDataProvider* dataProvider = NewRenderDataProvider(); + if( mResendFlag & RESEND_FACE_CULLING_MODE ) + { + typedef MessageValue1< Render::Renderer, FaceCullingMode::Type > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode ); + } - typedef MessageValue1< Render::Renderer, OwnerPointer > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider ); - mResendFlag &= ~RESEND_DATA_PROVIDER; - } + if( mResendFlag & RESEND_BLEND_BIT_MASK ) + { + typedef MessageValue1< Render::Renderer, unsigned int > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask ); + } - if( mResendFlag & RESEND_GEOMETRY ) - { - typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + if( mResendFlag & RESEND_BLEND_COLOR ) + { + typedef MessageValue1< Render::Renderer, Vector4 > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, GetBlendColor() ); + } - new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry ); - mResendFlag &= ~RESEND_GEOMETRY; - } + if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA ) + { + typedef MessageValue1< Render::Renderer, bool > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled ); + } - if( mResendFlag & RESEND_FACE_CULLING_MODE ) - { - typedef MessageValue1< Render::Renderer, Dali::Renderer::FaceCullingMode > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode ); - mResendFlag &= ~RESEND_FACE_CULLING_MODE; - } + if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT ) + { + typedef MessageValue1< Render::Renderer, size_t > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement ); + } - if( mResendFlag & RESEND_BLEND_BIT_MASK ) - { - typedef MessageValue1< Render::Renderer, unsigned int > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask ); - mResendFlag &= ~RESEND_BLEND_BIT_MASK; - } + if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT ) + { + typedef MessageValue1< Render::Renderer, size_t > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount ); + } - 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 ); - mResendFlag &= ~RESEND_BLEND_COLOR; - } + if( mResendFlag & RESEND_DEPTH_WRITE_MODE ) + { + typedef MessageValue1< Render::Renderer, DepthWriteMode::Type > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode ); + } - if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA ) - { - typedef MessageValue1< Render::Renderer, bool > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled ); - mResendFlag &= ~RESEND_PREMULTIPLIED_ALPHA; - } + if( mResendFlag & RESEND_DEPTH_TEST_MODE ) + { + typedef MessageValue1< Render::Renderer, DepthTestMode::Type > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode ); + } - if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT ) - { - typedef MessageValue1< Render::Renderer, size_t > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement ); - mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT; - } + if( mResendFlag & RESEND_DEPTH_FUNCTION ) + { + typedef MessageValue1< Render::Renderer, DepthFunction::Type > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction ); + } - if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT ) - { - typedef MessageValue1< Render::Renderer, size_t > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount ); - mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT; + if( mResendFlag & RESEND_RENDER_MODE ) + { + typedef MessageValue1< Render::Renderer, RenderMode::Type > DerivedType; + unsigned int* 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 ) ); + 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 ) ); + 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 ) ); + 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 ) ); + 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 ) ); + 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 ) ); + 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 ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass ); + } + + mResendFlag = 0; } } @@ -297,7 +357,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 ) @@ -312,7 +373,11 @@ void Renderer::SetShader( Shader* shader ) mShader = shader; mShader->AddConnectionObserver( *this ); mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; - mResendFlag |= RESEND_DATA_PROVIDER; + + if( mRenderDataProvider ) + { + mRenderDataProvider->mShader = mShader; + } } void Renderer::SetGeometry( Render::Geometry* geometry ) @@ -331,15 +396,25 @@ void Renderer::SetDepthIndex( int depthIndex ) mDepthIndex = depthIndex; } -void Renderer::SetFaceCullingMode( unsigned int faceCullingMode ) +void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode ) { - mFaceCullingMode = static_cast(faceCullingMode); + mFaceCullingMode = faceCullingMode; mResendFlag |= RESEND_FACE_CULLING_MODE; } -void Renderer::SetBlendingMode( unsigned int blendingMode ) +FaceCullingMode::Type Renderer::GetFaceCullingMode() const { - mBlendingMode = static_cast< BlendingMode::Type >( blendingMode ); + return mFaceCullingMode; +} + +void Renderer::SetBlendMode( BlendMode::Type blendingMode ) +{ + mBlendMode = blendingMode; +} + +BlendMode::Type Renderer::GetBlendMode() const +{ + return mBlendMode; } void Renderer::SetBlendingOptions( unsigned int options ) @@ -351,64 +426,168 @@ void Renderer::SetBlendingOptions( unsigned int options ) } } +unsigned int 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; } +Vector4 Renderer::GetBlendColor() const +{ + if( mBlendColor ) + { + return *mBlendColor; + } + return Color::TRANSPARENT; +} + void Renderer::SetIndexedDrawFirstElement( size_t firstElement ) { mIndexedDrawFirstElement = firstElement; mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT; } +size_t Renderer::GetIndexedDrawFirstElement() const +{ + return mIndexedDrawFirstElement; +} + void Renderer::SetIndexedDrawElementsCount( size_t elementsCount ) { mIndexedDrawElementsCount = elementsCount; mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT; } +size_t Renderer::GetIndexedDrawElementsCount() const +{ + return mIndexedDrawElementsCount; +} + void Renderer::EnablePreMultipliedAlpha( bool preMultipled ) { mPremultipledAlphaEnabled = preMultipled; mResendFlag |= RESEND_PREMULTIPLIED_ALPHA; } -//Called when a node with this renderer is added to the stage -void Renderer::OnStageConnect() +bool Renderer::IsPreMultipliedAlphaEnabled() const { - ++mReferenceCount; - if( !mRenderer) - { - RenderDataProvider* dataProvider = NewRenderDataProvider(); + return mPremultipledAlphaEnabled; +} - mRenderer = Render::Renderer::New( dataProvider, mGeometry, - mBlendBitmask, mBlendColor, - static_cast< Dali::Renderer::FaceCullingMode >( mFaceCullingMode ), - mPremultipledAlphaEnabled ); - mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer ); - mResendFlag = 0; - } +void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode ) +{ + mDepthWriteMode = depthWriteMode; + mResendFlag |= RESEND_DEPTH_WRITE_MODE; } -//Called when the node with this renderer has gone out of the stage -void Renderer::OnStageDisconnect() +DepthWriteMode::Type Renderer::GetDepthWriteMode() const { - --mReferenceCount; - if( mReferenceCount == 0 ) - { - mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer ); - mRenderer = NULL; - } + 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; + mResendFlag |= RESEND_RENDER_MODE; +} + +void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction ) +{ + mStencilParameters.stencilFunction = stencilFunction; + mResendFlag |= RESEND_STENCIL_FUNCTION; +} + +void Renderer::SetStencilFunctionMask( int stencilFunctionMask ) +{ + mStencilParameters.stencilFunctionMask = stencilFunctionMask; + mResendFlag |= RESEND_STENCIL_FUNCTION_MASK; +} + +void Renderer::SetStencilFunctionReference( int stencilFunctionReference ) +{ + mStencilParameters.stencilFunctionReference = stencilFunctionReference; + mResendFlag |= RESEND_STENCIL_FUNCTION_REFERENCE; +} + +void Renderer::SetStencilMask( int stencilMask ) +{ + mStencilParameters.stencilMask = stencilMask; + mResendFlag |= RESEND_STENCIL_MASK; +} + +void Renderer::SetStencilOperationOnFail( StencilOperation::Type stencilOperationOnFail ) +{ + mStencilParameters.stencilOperationOnFail = stencilOperationOnFail; + mResendFlag |= RESEND_STENCIL_OPERATION_ON_FAIL; +} + +void Renderer::SetStencilOperationOnZFail( StencilOperation::Type stencilOperationOnZFail ) +{ + mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail; + mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_FAIL; +} + +void Renderer::SetStencilOperationOnZPass( StencilOperation::Type stencilOperationOnZPass ) +{ + mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass; + mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_PASS; +} + +const Render::Renderer::StencilParameters& Renderer::GetStencilParameters() const +{ + return mStencilParameters; +} + +void Renderer::BakeOpacity( BufferIndex updateBufferIndex, float opacity ) +{ + mOpacity.Bake( updateBufferIndex, opacity ); +} + +float Renderer::GetOpacity( BufferIndex updateBufferIndex ) const +{ + return mOpacity[updateBufferIndex]; } //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created ) @@ -416,8 +595,16 @@ void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferInde { mRegenerateUniformMap = REGENERATE_UNIFORM_MAP; mSceneController = &sceneController; -} + mRenderDataProvider = new RenderDataProvider( mOpacity ); + mRenderDataProvider->mUniformMapDataProvider = this; + + 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 ) void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex ) @@ -427,29 +614,32 @@ void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, Buffe { mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer ); mRenderer = NULL; - mSceneController = 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 ); - for( unsigned int i(0); imTextures[i] = Render::Texture( mTextureSet->GetTextureId(i), - mTextureSet->GetTextureSampler(i)); + size_t textureCount = mTextureSet->GetTextureCount(); + mRenderDataProvider->mTextures.resize( textureCount ); + mRenderDataProvider->mSamplers.resize( textureCount ); + for( unsigned int i(0); imTextures[i] = mTextureSet->GetTexture(i); + mRenderDataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i); + } + } + else + { + mRenderDataProvider->mTextures.clear(); + mRenderDataProvider->mSamplers.clear(); } } - - return dataProvider; } Render::Renderer& Renderer::GetRenderer() @@ -460,61 +650,72 @@ Render::Renderer& Renderer::GetRenderer() const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) const { 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( mBlendingMode ) + switch( mBlendMode ) { - case BlendingMode::ON: // If the renderer should always be use blending + 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 BlendingMode::AUTO: + case BlendMode::AUTO: { - bool shaderRequiresBlending( mShader->GeometryHintEnabled( Dali::ShaderEffect::HINT_BLENDING ) ); + 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 BlendingMode::OFF: // the renderer should never use blending + 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 ) @@ -522,9 +723,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() @@ -540,11 +738,7 @@ void Renderer::UniformMappingsChanged( const UniformMap& mappings ) void Renderer::ObservedObjectDestroyed(PropertyOwner& owner) { - if( reinterpret_cast(mTextureSet) == &owner ) - { - mTextureSet = NULL; - } - else if( reinterpret_cast(mShader) == &owner ) + if( reinterpret_cast(mShader) == &owner ) { mShader = NULL; }