/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+#include <dali/devel-api/rendering/renderer-devel.h>
//INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/color-visual-properties.h>
-#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
+#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
+#include <dali-toolkit/devel-api/visuals/color-visual-actions-devel.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
+#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
namespace Dali
{
namespace Internal
{
-namespace
-{
-const char * const COLOR_NAME("mixColor");
-
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- \n
- void main()\n
- {\n
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
- }\n
-);
-
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform lowp vec4 mixColor;\n
- \n
- void main()\n
- {\n
- gl_FragColor = mixColor*uColor;\n
- }\n
-);
-}
-
-ColorVisualPtr ColorVisual::New( VisualFactoryCache& factoryCache )
+ColorVisualPtr ColorVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
{
- return new ColorVisual( factoryCache );
+ ColorVisualPtr colorVisualPtr( new ColorVisual( factoryCache ) );
+ colorVisualPtr->SetProperties( properties );
+ return colorVisualPtr;
}
-ColorVisual::ColorVisual( VisualFactoryCache& factoryCache )
-: Visual::Base( factoryCache ),
- mMixColorIndex( Property::INVALID_INDEX )
+ColorVisual::ColorVisual(VisualFactoryCache& factoryCache)
+: Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::COLOR),
+ mBlurRadius(0.0f),
+ mBlurRadiusIndex(Property::INVALID_INDEX),
+ mRenderIfTransparent(false),
+ mNeedBlurRadius(false)
{
}
void ColorVisual::DoSetProperties( const Property::Map& propertyMap )
{
- Property::Value* color = propertyMap.Find( Toolkit::ColorVisual::Property::MIX_COLOR, COLOR_NAME );
- if( !( color && color->Get(mMixColor) ) )
+ // By virtue of DoSetProperties being called last, this will override
+ // anything set by Toolkit::Visual::Property::MIX_COLOR
+ Property::Value* colorValue = propertyMap.Find( Toolkit::ColorVisual::Property::MIX_COLOR, MIX_COLOR );
+ if( colorValue )
+ {
+ Vector4 color;
+ if( colorValue->Get( color ) )
+ {
+ Property::Type type = colorValue->GetType();
+ if( type == Property::VECTOR4 )
+ {
+ SetMixColor( color );
+ }
+ else if( type == Property::VECTOR3 )
+ {
+ Vector3 color3(color);
+ SetMixColor( color3 );
+ }
+ }
+ else
+ {
+ DALI_LOG_ERROR("ColorVisual: mixColor property has incorrect type\n");
+ }
+ }
+
+ Property::Value* renderIfTransparentValue = propertyMap.Find( Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT, RENDER_IF_TRANSPARENT_NAME );
+ if( renderIfTransparentValue )
{
- DALI_LOG_ERROR( "Fail to provide a color to the ColorVisual object\n" );
+ if( ! renderIfTransparentValue->Get( mRenderIfTransparent ) )
+ {
+ DALI_LOG_ERROR( "ColorVisual: renderIfTransparent property has incorrect type: %d\n", renderIfTransparentValue->GetType() );
+ }
+ }
+
+ Property::Value* blurRadiusValue = propertyMap.Find( Toolkit::DevelColorVisual::Property::BLUR_RADIUS, BLUR_RADIUS_NAME );
+ if( blurRadiusValue )
+ {
+ if( !blurRadiusValue->Get( mBlurRadius ) )
+ {
+ DALI_LOG_ERROR( "ColorVisual:DoSetProperties:: BLUR_RADIUS property has incorrect type: %d\n", blurRadiusValue->GetType() );
+ }
}
}
-void ColorVisual::SetSize( const Vector2& size )
+void ColorVisual::DoSetOnScene( Actor& actor )
{
- Visual::Base::SetSize( size );
+ InitializeRenderer();
+
+ // Only add the renderer if it's not fully transparent
+ // We cannot avoid creating a renderer as it's used in the base class
+ if( mRenderIfTransparent || mImpl->mMixColor.a > 0.0f )
+ {
+ actor.AddRenderer( mImpl->mRenderer );
+ }
- // ToDo: renderer responds to the size change
+ // Color Visual generated and ready to display
+ ResourceReady( Toolkit::Visual::ResourceStatus::READY );
}
-void ColorVisual::DoSetOnStage( Actor& actor )
+void ColorVisual::DoSetOffScene(Actor& actor)
{
- InitializeRenderer();
+ if(mImpl->mRenderer && mBlurRadiusIndex != Property::INVALID_INDEX)
+ {
+ // Update values from Renderer
+ mBlurRadius = mImpl->mRenderer.GetProperty<float>(mBlurRadiusIndex);
+ }
- actor.AddRenderer( mImpl->mRenderer );
+ actor.RemoveRenderer(mImpl->mRenderer);
+ mImpl->mRenderer.Reset();
+ mBlurRadiusIndex = Property::INVALID_INDEX;
}
void ColorVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::COLOR );
- map.Insert( Toolkit::ColorVisual::Property::MIX_COLOR, mMixColor );
+ map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR );
+ map.Insert( Toolkit::ColorVisual::Property::MIX_COLOR, mImpl->mMixColor );
+ map.Insert( Toolkit::DevelColorVisual::Property::RENDER_IF_TRANSPARENT, mRenderIfTransparent );
+
+ if(mImpl->mRenderer && mBlurRadiusIndex != Property::INVALID_INDEX)
+ {
+ // Update values from Renderer
+ float blurRadius = mImpl->mRenderer.GetProperty<float>(mBlurRadiusIndex);
+ map.Insert(Toolkit::DevelColorVisual::Property::BLUR_RADIUS, blurRadius);
+ }
+ else
+ {
+ map.Insert(Toolkit::DevelColorVisual::Property::BLUR_RADIUS, mBlurRadius);
+ }
}
-void ColorVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
+void ColorVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
{
- // TODO
- /* David Steele comented :
-
- Some things to bear in mind:
-
- We currently keep a copy of the mix color in the ColorVisual object, which is then used to instantiate the registered property on the renderer.
+ // Do nothing
+}
- The user can get the renderer and animate the mixColor property (it's registered, so is automatically a scene-graph property).
+void ColorVisual::OnSetTransform()
+{
+ if( mImpl->mRenderer )
+ {
+ mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
+ }
+}
- The GetProperty method will have to read from the renderer, or from the cached value in the Visual, and the SetProperty will have to write to cache and to the renderer if present.
- */
+void ColorVisual::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
+{
+ // Check if action is valid for this visual type and perform action if possible
+ switch( actionId )
+ {
+ case DevelColorVisual::Action::UPDATE_PROPERTY:
+ {
+ const Property::Map* map = attributes.GetMap();
+ if( map )
+ {
+ DoSetProperties( *map );
+ }
+ break;
+ }
+ }
}
-Dali::Property::Value ColorVisual::DoGetProperty( Dali::Property::Index index )
+void ColorVisual::UpdateShader()
{
- // TODO
- return Dali::Property::Value();
+ if(mImpl->mRenderer)
+ {
+ Shader shader = GetShader();
+ mImpl->mRenderer.SetShader(shader);
+ }
}
void ColorVisual::InitializeRenderer()
{
Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
- if( !geometry )
- {
- geometry = VisualFactoryCache::CreateQuadGeometry();
- mFactoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY, geometry );
- }
- Shader shader = mFactoryCache.GetShader( VisualFactoryCache::COLOR_SHADER );
- if( !shader )
+ Shader shader = GetShader();
+
+ mImpl->mRenderer = Renderer::New(geometry, shader);
+
+ // ColorVisual has it's own index key for mix color - use this instead
+ // of using the new base index to avoid changing existing applications
+ // String keys will get to this property.
+ mImpl->mMixColorIndex = mImpl->mRenderer.RegisterProperty(Toolkit::ColorVisual::Property::MIX_COLOR, MIX_COLOR, Vector3(mImpl->mMixColor));
+
+ if(!EqualsZero(mBlurRadius))
{
- shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
- mFactoryCache.SaveShader( VisualFactoryCache::COLOR_SHADER, shader );
+ mBlurRadiusIndex = mImpl->mRenderer.RegisterProperty(DevelColorVisual::Property::BLUR_RADIUS, BLUR_RADIUS_NAME, mBlurRadius);
+ mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
}
- mImpl->mRenderer = Renderer::New( geometry, shader );
+ // Register transform properties
+ mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+}
- mMixColorIndex = mImpl->mRenderer.RegisterProperty( Toolkit::ColorVisual::Property::MIX_COLOR, COLOR_NAME, mMixColor );
- if( mMixColor.a < 1.f )
+Shader ColorVisual::GetShader()
+{
+ Shader shader;
+ if(!EqualsZero(mBlurRadius) || mNeedBlurRadius)
{
- mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+ shader = mFactoryCache.GetShader( VisualFactoryCache::COLOR_SHADER_BLUR_EDGE );
+ if( !shader )
+ {
+ shader = Shader::New( Dali::Shader::GetVertexShaderPrefix() + SHADER_COLOR_VISUAL_BLUR_EDGE_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_COLOR_VISUAL_BLUR_EDGE_SHADER_FRAG.data() );
+ mFactoryCache.SaveShader( VisualFactoryCache::COLOR_SHADER_BLUR_EDGE, shader );
+ }
}
+ else if( !IsRoundedCornerRequired() )
+ {
+ shader = mFactoryCache.GetShader( VisualFactoryCache::COLOR_SHADER );
+ if( !shader )
+ {
+ shader = Shader::New( Dali::Shader::GetVertexShaderPrefix() + SHADER_COLOR_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_COLOR_VISUAL_SHADER_FRAG.data() );
+ mFactoryCache.SaveShader( VisualFactoryCache::COLOR_SHADER, shader );
+ }
+ }
+ else
+ {
+ shader = mFactoryCache.GetShader( VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER );
+ if( !shader )
+ {
+ shader = Shader::New( Dali::Shader::GetVertexShaderPrefix() + SHADER_COLOR_VISUAL_ROUNDED_CORNER_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_COLOR_VISUAL_ROUNDED_CORNER_SHADER_FRAG.data() );
+ mFactoryCache.SaveShader( VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER, shader );
+ }
+ }
+
+ return shader;
}
-void ColorVisual::SetColor(const Vector4& color)
+Dali::Property ColorVisual::OnGetPropertyObject(Dali::Property::Key key)
{
- mMixColor = color;
+ if(!mImpl->mRenderer)
+ {
+ Handle handle;
+ return Dali::Property(handle, Property::INVALID_INDEX);
+ }
- if( mImpl->mRenderer )
+ if((key.type == Property::Key::INDEX && key.indexKey == DevelColorVisual::Property::BLUR_RADIUS) || (key.type == Property::Key::STRING && key.stringKey == BLUR_RADIUS_NAME))
{
- (mImpl->mRenderer).SetProperty( mMixColorIndex, color );
- if( color.a < 1.f )
- {
- mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
- }
+ mBlurRadiusIndex = mImpl->mRenderer.RegisterProperty(DevelColorVisual::Property::BLUR_RADIUS, BLUR_RADIUS_NAME, mBlurRadius);
+
+ mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
+
+ mNeedBlurRadius = true;
+
+ // Change shader
+ UpdateShader();
+
+ return Dali::Property(mImpl->mRenderer, mBlurRadiusIndex);
}
+
+ Handle handle;
+ return Dali::Property(handle, Property::INVALID_INDEX);
}
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff