X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-renderer.cpp;h=e3f16848641fd6be3e465a14a7b5bf05b39c790b;hb=e8e38595cefb3d47ae789b26ce4581f518f18662;hp=b48e1d88969e2a7a90b9d1ee351cac6b56affe3d;hpb=0e878187e31cf1ea5a7786f311051b0667667c30;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 b48e1d8..e3f1684 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 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. @@ -18,7 +18,6 @@ // CLASS HEADER #include - // INTERNAL INCLUDES #include #include @@ -26,10 +25,6 @@ #include #include #include -#include -#include -#include -#include namespace Dali { @@ -40,8 +35,6 @@ namespace Internal namespace { -static Matrix gModelViewProjectionMatrix( false ); ///< a shared matrix to calculate the MVP matrix, dont want to store it in object to reduce storage overhead -static Matrix3 gNormalMatrix; ///< a shared matrix to calculate normal matrix, dont want to store it in object to reduce storage overhead /** * Helper to set view and projection matrices once per program @@ -91,17 +84,19 @@ inline void SetMatrices( Program& program, loc = program.GetUniformLocation( Program::UNIFORM_MVP_MATRIX ); if( Program::UNIFORM_UNKNOWN != loc ) { - Matrix::Multiply( gModelViewProjectionMatrix, modelViewMatrix, projectionMatrix ); - program.SetUniformMatrix4fv( loc, 1, gModelViewProjectionMatrix.AsFloat() ); + Matrix modelViewProjectionMatrix(false); + Matrix::Multiply( modelViewProjectionMatrix, modelViewMatrix, projectionMatrix ); + program.SetUniformMatrix4fv( loc, 1, modelViewProjectionMatrix.AsFloat() ); } loc = program.GetUniformLocation( Program::UNIFORM_NORMAL_MATRIX ); if( Program::UNIFORM_UNKNOWN != loc ) { - gNormalMatrix = modelViewMatrix; - gNormalMatrix.Invert(); - gNormalMatrix.Transpose(); - program.SetUniformMatrix3fv( loc, 1, gNormalMatrix.AsFloat() ); + Matrix3 normalMatrix; + normalMatrix = modelViewMatrix; + normalMatrix.Invert(); + normalMatrix.Transpose(); + program.SetUniformMatrix3fv( loc, 1, normalMatrix.AsFloat() ); } } @@ -111,76 +106,71 @@ namespace Render { Renderer* Renderer::New( SceneGraph::RenderDataProvider* dataProvider, - SceneGraph::RenderGeometry* renderGeometry, - unsigned int blendingBitmask, - const Vector4* blendColor, - Dali::Renderer::FaceCullingMode faceCullingMode, - bool preMultipliedAlphaEnabled ) + 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, renderGeometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled ); + return new Renderer( dataProvider, geometry, blendingBitmask, blendColor, + faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, + depthFunction, stencilParameters ); } Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider, - SceneGraph::RenderGeometry* renderGeometry, - unsigned int blendingBitmask, - const Vector4* blendColor, - Dali::Renderer::FaceCullingMode faceCullingMode, - bool preMultipliedAlphaEnabled) + 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), - mTextureCache( NULL ), - mUniformNameCache( NULL ), - mRenderGeometry( renderGeometry ), + mContext( NULL), + mGeometry( geometry ), mUniformIndexMap(), mAttributesLocation(), + mStencilParameters( stencilParameters ), mBlendingOptions(), - mFaceCullingMode( faceCullingMode ), - mSamplerBitfield( ImageSampler::PackBitfield( FilterMode::DEFAULT, FilterMode::DEFAULT ) ), + mIndexedDrawFirstElement( 0 ), + mIndexedDrawElementsCount( 0 ), + mDepthFunction( depthFunction ), + mFaceCullingMode( faceCullingMode ), + mDepthWriteMode( depthWriteMode ), + mDepthTestMode( depthTestMode ), mUpdateAttributesLocation( true ), - mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ) + mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ), + mShaderChanged( false ) { - if( blendingBitmask != 0u ) + if( blendingBitmask != 0u ) { mBlendingOptions.SetBitmask( blendingBitmask ); } - if( blendColor ) - { - mBlendingOptions.SetBlendColor( *blendColor ); - } + mBlendingOptions.SetBlendColor( blendColor ); } -void Renderer::Initialize( Context& context, SceneGraph::TextureCache& textureCache, Render::UniformNameCache& uniformNameCache ) +void Renderer::Initialize( Context& context ) { mContext = &context; - mTextureCache = &textureCache; - mUniformNameCache = &uniformNameCache; } Renderer::~Renderer() { } -void Renderer::SetRenderDataProvider( SceneGraph::RenderDataProvider* dataProvider ) -{ - mRenderDataProvider = dataProvider; - mUpdateAttributesLocation = true; -} - -void Renderer::SetGeometry( SceneGraph::RenderGeometry* renderGeometry ) +void Renderer::SetGeometry( Render::Geometry* geometry ) { - mRenderGeometry = renderGeometry; + mGeometry = geometry; mUpdateAttributesLocation = true; } -// Note - this is currently called from UpdateThread, PrepareRenderInstructions, -// as an optimisation. -// @todo MESH_REWORK Should use Update thread objects only in PrepareRenderInstructions. -bool Renderer::RequiresDepthTest() const -{ - return mRenderGeometry->RequiresDepthTest(); -} - void Renderer::SetBlending( Context& context, bool blend ) { context.SetBlend( blend ); @@ -211,7 +201,7 @@ void Renderer::SetBlending( Context& context, bool blend ) void Renderer::GlContextDestroyed() { - mRenderGeometry->GlContextDestroyed(); + mGeometry->GlContextDestroyed(); } void Renderer::GlCleanup() @@ -226,27 +216,32 @@ void Renderer::SetUniforms( BufferIndex bufferIndex, const SceneGraph::NodeDataP const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap(); if( uniformMapDataProvider.GetUniformMapChanged( bufferIndex ) || - node.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 ); - unsigned int maxMaps = uniformMap.Count() + uniformMapNode.Count(); + 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 ); - unsigned int mapIndex(0); + uint32_t mapIndex = 0; for(; mapIndex < uniformMap.Count() ; ++mapIndex ) { mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex]->propertyPtr; mUniformIndexMap[mapIndex].uniformIndex = program.RegisterUniform( uniformMap[mapIndex]->uniformName ); } - for( unsigned int nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count() ; ++nodeMapIndex ) + for( uint32_t nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count() ; ++nodeMapIndex ) { - unsigned int uniformIndex = program.RegisterUniform( uniformMapNode[nodeMapIndex]->uniformName ); + uint32_t uniformIndex = program.RegisterUniform( uniformMapNode[nodeMapIndex]->uniformName ); bool found(false); - for( unsigned int i(0); i& boundTextures ) { - int textureUnit = 0; + uint32_t textureUnit = 0; bool result = true; - std::vector& textures( mRenderDataProvider->GetTextures() ); - for( size_t i(0); result && i& 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 { - ResourceId textureId = textures[i].GetTextureId(); - Internal::Texture* texture = textureCache.GetTexture( textureId ); - if( texture ) + if( textures[i] ) { - result = textureCache.BindTexture( texture, textureId, GL_TEXTURE_2D, (TextureUnit)textureUnit ); - - if( result ) + result = textures[i]->Bind(context, textureUnit, samplers[i] ); + boundTextures.PushBack( textures[i]->GetId() ); + if( result && program.GetSamplerUniformLocation( i, uniformLocation ) ) { - GLint uniformLocation; - - bool result = program.GetSamplerUniformLocation( i, uniformLocation ); - if( result && Program::UNIFORM_UNKNOWN != uniformLocation ) - { - program.SetUniform1i( uniformLocation, textureUnit ); - - unsigned int samplerBitfield(0); - Render::Texture& textureMapping = textures[i]; - const Render::Sampler* sampler( textureMapping.GetSampler() ); - if( sampler ) - { - samplerBitfield = ImageSampler::PackBitfield( - static_cast< FilterMode::Type >(sampler->GetMinifyFilterMode()), - static_cast< FilterMode::Type >(sampler->GetMagnifyFilterMode()), - static_cast< WrapMode::Type >(sampler->GetUWrapMode()), - static_cast< WrapMode::Type >(sampler->GetVWrapMode()) - ); - } - else - { - samplerBitfield = ImageSampler::DEFAULT_BITFIELD; - } - - texture->ApplySampler( (TextureUnit)textureUnit, samplerBitfield ); - - ++textureUnit; - } + program.SetUniform1i( uniformLocation, textureUnit ); + ++textureUnit; } } } + return result; } -void Renderer::SetFaceCullingMode( Dali::Renderer::FaceCullingMode mode ) +void Renderer::SetFaceCullingMode( FaceCullingMode::Type mode ) { mFaceCullingMode = mode; } -void Renderer::SetBlendingBitMask( unsigned int bitmask ) +void Renderer::SetBlendingBitMask( uint32_t bitmask ) { mBlendingOptions.SetBitmask( bitmask ); } -void Renderer::SetBlendColor( const Vector4* color ) +void Renderer::SetBlendColor( const Vector4& color ) +{ + mBlendingOptions.SetBlendColor( color ); +} + +void Renderer::SetIndexedDrawFirstElement( uint32_t firstElement ) +{ + mIndexedDrawFirstElement = firstElement; +} + +void Renderer::SetIndexedDrawElementsCount( uint32_t elementsCount ) { - mBlendingOptions.SetBlendColor( *color ); + mIndexedDrawElementsCount = elementsCount; } void Renderer::EnablePreMultipliedAlpha( bool enable ) @@ -422,34 +402,138 @@ void Renderer::EnablePreMultipliedAlpha( bool enable ) mPremultipledAlphaEnabled = enable; } -void Renderer::SetSampler( unsigned int samplerBitfield ) +void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode ) +{ + mDepthWriteMode = depthWriteMode; +} + +void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode ) +{ + mDepthTestMode = depthTestMode; +} + +DepthWriteMode::Type Renderer::GetDepthWriteMode() const +{ + return mDepthWriteMode; +} + +DepthTestMode::Type Renderer::GetDepthTestMode() const +{ + return mDepthTestMode; +} + +void Renderer::SetDepthFunction( DepthFunction::Type depthFunction ) +{ + mDepthFunction = depthFunction; +} + +DepthFunction::Type Renderer::GetDepthFunction() const +{ + return mDepthFunction; +} + +void Renderer::SetRenderMode( RenderMode::Type renderMode ) +{ + mStencilParameters.renderMode = renderMode; +} + +RenderMode::Type Renderer::GetRenderMode() const +{ + return mStencilParameters.renderMode; +} + +void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction ) +{ + mStencilParameters.stencilFunction = stencilFunction; +} + +StencilFunction::Type Renderer::GetStencilFunction() const +{ + return mStencilParameters.stencilFunction; +} + +void Renderer::SetStencilFunctionMask( int stencilFunctionMask ) +{ + mStencilParameters.stencilFunctionMask = stencilFunctionMask; +} + +int Renderer::GetStencilFunctionMask() const +{ + return mStencilParameters.stencilFunctionMask; +} + +void Renderer::SetStencilFunctionReference( int stencilFunctionReference ) +{ + mStencilParameters.stencilFunctionReference = stencilFunctionReference; +} + +int Renderer::GetStencilFunctionReference() const +{ + return mStencilParameters.stencilFunctionReference; +} + +void Renderer::SetStencilMask( int stencilMask ) +{ + mStencilParameters.stencilMask = stencilMask; +} + +int Renderer::GetStencilMask() const +{ + return mStencilParameters.stencilMask; +} + +void Renderer::SetStencilOperationOnFail( StencilOperation::Type stencilOperationOnFail ) +{ + mStencilParameters.stencilOperationOnFail = stencilOperationOnFail; +} + +StencilOperation::Type Renderer::GetStencilOperationOnFail() const +{ + return mStencilParameters.stencilOperationOnFail; +} + +void Renderer::SetStencilOperationOnZFail( StencilOperation::Type stencilOperationOnZFail ) +{ + mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail; +} + +StencilOperation::Type Renderer::GetStencilOperationOnZFail() const +{ + return mStencilParameters.stencilOperationOnZFail; +} + +void Renderer::SetStencilOperationOnZPass( StencilOperation::Type stencilOperationOnZPass ) +{ + mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass; +} + +StencilOperation::Type Renderer::GetStencilOperationOnZPass() const +{ + return mStencilParameters.stencilOperationOnZPass; +} + +void Renderer::Upload( Context& context ) { - mSamplerBitfield = samplerBitfield; + mGeometry->Upload( context ); } void Renderer::Render( Context& context, - SceneGraph::TextureCache& textureCache, BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, - SceneGraph::Shader& defaultShader, + const Matrix& modelMatrix, const Matrix& modelViewMatrix, const Matrix& viewMatrix, const Matrix& projectionMatrix, const Vector3& size, - bool blend ) + bool blend, + Vector& boundTextures ) { // Get the program to use: Program* program = mRenderDataProvider->GetShader().GetProgram(); if( !program ) { - // if program is NULL it means this is a custom shader with non matching geometry type so we need to use default shaders program - program = defaultShader.GetProgram(); - DALI_ASSERT_DEBUG( program && "Default shader should always have a program available." ); - if( !program ) - { - DALI_LOG_ERROR( "Failed to get program for shader at address %p.", (void*)&mRenderDataProvider->GetShader() ); - return; - } + DALI_LOG_ERROR( "Failed to get program for shader at address %p.\n", reinterpret_cast< void* >( &mRenderDataProvider->GetShader() ) ); + return; } //Set cull face mode @@ -461,12 +545,12 @@ void Renderer::Render( Context& context, // Take the program into use so we can send uniforms to it program->Use(); - if( DALI_LIKELY( BindTextures( textureCache, *program ) ) ) + 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, node.GetModelMatrix( bufferIndex ), viewMatrix, projectionMatrix, modelViewMatrix ); + SetMatrices( *program, modelMatrix, viewMatrix, projectionMatrix, modelViewMatrix ); // set color uniform GLint loc = program->GetUniformLocation( Program::UNIFORM_COLOR ); @@ -475,40 +559,41 @@ void Renderer::Render( Context& context, const Vector4& color = node.GetRenderColor( bufferIndex ); if( mPremultipledAlphaEnabled ) { - program->SetUniform4f( loc, color.r*color.a, color.g*color.a, color.b*color.a, color.a ); + 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 ); + 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 || mRenderGeometry->AttributesChanged() ) + if( mUpdateAttributesLocation || mGeometry->AttributesChanged() ) { - mRenderGeometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex ); + mGeometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex ); mUpdateAttributesLocation = false; } - mRenderGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation ); + mGeometry->Draw( context, + bufferIndex, + mAttributesLocation, + mIndexedDrawFirstElement, + mIndexedDrawElementsCount ); } } -void Renderer::SetSortAttributes( BufferIndex bufferIndex, SceneGraph::RendererWithSortAttributes& sortAttributes ) const +void Renderer::SetSortAttributes( BufferIndex bufferIndex, + SceneGraph::RenderInstructionProcessor::SortAttributes& sortAttributes ) const { sortAttributes.shader = &( mRenderDataProvider->GetShader() ); - const std::vector& textures( mRenderDataProvider->GetTextures() ); - if( !textures.empty() ) - { - sortAttributes.textureResourceId = textures[0].GetTextureId(); - } - else - { - sortAttributes.textureResourceId = Integration::InvalidResourceId; - } + sortAttributes.geometry = mGeometry; +} - sortAttributes.geometry = mRenderGeometry; +void Renderer::SetShaderChanged( bool value ) +{ + mShaderChanged = value; } } // namespace SceneGraph