X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Frendering%2Frenderer-impl.cpp;h=4342d90b8d4c7a89d592c24323e9c74eebfb4d4f;hb=50f6f9022d087132cfdc1eb2bdc59a3ca2d49b6f;hp=e109bf666575d3439c6500968d894e29db652aff;hpb=d59644fcad10ca4a10882ceb6c3bc3ac4a324373;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/rendering/renderer-impl.cpp b/dali/internal/event/rendering/renderer-impl.cpp index e109bf6..4342d90 100644 --- a/dali/internal/event/rendering/renderer-impl.cpp +++ b/dali/internal/event/rendering/renderer-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 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. @@ -19,159 +19,278 @@ #include // Dali::Internal::Renderer // INTERNAL INCLUDES -#include -#include // Dali::Renderer -#include // Dali::Internal::ObjectHelper +#include #include // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END #include -#include +#include #include +#include +#include namespace Dali { namespace Internal { - namespace { - /** - * |name |type |writable|animatable|constraint-input|enum for index-checking| + * Properties: |name |type |writable|animatable|constraint-input|enum for index-checking| */ DALI_PROPERTY_TABLE_BEGIN -DALI_PROPERTY( "depthIndex", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_INDEX ) -DALI_PROPERTY( "faceCullingMode", INTEGER, true, false, false, Dali::Renderer::Property::FACE_CULLING_MODE ) -DALI_PROPERTY( "blendingMode", INTEGER, true, false, false, Dali::Renderer::Property::BLENDING_MODE ) -DALI_PROPERTY( "blendEquationRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_RGB ) -DALI_PROPERTY( "blendEquationAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_ALPHA ) -DALI_PROPERTY( "sourceBlendFactorRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLENDING_SRC_FACTOR_RGB ) -DALI_PROPERTY( "destinationBlendFactorRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLENDING_DEST_FACTOR_RGB ) -DALI_PROPERTY( "sourceBlendFactorAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLENDING_SRC_FACTOR_ALPHA ) -DALI_PROPERTY( "destinationBlendFactorAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLENDING_DEST_FACTOR_ALPHA ) -DALI_PROPERTY( "blendingColor", VECTOR4, true, false, false, Dali::Renderer::Property::BLENDING_COLOR ) -DALI_PROPERTY( "blendPreMultipliedAlpha", BOOLEAN, true, false, false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA ) -DALI_PROPERTY( "indexRangeFirst", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_FIRST ) -DALI_PROPERTY( "indexRangeCount", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_COUNT ) -DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX ) - -const ObjectImplHelper RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS }; +DALI_PROPERTY("depthIndex", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_INDEX) +DALI_PROPERTY("faceCullingMode", INTEGER, true, false, false, Dali::Renderer::Property::FACE_CULLING_MODE) +DALI_PROPERTY("blendMode", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_MODE) +DALI_PROPERTY("blendEquationRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_RGB) +DALI_PROPERTY("blendEquationAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_ALPHA) +DALI_PROPERTY("blendFactorSrcRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB) +DALI_PROPERTY("blendFactorDestRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB) +DALI_PROPERTY("blendFactorSrcAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA) +DALI_PROPERTY("blendFactorDestAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA) +DALI_PROPERTY("blendColor", VECTOR4, true, false, false, Dali::Renderer::Property::BLEND_COLOR) +DALI_PROPERTY("blendPreMultipliedAlpha", BOOLEAN, true, false, false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA) +DALI_PROPERTY("indexRangeFirst", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_FIRST) +DALI_PROPERTY("indexRangeCount", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_COUNT) +DALI_PROPERTY("depthWriteMode", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_WRITE_MODE) +DALI_PROPERTY("depthFunction", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_FUNCTION) +DALI_PROPERTY("depthTestMode", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_TEST_MODE) +DALI_PROPERTY("renderMode", INTEGER, true, false, false, Dali::Renderer::Property::RENDER_MODE) +DALI_PROPERTY("stencilFunction", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION) +DALI_PROPERTY("stencilFunctionMask", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION_MASK) +DALI_PROPERTY("stencilFunctionReference", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE) +DALI_PROPERTY("stencilMask", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_MASK) +DALI_PROPERTY("stencilOperationOnFail", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL) +DALI_PROPERTY("stencilOperationOnZFail", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL) +DALI_PROPERTY("stencilOperationOnZPass", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS) +DALI_PROPERTY("opacity", FLOAT, true, true, true, Dali::DevelRenderer::Property::OPACITY) +DALI_PROPERTY("renderingBehavior", INTEGER, true, false, false, Dali::DevelRenderer::Property::RENDERING_BEHAVIOR) +DALI_PROPERTY("blendEquation", INTEGER, true, false, false, Dali::DevelRenderer::Property::BLEND_EQUATION) +DALI_PROPERTY_TABLE_END(DEFAULT_RENDERER_PROPERTY_START_INDEX, RendererDefaultProperties) + +// Property string to enumeration tables: + +DALI_ENUM_TO_STRING_TABLE_BEGIN(FACE_CULLING_MODE) + DALI_ENUM_TO_STRING_WITH_SCOPE(FaceCullingMode, NONE) + DALI_ENUM_TO_STRING_WITH_SCOPE(FaceCullingMode, FRONT) + DALI_ENUM_TO_STRING_WITH_SCOPE(FaceCullingMode, BACK) + DALI_ENUM_TO_STRING_WITH_SCOPE(FaceCullingMode, FRONT_AND_BACK) +DALI_ENUM_TO_STRING_TABLE_END(FACE_CULLING_MODE) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(BLEND_MODE) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendMode, OFF) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendMode, AUTO) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendMode, ON) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendMode, ON_WITHOUT_CULL) +DALI_ENUM_TO_STRING_TABLE_END(BLEND_MODE) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(BLEND_EQUATION) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendEquation, ADD) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendEquation, SUBTRACT) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendEquation, REVERSE_SUBTRACT) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, MIN) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, MAX) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, MULTIPLY) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, SCREEN) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, OVERLAY) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, DARKEN) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, LIGHTEN) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, COLOR_DODGE) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, COLOR_BURN) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, HARD_LIGHT) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, SOFT_LIGHT) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, DIFFERENCE) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, EXCLUSION) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, HUE) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, SATURATION) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelBlendEquation, LUMINOSITY) +DALI_ENUM_TO_STRING_TABLE_END(BLEND_EQUATION) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(BLEND_FACTOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ZERO) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ONE) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, SRC_COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ONE_MINUS_SRC_COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, SRC_ALPHA) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ONE_MINUS_SRC_ALPHA) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, DST_ALPHA) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ONE_MINUS_DST_ALPHA) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, DST_COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ONE_MINUS_DST_COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, SRC_ALPHA_SATURATE) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, CONSTANT_COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ONE_MINUS_CONSTANT_COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, CONSTANT_ALPHA) + DALI_ENUM_TO_STRING_WITH_SCOPE(BlendFactor, ONE_MINUS_CONSTANT_ALPHA) +DALI_ENUM_TO_STRING_TABLE_END(BLEND_FACTOR) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(DEPTH_WRITE_MODE) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthWriteMode, OFF) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthWriteMode, AUTO) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthWriteMode, ON) +DALI_ENUM_TO_STRING_TABLE_END(DEPTH_WRITE_MODE) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(DEPTH_TEST_MODE) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthTestMode, OFF) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthTestMode, AUTO) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthTestMode, ON) +DALI_ENUM_TO_STRING_TABLE_END(DEPTH_TEST_MODE) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(DEPTH_FUNCTION) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, NEVER) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, ALWAYS) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, LESS) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, GREATER) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, EQUAL) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, NOT_EQUAL) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, LESS_EQUAL) + DALI_ENUM_TO_STRING_WITH_SCOPE(DepthFunction, GREATER_EQUAL) +DALI_ENUM_TO_STRING_TABLE_END(DEPTH_FUNCTION) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(STENCIL_FUNCTION) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, NEVER) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, LESS) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, EQUAL) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, LESS_EQUAL) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, GREATER) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, NOT_EQUAL) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, GREATER_EQUAL) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilFunction, ALWAYS) +DALI_ENUM_TO_STRING_TABLE_END(STENCIL_FUNCTION) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(RENDER_MODE) + DALI_ENUM_TO_STRING_WITH_SCOPE(RenderMode, NONE) + DALI_ENUM_TO_STRING_WITH_SCOPE(RenderMode, AUTO) + DALI_ENUM_TO_STRING_WITH_SCOPE(RenderMode, COLOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(RenderMode, STENCIL) + DALI_ENUM_TO_STRING_WITH_SCOPE(RenderMode, COLOR_STENCIL) +DALI_ENUM_TO_STRING_TABLE_END(RENDER_MODE) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(STENCIL_OPERATION) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, ZERO) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, KEEP) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, REPLACE) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, INCREMENT) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, DECREMENT) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, INVERT) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, INCREMENT_WRAP) + DALI_ENUM_TO_STRING_WITH_SCOPE(StencilOperation, DECREMENT_WRAP) +DALI_ENUM_TO_STRING_TABLE_END(STENCIL_OPERATION) + +DALI_ENUM_TO_STRING_TABLE_BEGIN(RENDERING_BEHAVIOR) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelRenderer::Rendering, IF_REQUIRED) + DALI_ENUM_TO_STRING_WITH_SCOPE(DevelRenderer::Rendering, CONTINUOUSLY) +DALI_ENUM_TO_STRING_TABLE_END(RENDERING_BEHAVIOR) BaseHandle Create() { return Dali::BaseHandle(); } -TypeRegistration mType( typeid( Dali::Renderer ), typeid( Dali::Handle ), Create ); +TypeRegistration mType(typeid(Dali::Renderer), typeid(Dali::Handle), Create, RendererDefaultProperties); } // unnamed namespace RendererPtr Renderer::New() { - RendererPtr rendererPtr( new Renderer() ); - rendererPtr->Initialize(); + // create scene object first so it's guaranteed to exist for the event side + auto sceneObject = SceneGraph::Renderer::New(); + OwnerPointer transferOwnership(sceneObject); + // pass the pointer to base for message passing + RendererPtr rendererPtr(new Renderer(sceneObject)); + // transfer scene object ownership to update manager + EventThreadServices& eventThreadServices = rendererPtr->GetEventThreadServices(); + SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); + AddRendererMessage(updateManager, transferOwnership); + + eventThreadServices.RegisterObject(rendererPtr.Get()); return rendererPtr; } -void Renderer::SetGeometry( Geometry& geometry ) +void Renderer::SetGeometry(Geometry& geometry) { - mGeometryConnector.Set( geometry, OnStage() ); - const SceneGraph::Geometry* geometrySceneObject = geometry.GetGeometrySceneObject(); + mGeometry = &geometry; - SetGeometryMessage( GetEventThreadServices(), *mSceneObject, *geometrySceneObject ); + const Render::Geometry* geometrySceneObject = geometry.GetRenderObject(); + SetGeometryMessage(GetEventThreadServices(), GetRendererSceneObject(), *geometrySceneObject); } -Geometry* Renderer::GetGeometry() const +GeometryPtr Renderer::GetGeometry() const { - return mGeometryConnector.Get().Get(); + return mGeometry; } -void Renderer::SetTextures( TextureSet& textureSet ) +void Renderer::SetTextures(TextureSet& textureSet) { - mTextureSetConnector.Set( textureSet, OnStage() ); + mTextureSet = &textureSet; const SceneGraph::TextureSet* textureSetSceneObject = textureSet.GetTextureSetSceneObject(); - SetTexturesMessage( GetEventThreadServices(), *mSceneObject, *textureSetSceneObject ); + SetTexturesMessage(GetEventThreadServices(), GetRendererSceneObject(), *textureSetSceneObject); } -TextureSet* Renderer::GetTextures() const +TextureSetPtr Renderer::GetTextures() const { - return mTextureSetConnector.Get().Get(); + return mTextureSet; } -void Renderer::SetShader( Shader& shader ) +void Renderer::SetShader(Shader& shader) { - mShader = &shader; - SceneGraph::Shader& sceneGraphShader = *shader.GetShaderSceneObject(); - SceneGraph::SetShaderMessage( GetEventThreadServices(), *mSceneObject, sceneGraphShader ); + mShader = &shader; + const SceneGraph::Shader& sceneGraphShader = shader.GetShaderSceneObject(); + SceneGraph::SetShaderMessage(GetEventThreadServices(), GetRendererSceneObject(), sceneGraphShader); } -Shader* Renderer::GetShader() const +ShaderPtr Renderer::GetShader() const { - return mShader.Get(); + return mShader; } -void Renderer::SetDepthIndex( int depthIndex ) +void Renderer::SetDepthIndex(int32_t depthIndex) { - if ( mDepthIndex != depthIndex ) + if(mDepthIndex != depthIndex) { mDepthIndex = depthIndex; - SetDepthIndexMessage( GetEventThreadServices(), *mSceneObject, depthIndex ); + SetDepthIndexMessage(GetEventThreadServices(), GetRendererSceneObject(), depthIndex); } } -int Renderer::GetDepthIndex() const +int32_t Renderer::GetDepthIndex() const { return mDepthIndex; } -void Renderer::SetFaceCullingMode( Dali::Renderer::FaceCullingMode cullingMode ) -{ - if( mFaceCullingMode != cullingMode ) - { - mFaceCullingMode = cullingMode; - - SetFaceCullingModeMessage( GetEventThreadServices(), *mSceneObject, mFaceCullingMode ); - } -} - -Dali::Renderer::FaceCullingMode Renderer::GetFaceCullingMode() -{ - return mFaceCullingMode; -} - -void Renderer::SetBlendMode( BlendingMode::Type mode ) +void Renderer::SetBlendMode(BlendMode::Type mode) { - if( mBlendingMode != mode ) + if(mBlendMode != mode) { - mBlendingMode = mode; + mBlendMode = mode; - SetBlendingModeMessage( GetEventThreadServices(), *mSceneObject, mBlendingMode ); + SetBlendModeMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendMode); } } -BlendingMode::Type Renderer::GetBlendMode() const +BlendMode::Type Renderer::GetBlendMode() const { - return mBlendingMode; + return mBlendMode; } -void Renderer::SetBlendFunc( BlendingFactor::Type srcFactorRgba, BlendingFactor::Type destFactorRgba ) +void Renderer::SetBlendFunc(BlendFactor::Type srcFactorRgba, BlendFactor::Type destFactorRgba) { - mBlendingOptions.SetBlendFunc( srcFactorRgba, destFactorRgba, srcFactorRgba, destFactorRgba ); - SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() ); + mBlendingOptions.SetBlendFunc(srcFactorRgba, destFactorRgba, srcFactorRgba, destFactorRgba); + SetBlendingOptionsMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendingOptions.GetBitmask()); } -void Renderer::SetBlendFunc( BlendingFactor::Type srcFactorRgb, - BlendingFactor::Type destFactorRgb, - BlendingFactor::Type srcFactorAlpha, - BlendingFactor::Type destFactorAlpha ) +void Renderer::SetBlendFunc(BlendFactor::Type srcFactorRgb, + BlendFactor::Type destFactorRgb, + BlendFactor::Type srcFactorAlpha, + BlendFactor::Type destFactorAlpha) { - mBlendingOptions.SetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() ); + mBlendingOptions.SetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + SetBlendingOptionsMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendingOptions.GetBitmask()); } -void Renderer::GetBlendFunc( BlendingFactor::Type& srcFactorRgb, - BlendingFactor::Type& destFactorRgb, - BlendingFactor::Type& srcFactorAlpha, - BlendingFactor::Type& destFactorAlpha ) const +void Renderer::GetBlendFunc(BlendFactor::Type& srcFactorRgb, + BlendFactor::Type& destFactorRgb, + BlendFactor::Type& srcFactorAlpha, + BlendFactor::Type& destFactorAlpha) const { srcFactorRgb = mBlendingOptions.GetBlendSrcFactorRgb(); destFactorRgb = mBlendingOptions.GetBlendDestFactorRgb(); @@ -179,78 +298,64 @@ void Renderer::GetBlendFunc( BlendingFactor::Type& srcFactorRgb, destFactorAlpha = mBlendingOptions.GetBlendDestFactorAlpha(); } -void Renderer::SetBlendEquation( BlendingEquation::Type equationRgba ) +void Renderer::SetBlendEquation(DevelBlendEquation::Type equationRgba) { - mBlendingOptions.SetBlendEquation( equationRgba, equationRgba ); - SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() ); + mBlendingOptions.SetBlendEquation(equationRgba, equationRgba); + SetBlendingOptionsMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendingOptions.GetBitmask()); } -void Renderer::SetBlendEquation( BlendingEquation::Type equationRgb, - BlendingEquation::Type equationAlpha ) +void Renderer::SetBlendEquation(DevelBlendEquation::Type equationRgb, + DevelBlendEquation::Type equationAlpha) { - mBlendingOptions.SetBlendEquation( equationRgb, equationAlpha ); - SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() ); + if(mBlendingOptions.IsAdvancedBlendEquation(equationRgb) || mBlendingOptions.IsAdvancedBlendEquation(equationAlpha)) + { + DALI_LOG_ERROR("Advanced blend equation requires to be set by using SetBlendEquation( DevelBlendEquation::Type equationRgba )."); + return; + } + mBlendingOptions.SetBlendEquation(equationRgb, equationAlpha); + SetBlendingOptionsMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendingOptions.GetBitmask()); } -void Renderer::GetBlendEquation( BlendingEquation::Type& equationRgb, - BlendingEquation::Type& equationAlpha ) const +void Renderer::GetBlendEquation(DevelBlendEquation::Type& equationRgb, + DevelBlendEquation::Type& equationAlpha) const { // These are not animatable, the cached values are up-to-date. equationRgb = mBlendingOptions.GetBlendEquationRgb(); equationAlpha = mBlendingOptions.GetBlendEquationAlpha(); } -void Renderer::SetBlendColor( const Vector4& color ) -{ - if( !mBlendColor ) - { - mBlendColor = new Vector4(); - } - if( *mBlendColor != color ) - { - *mBlendColor = color; - SetBlendColorMessage( GetEventThreadServices(), *mSceneObject, *mBlendColor ); - } -} - -Vector4 Renderer::GetBlendColor() const +void Renderer::SetIndexedDrawFirstElement(uint32_t firstElement) { - if( mBlendColor ) - { - return *mBlendColor; - } - return Color::TRANSPARENT; // GL default -} - -void Renderer::SetIndexedDrawFirstElement( size_t firstElement ) -{ - if( firstElement != mIndexedDrawFirstElement ) + if(firstElement != mIndexedDrawFirstElement) { mIndexedDrawFirstElement = firstElement; - SetIndexedDrawFirstElementMessage( GetEventThreadServices(), *mSceneObject, mIndexedDrawFirstElement ); + SetIndexedDrawFirstElementMessage(GetEventThreadServices(), GetRendererSceneObject(), mIndexedDrawFirstElement); } } -void Renderer::SetIndexedDrawElementsCount( size_t elementsCount ) +void Renderer::SetIndexedDrawElementsCount(uint32_t elementsCount) { - if( elementsCount != mIndexedDrawElementCount ) + if(elementsCount != mIndexedDrawElementCount) { mIndexedDrawElementCount = elementsCount; - SetIndexedDrawElementsCountMessage( GetEventThreadServices(), *mSceneObject, mIndexedDrawElementCount ); + SetIndexedDrawElementsCountMessage(GetEventThreadServices(), GetRendererSceneObject(), mIndexedDrawElementCount); } } - -void Renderer::EnablePreMultipliedAlpha( bool preMultipled ) +void Renderer::EnablePreMultipliedAlpha(bool preMultipled) { - if( mPremultipledAlphaEnabled != preMultipled ) + if(mPremultipledAlphaEnabled != preMultipled) { - if( preMultipled ) + if(preMultipled) + { + SetBlendFunc(BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA); + } + else { - SetBlendFunc( BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA, BlendingFactor::ONE, BlendingFactor::ONE ); + SetBlendFunc(BlendFactor::SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA); } mPremultipledAlphaEnabled = preMultipled; - SetEnablePreMultipliedAlphaMessage( GetEventThreadServices(), *mSceneObject, mPremultipledAlphaEnabled ); + SetEnablePreMultipliedAlphaMessage(GetEventThreadServices(), GetRendererSceneObject(), mPremultipledAlphaEnabled); } } @@ -259,429 +364,822 @@ bool Renderer::IsPreMultipliedAlphaEnabled() const return mPremultipledAlphaEnabled; } -SceneGraph::Renderer* Renderer::GetRendererSceneObject() +bool Renderer::IsAdvancedBlendEquationApplied() const { - return mSceneObject; -} - -unsigned int Renderer::GetDefaultPropertyCount() const -{ - return RENDERER_IMPL.GetDefaultPropertyCount(); -} + DevelBlendEquation::Type equationRgb, equationAlpha; + GetBlendEquation(equationRgb, equationAlpha); -void Renderer::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const -{ - RENDERER_IMPL.GetDefaultPropertyIndices( indices ); -} - -const char* Renderer::GetDefaultPropertyName(Property::Index index) const -{ - return RENDERER_IMPL.GetDefaultPropertyName( index ); -} - -Property::Index Renderer::GetDefaultPropertyIndex( const std::string& name ) const -{ - return RENDERER_IMPL.GetDefaultPropertyIndex( name ); -} - -bool Renderer::IsDefaultPropertyWritable( Property::Index index ) const -{ - return RENDERER_IMPL.IsDefaultPropertyWritable( index ); -} - -bool Renderer::IsDefaultPropertyAnimatable( Property::Index index ) const -{ - return RENDERER_IMPL.IsDefaultPropertyAnimatable( index ); -} + if(equationRgb != equationAlpha) + { + return false; + } -bool Renderer::IsDefaultPropertyAConstraintInput( Property::Index index ) const -{ - return RENDERER_IMPL.IsDefaultPropertyAConstraintInput( index ); + return mBlendingOptions.IsAdvancedBlendEquation(equationRgb); } -Property::Type Renderer::GetDefaultPropertyType( Property::Index index ) const +const SceneGraph::Renderer& Renderer::GetRendererSceneObject() const { - return RENDERER_IMPL.GetDefaultPropertyType( index ); + return static_cast(GetSceneObject()); } -void Renderer::SetDefaultProperty( Property::Index index, - const Property::Value& propertyValue ) +void Renderer::SetDefaultProperty(Property::Index index, + const Property::Value& propertyValue) { - switch( index ) + switch(index) { case Dali::Renderer::Property::DEPTH_INDEX: { - SetDepthIndex( propertyValue.Get() ); + SetDepthIndex(propertyValue.Get()); break; } case Dali::Renderer::Property::FACE_CULLING_MODE: { - int faceCullingMode; - if( propertyValue.Get( faceCullingMode ) ) + FaceCullingMode::Type convertedValue = mFaceCullingMode; + if(Scripting::GetEnumerationProperty(propertyValue, FACE_CULLING_MODE_TABLE, FACE_CULLING_MODE_TABLE_COUNT, convertedValue)) + { + mFaceCullingMode = convertedValue; + SetFaceCullingModeMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } + break; + } + case Dali::Renderer::Property::BLEND_MODE: + { + BlendMode::Type convertedValue = mBlendMode; + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_MODE_TABLE, BLEND_MODE_TABLE_COUNT, convertedValue)) { - SetFaceCullingMode( Dali::Renderer::FaceCullingMode( faceCullingMode ) ); + SetBlendMode(convertedValue); } break; } - case Dali::Renderer::Property::BLENDING_MODE: + case Dali::DevelRenderer::Property::BLEND_EQUATION: { - int blendingMode; - if( propertyValue.Get( blendingMode ) ) + DevelBlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationRgb(); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue)) { - SetBlendMode( BlendingMode::Type( blendingMode ) ); + mBlendingOptions.SetBlendEquation(convertedValue, convertedValue); + SetBlendingOptionsMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendingOptions.GetBitmask()); } break; } case Dali::Renderer::Property::BLEND_EQUATION_RGB: { - int blendingEquation; - if( propertyValue.Get( blendingEquation ) ) + DevelBlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationRgb(); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue)) { - BlendingEquation::Type alphaEquation = mBlendingOptions.GetBlendEquationAlpha(); - mBlendingOptions.SetBlendEquation( static_cast( blendingEquation ), alphaEquation ); - SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() ); + if(mBlendingOptions.IsAdvancedBlendEquation(convertedValue)) + { + DALI_LOG_ERROR("Advanced blend equation requires to be set by using DevelBlendEquation::BLEND_EQUATION."); + break; + } + DevelBlendEquation::Type alphaEquation = mBlendingOptions.GetBlendEquationAlpha(); + mBlendingOptions.SetBlendEquation(convertedValue, alphaEquation); + SetBlendingOptionsMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendingOptions.GetBitmask()); } break; } case Dali::Renderer::Property::BLEND_EQUATION_ALPHA: { - int blendingEquation; - if( propertyValue.Get( blendingEquation ) ) + DevelBlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationAlpha(); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue)) { - BlendingEquation::Type rgbEquation = mBlendingOptions.GetBlendEquationRgb(); - mBlendingOptions.SetBlendEquation( rgbEquation, static_cast( blendingEquation ) ); - SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() ); + if(mBlendingOptions.IsAdvancedBlendEquation(convertedValue)) + { + DALI_LOG_ERROR("Advanced blend equation requires to be set by using DevelBlendEquation::BLEND_EQUATION."); + break; + } + DevelBlendEquation::Type rgbEquation = mBlendingOptions.GetBlendEquationRgb(); + mBlendingOptions.SetBlendEquation(rgbEquation, convertedValue); + SetBlendingOptionsMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendingOptions.GetBitmask()); } break; } - case Dali::Renderer::Property::BLENDING_SRC_FACTOR_RGB: + case Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB: { - int blendingFactor; - if( propertyValue.Get( blendingFactor ) ) + BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha; + GetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, sourceFactorRgb)) { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( static_cast( blendingFactor ), - destFactorRgb, - srcFactorAlpha, - destFactorAlpha ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } - case Dali::Renderer::Property::BLENDING_DEST_FACTOR_RGB: + case Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB: { - int blendingFactor; - if( propertyValue.Get( blendingFactor ) ) + BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha; + GetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, destinationFactorRgb)) { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( srcFactorRgb, - static_cast( blendingFactor ), - srcFactorAlpha, - destFactorAlpha ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } - case Dali::Renderer::Property::BLENDING_SRC_FACTOR_ALPHA: + case Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA: { - int blendingFactor; - if( propertyValue.Get( blendingFactor ) ) + BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha; + GetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, sourceFactorAlpha)) { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( srcFactorRgb, - destFactorRgb, - static_cast( blendingFactor ), - destFactorAlpha ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } - case Dali::Renderer::Property::BLENDING_DEST_FACTOR_ALPHA: + case Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA: { - int blendingFactor; - if( propertyValue.Get( blendingFactor ) ) + BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha; + GetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, destinationFactorAlpha)) { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( srcFactorRgb, - destFactorRgb, - srcFactorAlpha, - static_cast( blendingFactor ) ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } - case Dali::Renderer::Property::BLENDING_COLOR: + case Dali::Renderer::Property::BLEND_COLOR: { Vector4 blendColor; - if( propertyValue.Get( blendColor ) ) + if(propertyValue.Get(blendColor)) { - SetBlendColor( blendColor ); + SetBlendColor(blendColor); } break; } case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA: { bool preMultipled; - if( propertyValue.Get( preMultipled ) ) + if(propertyValue.Get(preMultipled)) { - EnablePreMultipliedAlpha( preMultipled ); + EnablePreMultipliedAlpha(preMultipled); } break; } case Dali::Renderer::Property::INDEX_RANGE_FIRST: { - int firstElement; - if( propertyValue.Get( firstElement ) ) + int32_t firstElement; + if(propertyValue.Get(firstElement)) { - SetIndexedDrawFirstElement( firstElement ); + SetIndexedDrawFirstElement(firstElement); } break; } case Dali::Renderer::Property::INDEX_RANGE_COUNT: { - int elementsCount; - if( propertyValue.Get( elementsCount ) ) + int32_t elementsCount; + if(propertyValue.Get(elementsCount)) { - SetIndexedDrawElementsCount( elementsCount ); + SetIndexedDrawElementsCount(elementsCount); } break; } - } -} - -void Renderer::SetSceneGraphProperty( Property::Index index, - const PropertyMetadata& entry, - const Property::Value& value ) -{ - RENDERER_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value ); - OnPropertySet(index, value); -} - -Property::Value Renderer::GetDefaultProperty( Property::Index index ) const -{ - Property::Value value; - switch( index ) - { - case Dali::Renderer::Property::DEPTH_INDEX: + case Dali::Renderer::Property::DEPTH_WRITE_MODE: { - value = GetDepthIndex(); + DepthWriteMode::Type convertedValue = mDepthWriteMode; + if(Scripting::GetEnumerationProperty(propertyValue, DEPTH_WRITE_MODE_TABLE, DEPTH_WRITE_MODE_TABLE_COUNT, convertedValue)) + { + mDepthWriteMode = convertedValue; + SetDepthWriteModeMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } - case Dali::Renderer::Property::FACE_CULLING_MODE: + case Dali::Renderer::Property::DEPTH_FUNCTION: { - value = mFaceCullingMode; + DepthFunction::Type convertedValue = mDepthFunction; + if(Scripting::GetEnumerationProperty(propertyValue, DEPTH_FUNCTION_TABLE, DEPTH_FUNCTION_TABLE_COUNT, convertedValue)) + { + mDepthFunction = convertedValue; + SetDepthFunctionMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } - case Dali::Renderer::Property::BLENDING_MODE: + case Dali::Renderer::Property::DEPTH_TEST_MODE: { - value = mBlendingMode; + DepthTestMode::Type convertedValue = mDepthTestMode; + if(Scripting::GetEnumerationProperty(propertyValue, DEPTH_TEST_MODE_TABLE, DEPTH_TEST_MODE_TABLE_COUNT, convertedValue)) + { + mDepthTestMode = convertedValue; + SetDepthTestModeMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } - case Dali::Renderer::Property::BLEND_EQUATION_RGB: + case Dali::Renderer::Property::RENDER_MODE: { - value = static_cast( mBlendingOptions.GetBlendEquationRgb() ); + RenderMode::Type convertedValue = mStencilParameters.renderMode; + if(Scripting::GetEnumerationProperty(propertyValue, RENDER_MODE_TABLE, RENDER_MODE_TABLE_COUNT, convertedValue)) + { + mStencilParameters.renderMode = convertedValue; + SetRenderModeMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } - case Dali::Renderer::Property::BLEND_EQUATION_ALPHA: + case Dali::Renderer::Property::STENCIL_FUNCTION: { - value = static_cast( mBlendingOptions.GetBlendEquationAlpha() ); + StencilFunction::Type convertedValue = mStencilParameters.stencilFunction; + if(Scripting::GetEnumerationProperty(propertyValue, STENCIL_FUNCTION_TABLE, STENCIL_FUNCTION_TABLE_COUNT, convertedValue)) + { + mStencilParameters.stencilFunction = convertedValue; + SetStencilFunctionMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } - case Dali::Renderer::Property::BLENDING_SRC_FACTOR_RGB: + case Dali::Renderer::Property::STENCIL_FUNCTION_MASK: { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( srcFactorRgb ); + int32_t stencilFunctionMask; + if(propertyValue.Get(stencilFunctionMask)) + { + if(stencilFunctionMask != mStencilParameters.stencilFunctionMask) + { + mStencilParameters.stencilFunctionMask = stencilFunctionMask; + SetStencilFunctionMaskMessage(GetEventThreadServices(), GetRendererSceneObject(), stencilFunctionMask); + } + } break; } - case Dali::Renderer::Property::BLENDING_DEST_FACTOR_RGB: + case Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE: { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( destFactorRgb ); + int32_t stencilFunctionReference; + if(propertyValue.Get(stencilFunctionReference)) + { + if(stencilFunctionReference != mStencilParameters.stencilFunctionReference) + { + mStencilParameters.stencilFunctionReference = stencilFunctionReference; + SetStencilFunctionReferenceMessage(GetEventThreadServices(), GetRendererSceneObject(), stencilFunctionReference); + } + } break; } - case Dali::Renderer::Property::BLENDING_SRC_FACTOR_ALPHA: + case Dali::Renderer::Property::STENCIL_MASK: { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( srcFactorAlpha ); + int32_t stencilMask; + if(propertyValue.Get(stencilMask)) + { + if(stencilMask != mStencilParameters.stencilMask) + { + mStencilParameters.stencilMask = stencilMask; + SetStencilMaskMessage(GetEventThreadServices(), GetRendererSceneObject(), stencilMask); + } + } break; } - case Dali::Renderer::Property::BLENDING_DEST_FACTOR_ALPHA: + case Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL: { - BlendingFactor::Type srcFactorRgb; - BlendingFactor::Type destFactorRgb; - BlendingFactor::Type srcFactorAlpha; - BlendingFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( destFactorAlpha ); + StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnFail; + if(Scripting::GetEnumerationProperty(propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue)) + { + mStencilParameters.stencilOperationOnFail = convertedValue; + SetStencilOperationOnFailMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } - case Dali::Renderer::Property::BLENDING_COLOR: + case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL: { - if( mBlendColor ) - { - value = *mBlendColor; - } - else + StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnZFail; + if(Scripting::GetEnumerationProperty(propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue)) { - value = Color::TRANSPARENT; + mStencilParameters.stencilOperationOnZFail = convertedValue; + SetStencilOperationOnZFailMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); } break; } - case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA: + case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS: { - value = IsPreMultipliedAlphaEnabled(); + StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnZPass; + if(Scripting::GetEnumerationProperty(propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue)) + { + mStencilParameters.stencilOperationOnZPass = convertedValue; + SetStencilOperationOnZPassMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } - case Dali::Renderer::Property::INDEX_RANGE_FIRST: + case Dali::DevelRenderer::Property::OPACITY: { - value = static_cast( mIndexedDrawFirstElement ); + float opacity; + if(propertyValue.Get(opacity)) + { + if(!Equals(mOpacity, opacity)) + { + mOpacity = opacity; + BakeOpacityMessage(GetEventThreadServices(), GetRendererSceneObject(), mOpacity); + } + } break; } - case Dali::Renderer::Property::INDEX_RANGE_COUNT: + case DevelRenderer::Property::RENDERING_BEHAVIOR: { - value = static_cast( mIndexedDrawElementCount ); + DevelRenderer::Rendering::Type convertedValue = mRenderingBehavior; + if(Scripting::GetEnumerationProperty(propertyValue, RENDERING_BEHAVIOR_TABLE, RENDERING_BEHAVIOR_TABLE_COUNT, convertedValue)) + { + mRenderingBehavior = convertedValue; + SetRenderingBehaviorMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } } - return value; } -const SceneGraph::PropertyOwner* Renderer::GetPropertyOwner() const +Property::Value Renderer::GetDefaultProperty(Property::Index index) const { - return mSceneObject; -} + Property::Value value; -const SceneGraph::PropertyOwner* Renderer::GetSceneObject() const -{ - return mSceneObject; + if(!GetCachedPropertyValue(index, value)) + { + // If property value is not stored in the event-side, then it must be a scene-graph only property + GetCurrentPropertyValue(index, value); + } + + return value; } -const SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty( Property::Index index ) const +Property::Value Renderer::GetDefaultPropertyCurrentValue(Property::Index index) const { - DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" ); - const SceneGraph::PropertyBase* property = NULL; + Property::Value value; - if( OnStage() ) + if(!GetCurrentPropertyValue(index, value)) { - property = RENDERER_IMPL.GetRegisteredSceneGraphProperty( - this, - &Renderer::FindAnimatableProperty, - &Renderer::FindCustomProperty, - index ); + // If unable to retrieve scene-graph property value, then it must be an event-side only property + GetCachedPropertyValue(index, value); } - return property; + return value; +} + +void Renderer::OnNotifyDefaultPropertyAnimation(Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType) +{ + switch(animationType) + { + case Animation::TO: + case Animation::BETWEEN: + { + switch(index) + { + case Dali::DevelRenderer::Property::OPACITY: + { + value.Get(mOpacity); + break; + } + } + break; + } + + case Animation::BY: + { + switch(index) + { + case Dali::DevelRenderer::Property::OPACITY: + { + AdjustValue(mOpacity, value); + break; + } + } + break; + } + } } -const PropertyInputImpl* Renderer::GetSceneObjectInputProperty( Property::Index index ) const +const SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty(Property::Index index) const { - const PropertyInputImpl* property = NULL; + const SceneGraph::PropertyBase* property = nullptr; - if( OnStage() ) + if(index == DevelRenderer::Property::OPACITY) { - const SceneGraph::PropertyBase* baseProperty = - RENDERER_IMPL.GetRegisteredSceneGraphProperty( this, - &Renderer::FindAnimatableProperty, - &Renderer::FindCustomProperty, - index ); - property = static_cast( baseProperty ); + property = &GetRendererSceneObject().mOpacity; + } + if(!property) + { + // not our property, ask base + property = Object::GetSceneObjectAnimatableProperty(index); } return property; } -int Renderer::GetPropertyComponentIndex( Property::Index index ) const +const PropertyInputImpl* Renderer::GetSceneObjectInputProperty(Property::Index index) const +{ + // reuse animatable property getter, Object::GetSceneObjectInputProperty does the same so no need to call that0 + return GetSceneObjectAnimatableProperty(index); +} + +Renderer::Renderer(const SceneGraph::Renderer* sceneObject) +: Object(sceneObject), + mDepthIndex(0), + mIndexedDrawFirstElement(0), + mIndexedDrawElementCount(0), + mStencilParameters(RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP), + mBlendingOptions(), + mOpacity(1.0f), + mDepthFunction(DepthFunction::LESS), + mFaceCullingMode(FaceCullingMode::NONE), + mBlendMode(BlendMode::AUTO), + mDepthWriteMode(DepthWriteMode::AUTO), + mDepthTestMode(DepthTestMode::AUTO), + mRenderingBehavior(DevelRenderer::Rendering::IF_REQUIRED), + mPremultipledAlphaEnabled(false) { - return Property::INVALID_COMPONENT_INDEX; } -bool Renderer::OnStage() const +void Renderer::SetBlendColor(const Vector4& blendColor) { - return mOnStageCount > 0; + mBlendingOptions.SetBlendColor(blendColor); + SetBlendColorMessage(GetEventThreadServices(), GetRendererSceneObject(), GetBlendColor()); } -void Renderer::Connect() +const Vector4& Renderer::GetBlendColor() const { - if( mOnStageCount == 0 ) + const Vector4* blendColor = mBlendingOptions.GetBlendColor(); + if(blendColor) { - OnStageConnectMessage( GetEventThreadServices(), *mSceneObject ); - mGeometryConnector.OnStageConnect(); - mTextureSetConnector.OnStageConnect(); + return *blendColor; } - ++mOnStageCount; + return Color::TRANSPARENT; // GL default } -void Renderer::Disconnect() +Renderer::~Renderer() { - --mOnStageCount; - if( mOnStageCount == 0 ) + if(EventThreadServices::IsCoreRunning()) { - OnStageDisconnectMessage( GetEventThreadServices(), *mSceneObject); - mGeometryConnector.OnStageDisconnect(); - mTextureSetConnector.OnStageDisconnect(); + EventThreadServices& eventThreadServices = GetEventThreadServices(); + SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); + RemoveRendererMessage(updateManager, GetRendererSceneObject()); + + eventThreadServices.UnregisterObject(this); } } -Renderer::Renderer() -: mSceneObject (NULL ), - mBlendColor( NULL ), - mDepthIndex( 0 ), - mOnStageCount( 0 ), - mIndexedDrawFirstElement( 0 ), - mIndexedDrawElementCount( 0 ), - mFaceCullingMode( Dali::Renderer::NONE ), - mBlendingMode( Dali::BlendingMode::AUTO ), - mBlendingOptions(), - mPremultipledAlphaEnabled( false ) +bool Renderer::GetCachedPropertyValue(Property::Index index, Property::Value& value) const { + bool valueSet = true; + + switch(index) + { + case Dali::Renderer::Property::DEPTH_INDEX: + { + value = GetDepthIndex(); + break; + } + case Dali::Renderer::Property::FACE_CULLING_MODE: + { + value = mFaceCullingMode; + break; + } + case Dali::Renderer::Property::BLEND_MODE: + { + value = mBlendMode; + break; + } + case Dali::DevelRenderer::Property::BLEND_EQUATION: + { + value = static_cast(mBlendingOptions.GetBlendEquationRgb()); + break; + } + case Dali::Renderer::Property::BLEND_EQUATION_RGB: + { + value = static_cast(mBlendingOptions.GetBlendEquationRgb()); + break; + } + case Dali::Renderer::Property::BLEND_EQUATION_ALPHA: + { + value = static_cast(mBlendingOptions.GetBlendEquationAlpha()); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB: + { + BlendFactor::Type srcFactorRgb; + BlendFactor::Type destFactorRgb; + BlendFactor::Type srcFactorAlpha; + BlendFactor::Type destFactorAlpha; + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(srcFactorRgb); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB: + { + BlendFactor::Type srcFactorRgb; + BlendFactor::Type destFactorRgb; + BlendFactor::Type srcFactorAlpha; + BlendFactor::Type destFactorAlpha; + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(destFactorRgb); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA: + { + BlendFactor::Type srcFactorRgb; + BlendFactor::Type destFactorRgb; + BlendFactor::Type srcFactorAlpha; + BlendFactor::Type destFactorAlpha; + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(srcFactorAlpha); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA: + { + BlendFactor::Type srcFactorRgb; + BlendFactor::Type destFactorRgb; + BlendFactor::Type srcFactorAlpha; + BlendFactor::Type destFactorAlpha; + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(destFactorAlpha); + break; + } + case Dali::Renderer::Property::BLEND_COLOR: + { + value = GetBlendColor(); + break; + } + case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA: + { + value = IsPreMultipliedAlphaEnabled(); + break; + } + case Dali::Renderer::Property::INDEX_RANGE_FIRST: + { + value = static_cast(mIndexedDrawFirstElement); + break; + } + case Dali::Renderer::Property::INDEX_RANGE_COUNT: + { + value = static_cast(mIndexedDrawElementCount); + break; + } + case Dali::Renderer::Property::DEPTH_WRITE_MODE: + { + value = mDepthWriteMode; + break; + } + case Dali::Renderer::Property::DEPTH_FUNCTION: + { + value = mDepthFunction; + break; + } + case Dali::Renderer::Property::DEPTH_TEST_MODE: + { + value = mDepthTestMode; + break; + } + case Dali::Renderer::Property::STENCIL_FUNCTION: + { + value = mStencilParameters.stencilFunction; + break; + } + case Dali::Renderer::Property::STENCIL_FUNCTION_MASK: + { + value = mStencilParameters.stencilFunctionMask; + break; + } + case Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE: + { + value = mStencilParameters.stencilFunctionReference; + break; + } + case Dali::Renderer::Property::STENCIL_MASK: + { + value = mStencilParameters.stencilMask; + break; + } + case Dali::Renderer::Property::RENDER_MODE: + { + value = mStencilParameters.renderMode; + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL: + { + value = mStencilParameters.stencilOperationOnFail; + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL: + { + value = mStencilParameters.stencilOperationOnZFail; + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS: + { + value = mStencilParameters.stencilOperationOnZPass; + break; + } + case Dali::DevelRenderer::Property::OPACITY: + { + value = mOpacity; + break; + } + case Dali::DevelRenderer::Property::RENDERING_BEHAVIOR: + { + value = mRenderingBehavior; + break; + } + default: + { + // Must be a scene-graph only property + valueSet = false; + break; + } + } + + return valueSet; } -void Renderer::Initialize() +bool Renderer::GetCurrentPropertyValue(Property::Index index, Property::Value& value) const { - EventThreadServices& eventThreadServices = GetEventThreadServices(); - SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); + bool valueSet = true; + const SceneGraph::Renderer& sceneObject = GetRendererSceneObject(); - mSceneObject = SceneGraph::Renderer::New(); - AddMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject ); + switch(index) + { + case Dali::Renderer::Property::DEPTH_INDEX: + { + value = sceneObject.GetDepthIndex(); + break; + } + case Dali::Renderer::Property::FACE_CULLING_MODE: + { + value = sceneObject.GetFaceCullingMode(); + break; + } + case Dali::Renderer::Property::BLEND_MODE: + { + value = sceneObject.GetBlendMode(); + break; + } + case Dali::DevelRenderer::Property::BLEND_EQUATION: + { + uint32_t bitMask = sceneObject.GetBlendingOptions(); + BlendingOptions blendingOptions; + blendingOptions.SetBitmask(bitMask); + value = static_cast(blendingOptions.GetBlendEquationRgb()); + break; + } + case Dali::Renderer::Property::BLEND_EQUATION_RGB: + { + uint32_t bitMask = sceneObject.GetBlendingOptions(); + BlendingOptions blendingOptions; + blendingOptions.SetBitmask(bitMask); + value = static_cast(blendingOptions.GetBlendEquationRgb()); + break; + } + case Dali::Renderer::Property::BLEND_EQUATION_ALPHA: + { + uint32_t bitMask = sceneObject.GetBlendingOptions(); + BlendingOptions blendingOptions; + blendingOptions.SetBitmask(bitMask); + value = static_cast(blendingOptions.GetBlendEquationAlpha()); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB: + { + uint32_t bitMask = sceneObject.GetBlendingOptions(); + BlendingOptions blendingOptions; + blendingOptions.SetBitmask(bitMask); + value = static_cast(blendingOptions.GetBlendSrcFactorRgb()); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB: + { + uint32_t bitMask = sceneObject.GetBlendingOptions(); + BlendingOptions blendingOptions; + blendingOptions.SetBitmask(bitMask); + value = static_cast(blendingOptions.GetBlendDestFactorRgb()); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA: + { + uint32_t bitMask = sceneObject.GetBlendingOptions(); + BlendingOptions blendingOptions; + blendingOptions.SetBitmask(bitMask); + value = static_cast(blendingOptions.GetBlendSrcFactorAlpha()); + break; + } + case Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA: + { + uint32_t bitMask = sceneObject.GetBlendingOptions(); + BlendingOptions blendingOptions; + blendingOptions.SetBitmask(bitMask); + value = static_cast(blendingOptions.GetBlendDestFactorAlpha()); + break; + } + case Dali::Renderer::Property::BLEND_COLOR: + { + value = sceneObject.GetBlendColor(); + break; + } + case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA: + { + value = sceneObject.IsPreMultipliedAlphaEnabled(); + break; + } + case Dali::Renderer::Property::INDEX_RANGE_FIRST: + { + value = static_cast(sceneObject.GetIndexedDrawFirstElement()); + break; + } + case Dali::Renderer::Property::INDEX_RANGE_COUNT: + { + value = static_cast(sceneObject.GetIndexedDrawElementsCount()); + break; + } + case Dali::Renderer::Property::DEPTH_WRITE_MODE: + { + value = sceneObject.GetDepthWriteMode(); + break; + } + case Dali::Renderer::Property::DEPTH_FUNCTION: + { + value = sceneObject.GetDepthFunction(); + break; + } + case Dali::Renderer::Property::DEPTH_TEST_MODE: + { + value = sceneObject.GetDepthTestMode(); + break; + } + case Dali::Renderer::Property::STENCIL_FUNCTION: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.stencilFunction; + break; + } + case Dali::Renderer::Property::STENCIL_FUNCTION_MASK: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.stencilFunctionMask; + break; + } + case Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.stencilFunctionReference; + break; + } + case Dali::Renderer::Property::STENCIL_MASK: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.stencilMask; + break; + } + case Dali::Renderer::Property::RENDER_MODE: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.renderMode; + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.stencilOperationOnFail; + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.stencilOperationOnZFail; + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS: + { + Render::Renderer::StencilParameters stencilParameters = sceneObject.GetStencilParameters(); + value = stencilParameters.stencilOperationOnZPass; + break; + } + case Dali::DevelRenderer::Property::OPACITY: + { + value = sceneObject.GetOpacity(GetEventThreadServices().GetEventBufferIndex()); + break; + } + case Dali::DevelRenderer::Property::RENDERING_BEHAVIOR: + { + value = sceneObject.GetRenderingBehavior(); + break; + } + default: + { + // Must be an event-side only property + valueSet = false; + break; + } + } - eventThreadServices.RegisterObject( this ); + return valueSet; } -Renderer::~Renderer() +void Renderer::AddDrawCommand(const Dali::DevelRenderer::DrawCommand& command) { - if( EventThreadServices::IsCoreRunning() ) + if(!mDrawCommands.capacity()) { - EventThreadServices& eventThreadServices = GetEventThreadServices(); - SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); - RemoveMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject ); - - eventThreadServices.UnregisterObject( this ); + mDrawCommands.reserve(8); } + + mDrawCommands.emplace_back(command); + + Dali::Internal::SceneGraph::SetDrawCommandsMessage(GetEventThreadServices(), + GetRendererSceneObject(), + mDrawCommands.data(), + uint32_t(mDrawCommands.size()) + + ); } } // namespace Internal + } // namespace Dali