X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Frendering%2Fscene-graph-renderer.cpp;h=2fd1cfb632c5f4cc0a52e2b1314a179a23d0a3a5;hb=ad06250b0131a81ad28ae63c7e063f3d291d3060;hp=d2937755a9d1e085b5ba5a84958012e6ae536be6;hpb=0db2affb5b891cf73b32925fd9a91f31ea5fc583;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 d293775..2fd1cfb 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) 2016 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,13 +17,12 @@ // CLASS HEADER #include "scene-graph-renderer.h" -// INTERNAL HEADERS +// INTERNAL INCLUDES #include #include #include #include #include -#include #include #include #include @@ -86,21 +85,32 @@ 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_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_WRITE_MODE = 1 << 8, + RESEND_DEPTH_TEST_MODE = 1 << 9, + RESEND_DEPTH_FUNCTION = 1 << 10, + RESEND_STENCIL_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 }; -} +} // Anonymous namespace namespace Dali { @@ -115,25 +125,28 @@ Renderer* Renderer::New() } Renderer::Renderer() -:mSceneController( 0 ), - mRenderer( NULL ), - mTextureSet( NULL ), - mGeometry( NULL ), - mShader( NULL ), - mBlendColor( NULL ), - mBlendBitmask( 0u ), - mFaceCullingMode( FaceCullingMode::NONE ), - mBlendMode( BlendMode::AUTO ), - mDepthWriteMode( DepthWriteMode::AUTO ), - mIndexedDrawFirstElement( 0 ), - mIndexedDrawElementsCount( 0 ), - mReferenceCount( 0 ), - mRegenerateUniformMap( 0 ), - mResendFlag( 0 ), - mResourcesReady( false ), - mFinishedResourceAcquisition( false ), - mPremultipledAlphaEnabled(false), - mDepthIndex( 0 ) +: mSceneController( 0 ), + mRenderer( NULL ), + mTextureSet( NULL ), + mGeometry( NULL ), + mShader( NULL ), + mBlendColor( NULL ), + mStencilParameters( StencilMode::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 ), + mWriteToColorBuffer( true ), + mResourcesReady( false ), + mFinishedResourceAcquisition( false ), + mPremultipledAlphaEnabled( false ), + mDepthIndex( 0 ) { mUniformMapChanged[0] = false; mUniformMapChanged[1] = false; @@ -154,7 +167,6 @@ Renderer::~Renderer() mShader->RemoveConnectionObserver(*this); mShader=NULL; } - } void Renderer::operator delete( void* ptr ) @@ -194,7 +206,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 ) { @@ -283,6 +299,83 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex ) 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 ) ); + 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 ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction ); + } + + if( mResendFlag & RESEND_STENCIL_MODE ) + { + typedef MessageValue1< Render::Renderer, StencilMode::Type > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilMode, mStencilParameters.stencilMode ); + } + + 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 ); + } + + if( mResendFlag & RESEND_WRITE_TO_COLOR_BUFFER ) + { + typedef MessageValue1< Render::Renderer, bool > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetWriteToColorBuffer, mWriteToColorBuffer ); + } + mResendFlag = 0; } } @@ -333,15 +426,15 @@ void Renderer::SetDepthIndex( int depthIndex ) mDepthIndex = depthIndex; } -void Renderer::SetFaceCullingMode( unsigned int faceCullingMode ) +void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode ) { - mFaceCullingMode = static_cast< FaceCullingMode::Type >( faceCullingMode ); + mFaceCullingMode = faceCullingMode; mResendFlag |= RESEND_FACE_CULLING_MODE; } -void Renderer::SetBlendMode( unsigned int blendingMode ) +void Renderer::SetBlendMode( BlendMode::Type blendingMode ) { - mBlendMode = static_cast< BlendMode::Type >( blendingMode ); + mBlendMode = blendingMode; } void Renderer::SetBlendingOptions( unsigned int options ) @@ -385,40 +478,76 @@ void Renderer::EnablePreMultipliedAlpha( bool preMultipled ) mResendFlag |= RESEND_PREMULTIPLIED_ALPHA; } -void Renderer::SetDepthWriteMode( unsigned int depthWriteMode ) +void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode ) { - mDepthWriteMode = static_cast< DepthWriteMode::Type >( depthWriteMode ); + mDepthWriteMode = depthWriteMode; mResendFlag |= RESEND_DEPTH_WRITE_MODE; } -//Called when a node with this renderer is added to the stage -void Renderer::OnStageConnect() +void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode ) { - ++mReferenceCount; - if( !mRenderer) - { - RenderDataProvider* dataProvider = NewRenderDataProvider(); + mDepthTestMode = depthTestMode; + mResendFlag |= RESEND_DEPTH_TEST_MODE; +} - mRenderer = Render::Renderer::New( dataProvider, mGeometry, - mBlendBitmask, mBlendColor, - static_cast< FaceCullingMode::Type >( mFaceCullingMode ), - mPremultipledAlphaEnabled, - mDepthWriteMode ); +void Renderer::SetDepthFunction( DepthFunction::Type depthFunction ) +{ + mDepthFunction = depthFunction; + mResendFlag |= RESEND_DEPTH_FUNCTION; +} - mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer ); - mResendFlag = 0; - } +void Renderer::SetStencilMode( StencilMode::Type mode ) +{ + mStencilParameters.stencilMode = mode; + mResendFlag |= RESEND_STENCIL_MODE; } -//Called when the node with this renderer has gone out of the stage -void Renderer::OnStageDisconnect() +void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction ) { - --mReferenceCount; - if( mReferenceCount == 0 ) - { - mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer ); - mRenderer = NULL; - } + 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; +} + +void Renderer::SetWriteToColorBuffer( bool writeToColorBuffer ) +{ + mWriteToColorBuffer = writeToColorBuffer; + mResendFlag |= RESEND_WRITE_TO_COLOR_BUFFER; } //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created ) @@ -426,8 +555,13 @@ void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferInde { 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, mWriteToColorBuffer ); + + mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer ); +} //Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced ) void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex ) @@ -437,8 +571,8 @@ void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, Buffe { mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer ); mRenderer = NULL; - mSceneController = NULL; } + mSceneController = NULL; } RenderDataProvider* Renderer::NewRenderDataProvider() @@ -452,10 +586,20 @@ RenderDataProvider* Renderer::NewRenderDataProvider() { size_t textureCount( mTextureSet->GetTextureCount() ); dataProvider->mTextures.resize( textureCount ); + dataProvider->mSamplers.resize( textureCount ); for( unsigned int i(0); imTextures[i] = Render::Texture( mTextureSet->GetTextureId(i), - mTextureSet->GetTextureSampler(i)); + dataProvider->mTextures[i] = Render::Texture( mTextureSet->GetTextureId(i),0); + dataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i); + } + + textureCount = mTextureSet->GetNewTextureCount(); + dataProvider->mNewTextures.resize( textureCount ); + dataProvider->mSamplers.resize( textureCount ); + for( unsigned int i(0); imNewTextures[i] = mTextureSet->GetNewTexture(i); + dataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i); } } @@ -470,7 +614,7 @@ Render::Renderer& Renderer::GetRenderer() const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) const { return mCollectedUniformMap[bufferIndex]; -}; +} void Renderer::GetReadyAndComplete( bool& ready, bool& complete ) const {