X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=dali%2Finternal%2Fevent%2Frendering%2Frenderer-impl.cpp;h=4342d90b8d4c7a89d592c24323e9c74eebfb4d4f;hb=50f6f9022d087132cfdc1eb2bdc59a3ca2d49b6f;hp=1f6ceb271f302eb4a503ef277cf7e08ff125167e;hpb=3f42994af46957ed04ea29af60c541f561120b01;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 1f6ceb2..4342d90 100644 --- a/dali/internal/event/rendering/renderer-impl.cpp +++ b/dali/internal/event/rendering/renderer-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 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,144 +19,251 @@ #include // Dali::Internal::Renderer // INTERNAL INCLUDES -#include -#include // Dali::Internal::ObjectHelper +#include #include // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END #include -#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( "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( "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( "stencilMode", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_MODE ) -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( "writeToColorBuffer", BOOLEAN, true, false, false, Dali::Renderer::Property::WRITE_TO_COLOR_BUFFER ) -DALI_PROPERTY_TABLE_END( DEFAULT_RENDERER_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) { mGeometry = &geometry; const Render::Geometry* geometrySceneObject = geometry.GetRenderObject(); - SetGeometryMessage( GetEventThreadServices(), *mSceneObject, *geometrySceneObject ); + SetGeometryMessage(GetEventThreadServices(), GetRendererSceneObject(), *geometrySceneObject); } -Geometry* Renderer::GetGeometry() const +GeometryPtr Renderer::GetGeometry() const { - return mGeometry.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( FaceCullingMode::Type cullingMode ) +void Renderer::SetBlendMode(BlendMode::Type mode) { - if( mFaceCullingMode != cullingMode ) - { - mFaceCullingMode = cullingMode; - - SetFaceCullingModeMessage( GetEventThreadServices(), *mSceneObject, mFaceCullingMode ); - } -} - -FaceCullingMode::Type Renderer::GetFaceCullingMode() -{ - return mFaceCullingMode; -} - -void Renderer::SetBlendMode( BlendMode::Type mode ) -{ - if( mBlendMode != mode ) + if(mBlendMode != mode) { mBlendMode = mode; - SetBlendModeMessage( GetEventThreadServices(), *mSceneObject, mBlendMode ); + SetBlendModeMessage(GetEventThreadServices(), GetRendererSceneObject(), mBlendMode); } } @@ -165,25 +272,25 @@ BlendMode::Type Renderer::GetBlendMode() const return mBlendMode; } -void Renderer::SetBlendFunc( BlendFactor::Type srcFactorRgba, BlendFactor::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( BlendFactor::Type srcFactorRgb, - BlendFactor::Type destFactorRgb, - BlendFactor::Type srcFactorAlpha, - BlendFactor::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( BlendFactor::Type& srcFactorRgb, - BlendFactor::Type& destFactorRgb, - BlendFactor::Type& srcFactorAlpha, - BlendFactor::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(); @@ -191,78 +298,64 @@ void Renderer::GetBlendFunc( BlendFactor::Type& srcFactorRgb, destFactorAlpha = mBlendingOptions.GetBlendDestFactorAlpha(); } -void Renderer::SetBlendEquation( BlendEquation::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( BlendEquation::Type equationRgb, - BlendEquation::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( BlendEquation::Type& equationRgb, - BlendEquation::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 -{ - if( mBlendColor ) - { - return *mBlendColor; - } - return Color::TRANSPARENT; // GL default -} - -void Renderer::SetIndexedDrawFirstElement( size_t firstElement ) +void Renderer::SetIndexedDrawFirstElement(uint32_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( BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::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); } } @@ -271,260 +364,456 @@ 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)) { - SetFaceCullingMode( FaceCullingMode::Type( faceCullingMode ) ); + mFaceCullingMode = convertedValue; + SetFaceCullingModeMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); } break; } case Dali::Renderer::Property::BLEND_MODE: { - int blendingMode; - if( propertyValue.Get( blendingMode ) ) + BlendMode::Type convertedValue = mBlendMode; + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_MODE_TABLE, BLEND_MODE_TABLE_COUNT, convertedValue)) { - SetBlendMode( BlendMode::Type( blendingMode ) ); + SetBlendMode(convertedValue); + } + break; + } + case Dali::DevelRenderer::Property::BLEND_EQUATION: + { + DevelBlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationRgb(); + + if(Scripting::GetEnumerationProperty(propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue)) + { + 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)) { - BlendEquation::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)) { - BlendEquation::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::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)) { - BlendFactor::Type srcFactorRgb; - BlendFactor::Type destFactorRgb; - BlendFactor::Type srcFactorAlpha; - BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( static_cast( blendingFactor ), - destFactorRgb, - srcFactorAlpha, - destFactorAlpha ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } 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)) { - BlendFactor::Type srcFactorRgb; - BlendFactor::Type destFactorRgb; - BlendFactor::Type srcFactorAlpha; - BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( srcFactorRgb, - static_cast( blendingFactor ), - srcFactorAlpha, - destFactorAlpha ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } 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)) { - BlendFactor::Type srcFactorRgb; - BlendFactor::Type destFactorRgb; - BlendFactor::Type srcFactorAlpha; - BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( srcFactorRgb, - destFactorRgb, - static_cast( blendingFactor ), - destFactorAlpha ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } 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)) { - BlendFactor::Type srcFactorRgb; - BlendFactor::Type destFactorRgb; - BlendFactor::Type srcFactorAlpha; - BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - SetBlendFunc( srcFactorRgb, - destFactorRgb, - srcFactorAlpha, - static_cast( blendingFactor ) ); + SetBlendFunc(sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha); } break; } 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; } case Dali::Renderer::Property::DEPTH_WRITE_MODE: { - int value; - propertyValue.Get( value ); - DepthWriteMode::Type mode = static_cast(value); - if( mode != mDepthWriteMode ) + DepthWriteMode::Type convertedValue = mDepthWriteMode; + if(Scripting::GetEnumerationProperty(propertyValue, DEPTH_WRITE_MODE_TABLE, DEPTH_WRITE_MODE_TABLE_COUNT, convertedValue)) { - mDepthWriteMode = mode; - SetDepthWriteModeMessage( GetEventThreadServices(), *mSceneObject, mode ); + mDepthWriteMode = convertedValue; + SetDepthWriteModeMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); } break; } case Dali::Renderer::Property::DEPTH_FUNCTION: { - int value; - propertyValue.Get( value ); - DepthFunction::Type depthFunction = static_cast(value); - if( depthFunction != mDepthFunction ) + DepthFunction::Type convertedValue = mDepthFunction; + if(Scripting::GetEnumerationProperty(propertyValue, DEPTH_FUNCTION_TABLE, DEPTH_FUNCTION_TABLE_COUNT, convertedValue)) { - mDepthFunction = depthFunction; - SetDepthFunctionMessage( GetEventThreadServices(), *mSceneObject, depthFunction ); + mDepthFunction = convertedValue; + SetDepthFunctionMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); } break; } case Dali::Renderer::Property::DEPTH_TEST_MODE: { - int value; - propertyValue.Get( value ); - DepthTestMode::Type mode = static_cast(value); - if( mode != mDepthTestMode ) + DepthTestMode::Type convertedValue = mDepthTestMode; + if(Scripting::GetEnumerationProperty(propertyValue, DEPTH_TEST_MODE_TABLE, DEPTH_TEST_MODE_TABLE_COUNT, convertedValue)) { - mDepthTestMode = mode; - SetDepthTestModeMessage( GetEventThreadServices(), *mSceneObject, mode ); + mDepthTestMode = convertedValue; + SetDepthTestModeMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); } break; } - default: + case Dali::Renderer::Property::RENDER_MODE: { + 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::STENCIL_FUNCTION: + { + 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::STENCIL_FUNCTION_MASK: + { + int32_t stencilFunctionMask; + if(propertyValue.Get(stencilFunctionMask)) + { + if(stencilFunctionMask != mStencilParameters.stencilFunctionMask) + { + mStencilParameters.stencilFunctionMask = stencilFunctionMask; + SetStencilFunctionMaskMessage(GetEventThreadServices(), GetRendererSceneObject(), stencilFunctionMask); + } + } + break; + } + case Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE: + { + int32_t stencilFunctionReference; + if(propertyValue.Get(stencilFunctionReference)) + { + if(stencilFunctionReference != mStencilParameters.stencilFunctionReference) + { + mStencilParameters.stencilFunctionReference = stencilFunctionReference; + SetStencilFunctionReferenceMessage(GetEventThreadServices(), GetRendererSceneObject(), stencilFunctionReference); + } + } + break; + } + case Dali::Renderer::Property::STENCIL_MASK: + { + int32_t stencilMask; + if(propertyValue.Get(stencilMask)) + { + if(stencilMask != mStencilParameters.stencilMask) + { + mStencilParameters.stencilMask = stencilMask; + SetStencilMaskMessage(GetEventThreadServices(), GetRendererSceneObject(), stencilMask); + } + } + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL: + { + 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::STENCIL_OPERATION_ON_Z_FAIL: + { + StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnZFail; + if(Scripting::GetEnumerationProperty(propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue)) + { + mStencilParameters.stencilOperationOnZFail = convertedValue; + SetStencilOperationOnZFailMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } + break; + } + case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS: + { + 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::DevelRenderer::Property::OPACITY: + { + float opacity; + if(propertyValue.Get(opacity)) + { + if(!Equals(mOpacity, opacity)) + { + mOpacity = opacity; + BakeOpacityMessage(GetEventThreadServices(), GetRendererSceneObject(), mOpacity); + } + } + break; + } + case DevelRenderer::Property::RENDERING_BEHAVIOR: + { + DevelRenderer::Rendering::Type convertedValue = mRenderingBehavior; + if(Scripting::GetEnumerationProperty(propertyValue, RENDERING_BEHAVIOR_TABLE, RENDERING_BEHAVIOR_TABLE_COUNT, convertedValue)) + { + mRenderingBehavior = convertedValue; + SetRenderingBehaviorMessage(GetEventThreadServices(), GetRendererSceneObject(), convertedValue); + } break; } } } -void Renderer::SetSceneGraphProperty( Property::Index index, - const PropertyMetadata& entry, - const Property::Value& value ) +Property::Value Renderer::GetDefaultProperty(Property::Index index) const { - RENDERER_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value ); - OnPropertySet(index, value); + Property::Value value; + + 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; } -Property::Value Renderer::GetDefaultProperty( Property::Index index ) const +Property::Value Renderer::GetDefaultPropertyCurrentValue(Property::Index index) const { Property::Value value; - switch( index ) + + if(!GetCurrentPropertyValue(index, value)) + { + // If unable to retrieve scene-graph property value, then it must be an event-side only property + GetCachedPropertyValue(index, value); + } + + 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 SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty(Property::Index index) const +{ + const SceneGraph::PropertyBase* property = nullptr; + + if(index == DevelRenderer::Property::OPACITY) + { + property = &GetRendererSceneObject().mOpacity; + } + if(!property) + { + // not our property, ask base + property = Object::GetSceneObjectAnimatableProperty(index); + } + + return property; +} + +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) +{ +} + +void Renderer::SetBlendColor(const Vector4& blendColor) +{ + mBlendingOptions.SetBlendColor(blendColor); + SetBlendColorMessage(GetEventThreadServices(), GetRendererSceneObject(), GetBlendColor()); +} + +const Vector4& Renderer::GetBlendColor() const +{ + const Vector4* blendColor = mBlendingOptions.GetBlendColor(); + if(blendColor) + { + return *blendColor; + } + return Color::TRANSPARENT; // GL default +} + +Renderer::~Renderer() +{ + if(EventThreadServices::IsCoreRunning()) + { + EventThreadServices& eventThreadServices = GetEventThreadServices(); + SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); + RemoveRendererMessage(updateManager, GetRendererSceneObject()); + + eventThreadServices.UnregisterObject(this); + } +} + +bool Renderer::GetCachedPropertyValue(Property::Index index, Property::Value& value) const +{ + bool valueSet = true; + + switch(index) { case Dali::Renderer::Property::DEPTH_INDEX: { @@ -541,14 +830,19 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const 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() ); + value = static_cast(mBlendingOptions.GetBlendEquationRgb()); break; } case Dali::Renderer::Property::BLEND_EQUATION_ALPHA: { - value = static_cast( mBlendingOptions.GetBlendEquationAlpha() ); + value = static_cast(mBlendingOptions.GetBlendEquationAlpha()); break; } case Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB: @@ -557,8 +851,8 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const BlendFactor::Type destFactorRgb; BlendFactor::Type srcFactorAlpha; BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( srcFactorRgb ); + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(srcFactorRgb); break; } case Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB: @@ -567,8 +861,8 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const BlendFactor::Type destFactorRgb; BlendFactor::Type srcFactorAlpha; BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( destFactorRgb ); + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(destFactorRgb); break; } case Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA: @@ -577,8 +871,8 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const BlendFactor::Type destFactorRgb; BlendFactor::Type srcFactorAlpha; BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( srcFactorAlpha ); + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(srcFactorAlpha); break; } case Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA: @@ -587,20 +881,13 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const BlendFactor::Type destFactorRgb; BlendFactor::Type srcFactorAlpha; BlendFactor::Type destFactorAlpha; - GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha ); - value = static_cast( destFactorAlpha ); + GetBlendFunc(srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha); + value = static_cast(destFactorAlpha); break; } case Dali::Renderer::Property::BLEND_COLOR: { - if( mBlendColor ) - { - value = *mBlendColor; - } - else - { - value = Color::TRANSPARENT; - } + value = GetBlendColor(); break; } case Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA: @@ -610,12 +897,12 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const } case Dali::Renderer::Property::INDEX_RANGE_FIRST: { - value = static_cast( mIndexedDrawFirstElement ); + value = static_cast(mIndexedDrawFirstElement); break; } case Dali::Renderer::Property::INDEX_RANGE_COUNT: { - value = static_cast( mIndexedDrawElementCount ); + value = static_cast(mIndexedDrawElementCount); break; } case Dali::Renderer::Property::DEPTH_WRITE_MODE: @@ -633,123 +920,266 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const value = mDepthTestMode; break; } - } - return value; -} - -const SceneGraph::PropertyOwner* Renderer::GetPropertyOwner() const -{ - return mSceneObject; -} - -const SceneGraph::PropertyOwner* Renderer::GetSceneObject() const -{ - return mSceneObject; -} - -const SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty( Property::Index index ) const -{ - DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" ); - const SceneGraph::PropertyBase* property = NULL; - - if( OnStage() ) - { - property = RENDERER_IMPL.GetRegisteredSceneGraphProperty( - this, - &Renderer::FindAnimatableProperty, - &Renderer::FindCustomProperty, - index ); + 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 property; + return valueSet; } -const PropertyInputImpl* Renderer::GetSceneObjectInputProperty( Property::Index index ) const +bool Renderer::GetCurrentPropertyValue(Property::Index index, Property::Value& value) const { - const PropertyInputImpl* property = NULL; + bool valueSet = true; + const SceneGraph::Renderer& sceneObject = GetRendererSceneObject(); - if( OnStage() ) + switch(index) { - const SceneGraph::PropertyBase* baseProperty = - RENDERER_IMPL.GetRegisteredSceneGraphProperty( this, - &Renderer::FindAnimatableProperty, - &Renderer::FindCustomProperty, - index ); - property = static_cast( baseProperty ); + 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; + } } - return property; -} - -int Renderer::GetPropertyComponentIndex( Property::Index index ) const -{ - return Property::INVALID_COMPONENT_INDEX; + return valueSet; } -bool Renderer::OnStage() const +void Renderer::AddDrawCommand(const Dali::DevelRenderer::DrawCommand& command) { - return mOnStageCount > 0; -} - -void Renderer::Connect() -{ - if( mOnStageCount == 0 ) + if(!mDrawCommands.capacity()) { - OnStageConnectMessage( GetEventThreadServices(), *mSceneObject ); - mTextureSetConnector.OnStageConnect(); + mDrawCommands.reserve(8); } - ++mOnStageCount; -} - -void Renderer::Disconnect() -{ - --mOnStageCount; - if( mOnStageCount == 0 ) - { - OnStageDisconnectMessage( GetEventThreadServices(), *mSceneObject); - mTextureSetConnector.OnStageDisconnect(); - } -} - -Renderer::Renderer() -: mSceneObject (NULL ), - mBlendColor( NULL ), - mDepthIndex( 0 ), - mOnStageCount( 0 ), - mIndexedDrawFirstElement( 0 ), - mIndexedDrawElementCount( 0 ), - mFaceCullingMode( FaceCullingMode::NONE ), - mBlendMode( BlendMode::AUTO ), - mBlendingOptions(), - mDepthWriteMode( DepthWriteMode::AUTO ), - mDepthFunction( DepthFunction::LESS ), - mDepthTestMode( DepthTestMode::AUTO ), - mPremultipledAlphaEnabled( false ) -{ -} -void Renderer::Initialize() -{ - EventThreadServices& eventThreadServices = GetEventThreadServices(); - SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); + mDrawCommands.emplace_back(command); - mSceneObject = SceneGraph::Renderer::New(); - AddMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject ); + Dali::Internal::SceneGraph::SetDrawCommandsMessage(GetEventThreadServices(), + GetRendererSceneObject(), + mDrawCommands.data(), + uint32_t(mDrawCommands.size()) - eventThreadServices.RegisterObject( this ); -} - -Renderer::~Renderer() -{ - if( EventThreadServices::IsCoreRunning() ) - { - EventThreadServices& eventThreadServices = GetEventThreadServices(); - SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); - RemoveMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject ); - - eventThreadServices.UnregisterObject( this ); - } + ); } } // namespace Internal + } // namespace Dali