X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-renderer.cpp;h=1ffc12f8fb334ecc5fff0aa9c113f80f7a96c4a2;hb=4976fbaa1c6f06926438cfcd6a6e97553149a9ff;hp=80449e8f4e9d78e93f212243f9a6e9785fc7e7b3;hpb=e69ef8252edad2374dba71d2730c2db30376ec98;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp index 80449e8..1ffc12f 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 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. @@ -20,24 +20,21 @@ // INTERNAL INCLUDES #include +#include +#include +#include #include #include -#include +#include #include -#include -#include -#include +#include namespace Dali { - namespace Internal { - namespace { - - /** * Helper to set view and projection matrices once per program * @param program to set the matrices to @@ -47,149 +44,146 @@ namespace * @param modelViewMatrix to set * @param modelViewProjectionMatrix to set */ -inline void SetMatrices( Program& program, - const Matrix& modelMatrix, - const Matrix& viewMatrix, - const Matrix& projectionMatrix, - const Matrix& modelViewMatrix ) -{ - GLint loc = program.GetUniformLocation( Program::UNIFORM_MODEL_MATRIX ); - if( Program::UNIFORM_UNKNOWN != loc ) +inline void SetMatrices(Program& program, + const Matrix& modelMatrix, + const Matrix& viewMatrix, + const Matrix& projectionMatrix, + const Matrix& modelViewMatrix) +{ + GLint loc = program.GetUniformLocation(Program::UNIFORM_MODEL_MATRIX); + if(Program::UNIFORM_UNKNOWN != loc) { - program.SetUniformMatrix4fv( loc, 1, modelMatrix.AsFloat() ); + program.SetUniformMatrix4fv(loc, 1, modelMatrix.AsFloat()); } - loc = program.GetUniformLocation( Program::UNIFORM_VIEW_MATRIX ); - if( Program::UNIFORM_UNKNOWN != loc ) + loc = program.GetUniformLocation(Program::UNIFORM_VIEW_MATRIX); + if(Program::UNIFORM_UNKNOWN != loc) { - if( program.GetViewMatrix() != &viewMatrix ) + if(program.GetViewMatrix() != &viewMatrix) { - program.SetViewMatrix( &viewMatrix ); - program.SetUniformMatrix4fv( loc, 1, viewMatrix.AsFloat() ); + program.SetViewMatrix(&viewMatrix); + program.SetUniformMatrix4fv(loc, 1, viewMatrix.AsFloat()); } } // set projection matrix if program has not yet received it this frame or if it is dirty - loc = program.GetUniformLocation( Program::UNIFORM_PROJECTION_MATRIX ); - if( Program::UNIFORM_UNKNOWN != loc ) + loc = program.GetUniformLocation(Program::UNIFORM_PROJECTION_MATRIX); + if(Program::UNIFORM_UNKNOWN != loc) { - if( program.GetProjectionMatrix() != &projectionMatrix ) + if(program.GetProjectionMatrix() != &projectionMatrix) { - program.SetProjectionMatrix( &projectionMatrix ); - program.SetUniformMatrix4fv( loc, 1, projectionMatrix.AsFloat() ); + program.SetProjectionMatrix(&projectionMatrix); + program.SetUniformMatrix4fv(loc, 1, projectionMatrix.AsFloat()); } } loc = program.GetUniformLocation(Program::UNIFORM_MODELVIEW_MATRIX); - if( Program::UNIFORM_UNKNOWN != loc ) + if(Program::UNIFORM_UNKNOWN != loc) { - program.SetUniformMatrix4fv( loc, 1, modelViewMatrix.AsFloat() ); + program.SetUniformMatrix4fv(loc, 1, modelViewMatrix.AsFloat()); } - loc = program.GetUniformLocation( Program::UNIFORM_MVP_MATRIX ); - if( Program::UNIFORM_UNKNOWN != loc ) + loc = program.GetUniformLocation(Program::UNIFORM_MVP_MATRIX); + if(Program::UNIFORM_UNKNOWN != loc) { Matrix modelViewProjectionMatrix(false); - Matrix::Multiply( modelViewProjectionMatrix, modelViewMatrix, projectionMatrix ); - program.SetUniformMatrix4fv( loc, 1, modelViewProjectionMatrix.AsFloat() ); + Matrix::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix); + program.SetUniformMatrix4fv(loc, 1, modelViewProjectionMatrix.AsFloat()); } - loc = program.GetUniformLocation( Program::UNIFORM_NORMAL_MATRIX ); - if( Program::UNIFORM_UNKNOWN != loc ) + loc = program.GetUniformLocation(Program::UNIFORM_NORMAL_MATRIX); + if(Program::UNIFORM_UNKNOWN != loc) { Matrix3 normalMatrix; normalMatrix = modelViewMatrix; normalMatrix.Invert(); normalMatrix.Transpose(); - program.SetUniformMatrix3fv( loc, 1, normalMatrix.AsFloat() ); + program.SetUniformMatrix3fv(loc, 1, normalMatrix.AsFloat()); } } -} +} // namespace namespace Render { - -Renderer* Renderer::New( SceneGraph::RenderDataProvider* dataProvider, - Render::Geometry* geometry, - uint32_t blendingBitmask, - const Vector4& blendColor, - FaceCullingMode::Type faceCullingMode, - bool preMultipliedAlphaEnabled, - DepthWriteMode::Type depthWriteMode, - DepthTestMode::Type depthTestMode, - DepthFunction::Type depthFunction, - StencilParameters& stencilParameters ) -{ - return new Renderer( dataProvider, geometry, blendingBitmask, blendColor, - faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, - depthFunction, stencilParameters ); -} - -Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider, - Render::Geometry* geometry, - uint32_t blendingBitmask, - const Vector4& blendColor, - FaceCullingMode::Type faceCullingMode, - bool preMultipliedAlphaEnabled, - DepthWriteMode::Type depthWriteMode, - DepthTestMode::Type depthTestMode, - DepthFunction::Type depthFunction, - StencilParameters& stencilParameters ) -: mRenderDataProvider( dataProvider ), - mContext( NULL), - mGeometry( geometry ), +Renderer* Renderer::New(SceneGraph::RenderDataProvider* dataProvider, + Render::Geometry* geometry, + uint32_t blendingBitmask, + const Vector4& blendColor, + FaceCullingMode::Type faceCullingMode, + bool preMultipliedAlphaEnabled, + DepthWriteMode::Type depthWriteMode, + DepthTestMode::Type depthTestMode, + DepthFunction::Type depthFunction, + StencilParameters& stencilParameters) +{ + return new Renderer(dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, depthFunction, stencilParameters); +} + +Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider, + Render::Geometry* geometry, + uint32_t blendingBitmask, + const Vector4& blendColor, + FaceCullingMode::Type faceCullingMode, + bool preMultipliedAlphaEnabled, + DepthWriteMode::Type depthWriteMode, + DepthTestMode::Type depthTestMode, + DepthFunction::Type depthFunction, + StencilParameters& stencilParameters) +: mRenderDataProvider(dataProvider), + mContext(nullptr), + mGeometry(geometry), + mProgramCache(nullptr), mUniformIndexMap(), mAttributesLocation(), mUniformsHash(), - mStencilParameters( stencilParameters ), + mStencilParameters(stencilParameters), mBlendingOptions(), - mIndexedDrawFirstElement( 0 ), - mIndexedDrawElementsCount( 0 ), - mDepthFunction( depthFunction ), - mFaceCullingMode( faceCullingMode ), - mDepthWriteMode( depthWriteMode ), - mDepthTestMode( depthTestMode ), - mUpdateAttributesLocation( true ), - mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ), - mShaderChanged( false ), - mUpdated( true ) -{ - if( blendingBitmask != 0u ) + mIndexedDrawFirstElement(0), + mIndexedDrawElementsCount(0), + mDepthFunction(depthFunction), + mFaceCullingMode(faceCullingMode), + mDepthWriteMode(depthWriteMode), + mDepthTestMode(depthTestMode), + mUpdateAttributesLocation(true), + mPremultipledAlphaEnabled(preMultipliedAlphaEnabled), + mShaderChanged(false), + mUpdated(true) +{ + if(blendingBitmask != 0u) { - mBlendingOptions.SetBitmask( blendingBitmask ); + mBlendingOptions.SetBitmask(blendingBitmask); } - mBlendingOptions.SetBlendColor( blendColor ); + mBlendingOptions.SetBlendColor(blendColor); } -void Renderer::Initialize( Context& context ) +void Renderer::Initialize(Context& context, ProgramCache& programCache) { - mContext = &context; + mContext = &context; + mProgramCache = &programCache; } -Renderer::~Renderer() -{ -} +Renderer::~Renderer() = default; -void Renderer::SetGeometry( Render::Geometry* geometry ) +void Renderer::SetGeometry(Render::Geometry* geometry) { - mGeometry = geometry; + mGeometry = geometry; mUpdateAttributesLocation = true; } -void Renderer::SetDrawCommands( Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size ) +void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size) { mDrawCommands.clear(); - mDrawCommands.insert( mDrawCommands.end(), pDrawCommands, pDrawCommands+size ); + mDrawCommands.insert(mDrawCommands.end(), pDrawCommands, pDrawCommands + size); } -void Renderer::SetBlending( Context& context, bool blend ) +void Renderer::SetBlending(Context& context, bool blend) { - context.SetBlend( blend ); - if( blend ) + context.SetBlend(blend); + if(blend) { // Blend color is optional and rarely used const Vector4* blendColor = mBlendingOptions.GetBlendColor(); - if( blendColor ) + if(blendColor) { - context.SetCustomBlendColor( *blendColor ); + context.SetCustomBlendColor(*blendColor); } else { @@ -197,14 +191,27 @@ void Renderer::SetBlending( Context& context, bool blend ) } // Set blend source & destination factors - context.BlendFuncSeparate( mBlendingOptions.GetBlendSrcFactorRgb(), - mBlendingOptions.GetBlendDestFactorRgb(), - mBlendingOptions.GetBlendSrcFactorAlpha(), - mBlendingOptions.GetBlendDestFactorAlpha() ); + context.BlendFuncSeparate(mBlendingOptions.GetBlendSrcFactorRgb(), + mBlendingOptions.GetBlendDestFactorRgb(), + mBlendingOptions.GetBlendSrcFactorAlpha(), + mBlendingOptions.GetBlendDestFactorAlpha()); // Set blend equations - context.BlendEquationSeparate( mBlendingOptions.GetBlendEquationRgb(), - mBlendingOptions.GetBlendEquationAlpha() ); + Dali::DevelBlendEquation::Type rgbEquation = mBlendingOptions.GetBlendEquationRgb(); + Dali::DevelBlendEquation::Type alphaEquation = mBlendingOptions.GetBlendEquationAlpha(); + + if(mBlendingOptions.IsAdvancedBlendEquationApplied() && mPremultipledAlphaEnabled) + { + if(rgbEquation != alphaEquation) + { + DALI_LOG_ERROR("Advanced Blend Equation have to be appried by using BlendEquation.\n"); + } + context.BlendEquation(rgbEquation); + } + else + { + context.BlendEquationSeparate(rgbEquation, alphaEquation); + } } mUpdated = true; @@ -219,133 +226,133 @@ void Renderer::GlCleanup() { } -void Renderer::SetUniforms( BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, const Vector3& size, Program& program ) +void Renderer::SetUniforms(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, const Vector3& size, Program& program) { // Check if the map has changed - DALI_ASSERT_DEBUG( mRenderDataProvider && "No Uniform map data provider available" ); + DALI_ASSERT_DEBUG(mRenderDataProvider && "No Uniform map data provider available"); const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap(); - if( uniformMapDataProvider.GetUniformMapChanged( bufferIndex ) || - node.GetUniformMapChanged(bufferIndex) || - mUniformIndexMap.Count() == 0 || - mShaderChanged ) + if(uniformMapDataProvider.GetUniformMapChanged(bufferIndex) || + node.GetUniformMapChanged(bufferIndex) || + mUniformIndexMap.Count() == 0 || + mShaderChanged) { // Reset shader pointer mShaderChanged = false; - const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap( bufferIndex ); - const SceneGraph::CollectedUniformMap& uniformMapNode = node.GetUniformMap( bufferIndex ); + const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap(bufferIndex); + const SceneGraph::CollectedUniformMap& uniformMapNode = node.GetUniformMap(bufferIndex); - uint32_t maxMaps = static_cast( uniformMap.Count() + uniformMapNode.Count() ); // 4,294,967,295 maps should be enough - mUniformIndexMap.Clear(); // Clear contents, but keep memory if we don't change size - mUniformIndexMap.Resize( maxMaps ); + uint32_t maxMaps = static_cast(uniformMap.Count() + uniformMapNode.Count()); // 4,294,967,295 maps should be enough + mUniformIndexMap.Clear(); // Clear contents, but keep memory if we don't change size + mUniformIndexMap.Resize(maxMaps); uint32_t mapIndex = 0; - for(; mapIndex < uniformMap.Count() ; ++mapIndex ) + for(; mapIndex < uniformMap.Count(); ++mapIndex) { - mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex]->propertyPtr; - mUniformIndexMap[mapIndex].uniformIndex = program.RegisterUniform( uniformMap[mapIndex]->uniformName ); + mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex].propertyPtr; + mUniformIndexMap[mapIndex].uniformIndex = program.RegisterUniform(uniformMap[mapIndex].uniformName); } - for( uint32_t nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count() ; ++nodeMapIndex ) + for(uint32_t nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count(); ++nodeMapIndex) { - uint32_t uniformIndex = program.RegisterUniform( uniformMapNode[nodeMapIndex]->uniformName ); - bool found(false); - for( uint32_t i = 0; ipropertyPtr; - found = true; + mUniformIndexMap[i].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr; + found = true; break; } } - if( !found ) + if(!found) { - mUniformIndexMap[mapIndex].propertyValue = uniformMapNode[nodeMapIndex]->propertyPtr; - mUniformIndexMap[mapIndex].uniformIndex = uniformIndex; + mUniformIndexMap[mapIndex].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr; + mUniformIndexMap[mapIndex].uniformIndex = uniformIndex; ++mapIndex; } } - mUniformIndexMap.Resize( mapIndex ); + mUniformIndexMap.Resize(mapIndex); } // Set uniforms in local map - for( UniformIndexMappings::Iterator iter = mUniformIndexMap.Begin(), - end = mUniformIndexMap.End() ; - iter != end ; - ++iter ) + for(UniformIndexMappings::Iterator iter = mUniformIndexMap.Begin(), + end = mUniformIndexMap.End(); + iter != end; + ++iter) { - SetUniformFromProperty( bufferIndex, program, *iter ); + SetUniformFromProperty(bufferIndex, program, *iter); } - GLint sizeLoc = program.GetUniformLocation( Program::UNIFORM_SIZE ); - if( -1 != sizeLoc ) + GLint sizeLoc = program.GetUniformLocation(Program::UNIFORM_SIZE); + if(-1 != sizeLoc) { - program.SetSizeUniform3f( sizeLoc, size.x, size.y, size.z ); + program.SetSizeUniform3f(sizeLoc, size.x, size.y, size.z); } } -void Renderer::SetUniformFromProperty( BufferIndex bufferIndex, Program& program, UniformIndexMap& map ) +void Renderer::SetUniformFromProperty(BufferIndex bufferIndex, Program& program, UniformIndexMap& map) { GLint location = program.GetUniformLocation(map.uniformIndex); - if( Program::UNIFORM_UNKNOWN != location ) + if(Program::UNIFORM_UNKNOWN != location) { // switch based on property type to use correct GL uniform setter - switch ( map.propertyValue->GetType() ) + switch(map.propertyValue->GetType()) { case Property::INTEGER: { - program.SetUniform1i( location, map.propertyValue->GetInteger( bufferIndex ) ); + program.SetUniform1i(location, map.propertyValue->GetInteger(bufferIndex)); break; } case Property::FLOAT: { - program.SetUniform1f( location, map.propertyValue->GetFloat( bufferIndex ) ); + program.SetUniform1f(location, map.propertyValue->GetFloat(bufferIndex)); break; } case Property::VECTOR2: { - Vector2 value( map.propertyValue->GetVector2( bufferIndex ) ); - program.SetUniform2f( location, value.x, value.y ); + Vector2 value(map.propertyValue->GetVector2(bufferIndex)); + program.SetUniform2f(location, value.x, value.y); break; } case Property::VECTOR3: { - Vector3 value( map.propertyValue->GetVector3( bufferIndex ) ); - program.SetUniform3f( location, value.x, value.y, value.z ); + Vector3 value(map.propertyValue->GetVector3(bufferIndex)); + program.SetUniform3f(location, value.x, value.y, value.z); break; } case Property::VECTOR4: { - Vector4 value( map.propertyValue->GetVector4( bufferIndex ) ); - program.SetUniform4f( location, value.x, value.y, value.z, value.w ); + Vector4 value(map.propertyValue->GetVector4(bufferIndex)); + program.SetUniform4f(location, value.x, value.y, value.z, value.w); break; } case Property::ROTATION: { - Quaternion value( map.propertyValue->GetQuaternion( bufferIndex ) ); - program.SetUniform4f( location, value.mVector.x, value.mVector.y, value.mVector.z, value.mVector.w ); + Quaternion value(map.propertyValue->GetQuaternion(bufferIndex)); + program.SetUniform4f(location, value.mVector.x, value.mVector.y, value.mVector.z, value.mVector.w); break; } case Property::MATRIX: { const Matrix& value = map.propertyValue->GetMatrix(bufferIndex); - program.SetUniformMatrix4fv(location, 1, value.AsFloat() ); + program.SetUniformMatrix4fv(location, 1, value.AsFloat()); break; } case Property::MATRIX3: { const Matrix3& value = map.propertyValue->GetMatrix3(bufferIndex); - program.SetUniformMatrix3fv(location, 1, value.AsFloat() ); + program.SetUniformMatrix3fv(location, 1, value.AsFloat()); break; } @@ -358,23 +365,23 @@ void Renderer::SetUniformFromProperty( BufferIndex bufferIndex, Program& program } } -bool Renderer::BindTextures( Context& context, Program& program, Vector& boundTextures ) +bool Renderer::BindTextures(Context& context, Program& program, Vector& boundTextures) { uint32_t textureUnit = 0; - bool result = true; + bool result = true; - GLint uniformLocation(-1); - std::vector& samplers( mRenderDataProvider->GetSamplers() ); - std::vector& textures( mRenderDataProvider->GetTextures() ); - for( uint32_t i = 0; i < static_cast( textures.size() ) && result; ++i ) // not expecting more than uint32_t of textures + GLint uniformLocation(-1); + std::vector& samplers(mRenderDataProvider->GetSamplers()); + std::vector& textures(mRenderDataProvider->GetTextures()); + for(uint32_t i = 0; i < static_cast(textures.size()) && result; ++i) // not expecting more than uint32_t of textures { - if( textures[i] ) + if(textures[i]) { - result = textures[i]->Bind(context, textureUnit, samplers[i] ); - boundTextures.PushBack( textures[i]->GetId() ); - if( result && program.GetSamplerUniformLocation( i, uniformLocation ) ) + result = textures[i]->Bind(context, textureUnit, samplers[i]); + boundTextures.PushBack(textures[i]->GetId()); + if(result && program.GetSamplerUniformLocation(i, uniformLocation)) { - program.SetUniform1i( uniformLocation, textureUnit ); + program.SetUniform1i(uniformLocation, textureUnit); ++textureUnit; } } @@ -383,52 +390,52 @@ bool Renderer::BindTextures( Context& context, Program& program, Vector& return result; } -void Renderer::SetFaceCullingMode( FaceCullingMode::Type mode ) +void Renderer::SetFaceCullingMode(FaceCullingMode::Type mode) { - mFaceCullingMode = mode; - mUpdated = true; + mFaceCullingMode = mode; + mUpdated = true; } -void Renderer::SetBlendingBitMask( uint32_t bitmask ) +void Renderer::SetBlendingBitMask(uint32_t bitmask) { - mBlendingOptions.SetBitmask( bitmask ); + mBlendingOptions.SetBitmask(bitmask); mUpdated = true; } -void Renderer::SetBlendColor( const Vector4& color ) +void Renderer::SetBlendColor(const Vector4& color) { - mBlendingOptions.SetBlendColor( color ); + mBlendingOptions.SetBlendColor(color); mUpdated = true; } -void Renderer::SetIndexedDrawFirstElement( uint32_t firstElement ) +void Renderer::SetIndexedDrawFirstElement(uint32_t firstElement) { mIndexedDrawFirstElement = firstElement; - mUpdated = true; + mUpdated = true; } -void Renderer::SetIndexedDrawElementsCount( uint32_t elementsCount ) +void Renderer::SetIndexedDrawElementsCount(uint32_t elementsCount) { mIndexedDrawElementsCount = elementsCount; - mUpdated = true; + mUpdated = true; } -void Renderer::EnablePreMultipliedAlpha( bool enable ) +void Renderer::EnablePreMultipliedAlpha(bool enable) { mPremultipledAlphaEnabled = enable; - mUpdated = true; + mUpdated = true; } -void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode ) +void Renderer::SetDepthWriteMode(DepthWriteMode::Type depthWriteMode) { mDepthWriteMode = depthWriteMode; - mUpdated = true; + mUpdated = true; } -void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode ) +void Renderer::SetDepthTestMode(DepthTestMode::Type depthTestMode) { mDepthTestMode = depthTestMode; - mUpdated = true; + mUpdated = true; } DepthWriteMode::Type Renderer::GetDepthWriteMode() const @@ -441,10 +448,10 @@ DepthTestMode::Type Renderer::GetDepthTestMode() const return mDepthTestMode; } -void Renderer::SetDepthFunction( DepthFunction::Type depthFunction ) +void Renderer::SetDepthFunction(DepthFunction::Type depthFunction) { mDepthFunction = depthFunction; - mUpdated = true; + mUpdated = true; } DepthFunction::Type Renderer::GetDepthFunction() const @@ -452,10 +459,10 @@ DepthFunction::Type Renderer::GetDepthFunction() const return mDepthFunction; } -void Renderer::SetRenderMode( RenderMode::Type renderMode ) +void Renderer::SetRenderMode(RenderMode::Type renderMode) { mStencilParameters.renderMode = renderMode; - mUpdated = true; + mUpdated = true; } RenderMode::Type Renderer::GetRenderMode() const @@ -463,10 +470,10 @@ RenderMode::Type Renderer::GetRenderMode() const return mStencilParameters.renderMode; } -void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction ) +void Renderer::SetStencilFunction(StencilFunction::Type stencilFunction) { mStencilParameters.stencilFunction = stencilFunction; - mUpdated = true; + mUpdated = true; } StencilFunction::Type Renderer::GetStencilFunction() const @@ -474,10 +481,10 @@ StencilFunction::Type Renderer::GetStencilFunction() const return mStencilParameters.stencilFunction; } -void Renderer::SetStencilFunctionMask( int stencilFunctionMask ) +void Renderer::SetStencilFunctionMask(int stencilFunctionMask) { mStencilParameters.stencilFunctionMask = stencilFunctionMask; - mUpdated = true; + mUpdated = true; } int Renderer::GetStencilFunctionMask() const @@ -485,10 +492,10 @@ int Renderer::GetStencilFunctionMask() const return mStencilParameters.stencilFunctionMask; } -void Renderer::SetStencilFunctionReference( int stencilFunctionReference ) +void Renderer::SetStencilFunctionReference(int stencilFunctionReference) { mStencilParameters.stencilFunctionReference = stencilFunctionReference; - mUpdated = true; + mUpdated = true; } int Renderer::GetStencilFunctionReference() const @@ -496,10 +503,10 @@ int Renderer::GetStencilFunctionReference() const return mStencilParameters.stencilFunctionReference; } -void Renderer::SetStencilMask( int stencilMask ) +void Renderer::SetStencilMask(int stencilMask) { mStencilParameters.stencilMask = stencilMask; - mUpdated = true; + mUpdated = true; } int Renderer::GetStencilMask() const @@ -507,10 +514,10 @@ int Renderer::GetStencilMask() const return mStencilParameters.stencilMask; } -void Renderer::SetStencilOperationOnFail( StencilOperation::Type stencilOperationOnFail ) +void Renderer::SetStencilOperationOnFail(StencilOperation::Type stencilOperationOnFail) { mStencilParameters.stencilOperationOnFail = stencilOperationOnFail; - mUpdated = true; + mUpdated = true; } StencilOperation::Type Renderer::GetStencilOperationOnFail() const @@ -518,10 +525,10 @@ StencilOperation::Type Renderer::GetStencilOperationOnFail() const return mStencilParameters.stencilOperationOnFail; } -void Renderer::SetStencilOperationOnZFail( StencilOperation::Type stencilOperationOnZFail ) +void Renderer::SetStencilOperationOnZFail(StencilOperation::Type stencilOperationOnZFail) { mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail; - mUpdated = true; + mUpdated = true; } StencilOperation::Type Renderer::GetStencilOperationOnZFail() const @@ -529,10 +536,10 @@ StencilOperation::Type Renderer::GetStencilOperationOnZFail() const return mStencilParameters.stencilOperationOnZFail; } -void Renderer::SetStencilOperationOnZPass( StencilOperation::Type stencilOperationOnZPass ) +void Renderer::SetStencilOperationOnZPass(StencilOperation::Type stencilOperationOnZPass) { mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass; - mUpdated = true; + mUpdated = true; } StencilOperation::Type Renderer::GetStencilOperationOnZPass() const @@ -540,37 +547,37 @@ StencilOperation::Type Renderer::GetStencilOperationOnZPass() const return mStencilParameters.stencilOperationOnZPass; } -void Renderer::Upload( Context& context ) +void Renderer::Upload(Context& context) { - mGeometry->Upload( context ); + mGeometry->Upload(context); } -void Renderer::Render( Context& context, - BufferIndex bufferIndex, - const SceneGraph::NodeDataProvider& node, - const Matrix& modelMatrix, - const Matrix& modelViewMatrix, - const Matrix& viewMatrix, - const Matrix& projectionMatrix, - const Vector3& size, - bool blend, - Vector& boundTextures, - const Dali::Internal::SceneGraph::RenderInstruction& instruction, - uint32_t queueIndex ) +void Renderer::Render(Context& context, + BufferIndex bufferIndex, + const SceneGraph::NodeDataProvider& node, + const Matrix& modelMatrix, + const Matrix& modelViewMatrix, + const Matrix& viewMatrix, + const Matrix& projectionMatrix, + const Vector3& size, + bool blend, + Vector& boundTextures, + const Dali::Internal::SceneGraph::RenderInstruction& instruction, + uint32_t queueIndex) { // Before doing anything test if the call happens in the right queue - if( mDrawCommands.empty() && queueIndex > 0 ) + if(mDrawCommands.empty() && queueIndex > 0) { return; } // Prepare commands std::vector commands; - for( auto& cmd : mDrawCommands ) + for(auto& cmd : mDrawCommands) { if(cmd.queue == queueIndex) { - commands.emplace_back( &cmd ); + commands.emplace_back(&cmd); } } @@ -580,20 +587,23 @@ void Renderer::Render( Context& context, return; } - // Get the program to use: - Program* program = mRenderDataProvider->GetShader().GetProgram(); - if( !program ) + // Get the program to use + // The program cache owns the Program object so we don't need to worry about this raw allocation here. + ShaderDataPtr shaderData = mRenderDataProvider->GetShader().GetShaderData(); + Program* program = Program::New(*mProgramCache, shaderData, (shaderData->GetHints() & Dali::Shader::Hint::MODIFIES_GEOMETRY) != 0x0); + + if(!program) { - DALI_LOG_ERROR( "Failed to get program for shader at address %p.\n", reinterpret_cast< void* >( &mRenderDataProvider->GetShader() ) ); + DALI_LOG_ERROR("Failed to get program for shader at address %p.\n", reinterpret_cast(&mRenderDataProvider->GetShader())); return; } //Set cull face mode const Dali::Internal::SceneGraph::Camera* cam = instruction.GetCamera(); - if (cam->GetReflectionUsed()) + if(cam->GetReflectionUsed()) { auto adjFaceCullingMode = mFaceCullingMode; - switch( mFaceCullingMode ) + switch(mFaceCullingMode) { case FaceCullingMode::Type::FRONT: { @@ -610,67 +620,71 @@ void Renderer::Render( Context& context, // nothing to do, leave culling as it is } } - context.CullFace( adjFaceCullingMode ); + context.CullFace(adjFaceCullingMode); } else { - context.CullFace( mFaceCullingMode ); + context.CullFace(mFaceCullingMode); } // Take the program into use so we can send uniforms to it program->Use(); - if( DALI_LIKELY( BindTextures( context, *program, boundTextures ) ) ) + if(DALI_LIKELY(BindTextures(context, *program, boundTextures))) { // Only set up and draw if we have textures and they are all valid // set projection and view matrix if program has not yet received them yet this frame - SetMatrices( *program, modelMatrix, viewMatrix, projectionMatrix, modelViewMatrix ); + SetMatrices(*program, modelMatrix, viewMatrix, projectionMatrix, modelViewMatrix); // set color uniform - GLint loc = program->GetUniformLocation( Program::UNIFORM_COLOR ); - if( Program::UNIFORM_UNKNOWN != loc ) + GLint loc = program->GetUniformLocation(Program::UNIFORM_COLOR); + if(Program::UNIFORM_UNKNOWN != loc) { - const Vector4& color = node.GetRenderColor( bufferIndex ); - if( mPremultipledAlphaEnabled ) + const Vector4& color = node.GetRenderColor(bufferIndex); + if(mPremultipledAlphaEnabled) { - float alpha = color.a * mRenderDataProvider->GetOpacity( bufferIndex ); - program->SetUniform4f( loc, color.r * alpha, color.g * alpha, color.b * alpha, alpha ); + float alpha = color.a * mRenderDataProvider->GetOpacity(bufferIndex); + program->SetUniform4f(loc, color.r * alpha, color.g * alpha, color.b * alpha, alpha); } else { - program->SetUniform4f( loc, color.r, color.g, color.b, color.a * mRenderDataProvider->GetOpacity( bufferIndex ) ); + program->SetUniform4f(loc, color.r, color.g, color.b, color.a * mRenderDataProvider->GetOpacity(bufferIndex)); } } - SetUniforms( bufferIndex, node, size, *program ); + SetUniforms(bufferIndex, node, size, *program); - if( mUpdateAttributesLocation || mGeometry->AttributesChanged() ) + if(mUpdateAttributesLocation || mGeometry->AttributesChanged()) { - mGeometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex ); + mGeometry->GetAttributeLocationFromProgram(mAttributesLocation, *program, bufferIndex); mUpdateAttributesLocation = false; } + if(mBlendingOptions.IsAdvancedBlendEquationApplied() && mPremultipledAlphaEnabled) + { + context.BlendBarrier(); + } + if(mDrawCommands.empty()) { - SetBlending( context, blend ); + SetBlending(context, blend); - mGeometry->Draw( context, - bufferIndex, - mAttributesLocation, - mIndexedDrawFirstElement, - mIndexedDrawElementsCount ); + mGeometry->Draw(context, + bufferIndex, + mAttributesLocation, + mIndexedDrawFirstElement, + mIndexedDrawElementsCount); } else { - for(auto& cmd : commands ) + for(auto& cmd : commands) { - if(cmd->queue == queueIndex ) + if(cmd->queue == queueIndex) { //Set blending mode SetBlending(context, cmd->queue == DevelRenderer::RENDER_QUEUE_OPAQUE ? false : blend); - mGeometry->Draw(context, bufferIndex, mAttributesLocation, - cmd->firstIndex, cmd->elementCount); + mGeometry->Draw(context, bufferIndex, mAttributesLocation, cmd->firstIndex, cmd->elementCount); } } } @@ -678,55 +692,54 @@ void Renderer::Render( Context& context, } } -void Renderer::SetSortAttributes( BufferIndex bufferIndex, - SceneGraph::RenderInstructionProcessor::SortAttributes& sortAttributes ) const +void Renderer::SetSortAttributes(BufferIndex bufferIndex, + SceneGraph::RenderInstructionProcessor::SortAttributes& sortAttributes) const { - sortAttributes.shader = &( mRenderDataProvider->GetShader() ); + sortAttributes.shader = &(mRenderDataProvider->GetShader()); sortAttributes.geometry = mGeometry; } -void Renderer::SetShaderChanged( bool value ) +void Renderer::SetShaderChanged(bool value) { mShaderChanged = value; } bool Renderer::Updated(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider* node) { - if (mUpdated) + if(mUpdated) { mUpdated = false; return true; } - if (mShaderChanged || mUpdateAttributesLocation || mGeometry->AttributesChanged()) + if(mShaderChanged || mUpdateAttributesLocation || mGeometry->AttributesChanged()) { return true; } - std::vector textures = mRenderDataProvider->GetTextures(); - for (Render::Texture* texture : textures) + for(const auto& texture : mRenderDataProvider->GetTextures()) { - if (texture && texture->IsNativeImage()) + if(texture && texture->IsNativeImage()) { return true; } } - uint64_t hash = 0xc70f6907UL; - const SceneGraph::CollectedUniformMap& uniformMapNode = node->GetUniformMap( bufferIndex ); - for (const auto* uniformProperty : uniformMapNode) + uint64_t hash = 0xc70f6907UL; + const SceneGraph::CollectedUniformMap& uniformMapNode = node->GetUniformMap(bufferIndex); + for(const auto& uniformProperty : uniformMapNode) { - hash = uniformProperty->propertyPtr->Hash(bufferIndex, hash); + hash = uniformProperty.propertyPtr->Hash(bufferIndex, hash); } const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap(); - const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap( bufferIndex ); - for (const auto* uniformProperty : uniformMap) + const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap(bufferIndex); + for(const auto& uniformProperty : uniformMap) { - hash = uniformProperty->propertyPtr->Hash(bufferIndex, hash); + hash = uniformProperty.propertyPtr->Hash(bufferIndex, hash); } - if (mUniformsHash != hash) + if(mUniformsHash != hash) { mUniformsHash = hash; return true; @@ -735,7 +748,7 @@ bool Renderer::Updated(BufferIndex bufferIndex, const SceneGraph::NodeDataProvid return false; } -} // namespace SceneGraph +} // namespace Render } // namespace Internal