X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fsvg%2Fsvg-visual.cpp;h=051affee8cc3191cb1cb20258a1c8a14dc976f7f;hp=5dbb80f55c37d9f4b1340208cc7e881718cfdc1b;hb=5a6809a40da6a50d2edce9202466aa289ad96162;hpb=88b69217fe05ad98aab6d9d41e030d934093f82c diff --git a/dali-toolkit/internal/visuals/svg/svg-visual.cpp b/dali-toolkit/internal/visuals/svg/svg-visual.cpp index 5dbb80f..051affe 100644 --- a/dali-toolkit/internal/visuals/svg/svg-visual.cpp +++ b/dali-toolkit/internal/visuals/svg/svg-visual.cpp @@ -1,5 +1,5 @@ /* - * 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. @@ -18,32 +18,17 @@ // CLASS HEADER #include "svg-visual.h" -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include - // INTERNAL INCLUDES -#include -#include #include #include -#include #include -#include #include #include +#include +#include - -namespace -{ -const char * const UNITS("px"); - -const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); -} +// EXTERNAL INCLUDES +#include namespace Dali { @@ -54,30 +39,42 @@ namespace Toolkit namespace Internal { -SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, const std::string& imageUrl, const Property::Map& properties ) +namespace +{ +// property name +const char * const UNITS("px"); + +const char * const IMAGE_ATLASING( "atlasing" ); + +const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); +} + +SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties ) { - SvgVisualPtr svgVisual( new SvgVisual( factoryCache ) ); + SvgVisualPtr svgVisual( new SvgVisual( factoryCache, shaderFactory, imageUrl ) ); svgVisual->ParseFromUrl( imageUrl ); svgVisual->SetProperties( properties ); return svgVisual; } -SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, const std::string& imageUrl ) +SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl ) { - SvgVisualPtr svgVisual( new SvgVisual( factoryCache ) ); + SvgVisualPtr svgVisual( new SvgVisual( factoryCache, shaderFactory, imageUrl ) ); svgVisual->ParseFromUrl( imageUrl ); return svgVisual; } -SvgVisual::SvgVisual( VisualFactoryCache& factoryCache ) -: Visual::Base( factoryCache ), +SvgVisual::SvgVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl ) +: Visual::Base( factoryCache, Visual::FittingMode::FILL ), + mImageVisualShaderFactory( shaderFactory ), mAtlasRect( FULL_TEXTURE_RECT ), - mImageUrl(), + mImageUrl( imageUrl ), mParsedImage( NULL ), mPlacementActor(), - mVisualSize(Vector2::ZERO) + mVisualSize(Vector2::ZERO), + mAttemptAtlasing( false ) { // the rasterized image is with pre-multiplied alpha format mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA; @@ -94,17 +91,49 @@ SvgVisual::~SvgVisual() void SvgVisual::DoSetProperties( const Property::Map& propertyMap ) { // url already passed in from constructor + for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter ) + { + KeyValuePair keyValue = propertyMap.GetKeyValue( iter ); + if( keyValue.first.type == Property::Key::INDEX ) + { + DoSetProperty( keyValue.first.indexKey, keyValue.second ); + } + else if( keyValue.first == IMAGE_ATLASING ) + { + DoSetProperty( Toolkit::ImageVisual::Property::ATLASING, keyValue.second ); + } + } +} + +void SvgVisual::DoSetProperty( Property::Index index, const Property::Value& value ) +{ + switch( index ) + { + case Toolkit::ImageVisual::Property::ATLASING: + { + value.Get( mAttemptAtlasing ); + break; + } + } } void SvgVisual::DoSetOnStage( Actor& actor ) { - Shader shader = ImageVisual::GetImageShader( mFactoryCache, true, true ); - Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); - if( !geometry ) + Shader shader; + if( !mImpl->mCustomShader ) { - geometry = mFactoryCache.CreateQuadGeometry(); - mFactoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY, geometry ); + shader = mImageVisualShaderFactory.GetShader( mFactoryCache, mAttemptAtlasing, true ); + } + else + { + shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader, + mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader, + mImpl->mCustomShader->mHints ); + + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); } + + Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); TextureSet textureSet = TextureSet::New(); mImpl->mRenderer = Renderer::New( geometry, shader ); mImpl->mRenderer.SetTextures( textureSet ); @@ -116,6 +145,9 @@ void SvgVisual::DoSetOnStage( Actor& actor ) // Hold the weak handle of the placement actor and delay the adding of renderer until the svg rasterization is finished. mPlacementActor = actor; + + // SVG visual needs it's size set before it can be rasterized hence set ResourceReady once on stage + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); } void SvgVisual::DoSetOffStage( Actor& actor ) @@ -125,6 +157,9 @@ void SvgVisual::DoSetOffStage( Actor& actor ) actor.RemoveRenderer( mImpl->mRenderer ); mImpl->mRenderer.Reset(); mPlacementActor.Reset(); + + // Reset the visual size to zero so that when adding the actor back to stage the SVG rasterization is forced + mVisualSize = Vector2::ZERO; } void SvgVisual::GetNaturalSize( Vector2& naturalSize ) @@ -143,57 +178,79 @@ void SvgVisual::GetNaturalSize( Vector2& naturalSize ) void SvgVisual::DoCreatePropertyMap( Property::Map& map ) const { map.Clear(); - map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::IMAGE ); - if( !mImageUrl.empty() ) + map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::SVG ); + if( mImageUrl.IsValid() ) { - map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl ); + map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() ); + map.Insert( Toolkit::ImageVisual::Property::ATLASING, mAttemptAtlasing ); } } -void SvgVisual::ParseFromUrl( const std::string& imageUrl ) +void SvgVisual::DoCreateInstancePropertyMap( Property::Map& map ) const { - mImageUrl = imageUrl; + // Do nothing +} - Vector2 dpi = Stage::GetCurrent().GetDpi(); - float meanDpi = (dpi.height + dpi.width) * 0.5f; - mParsedImage = nsvgParseFromFile( imageUrl.c_str(), UNITS, meanDpi ); +void SvgVisual::ParseFromUrl( const VisualUrl& imageUrl ) +{ + mImageUrl = imageUrl; + if( mImageUrl.IsLocalResource() ) + { + Vector2 dpi = Stage::GetCurrent().GetDpi(); + float meanDpi = ( dpi.height + dpi.width ) * 0.5f; + Dali::Vector buffer; + if ( Dali::FileLoader::ReadFile( mImageUrl.GetUrl(), buffer ) ) + { + buffer.PushBack( '\0' ); + mParsedImage = nsvgParse( buffer.Begin(), UNITS, meanDpi ); + } + } } void SvgVisual::AddRasterizationTask( const Vector2& size ) { - if( mImpl->mRenderer && mParsedImage ) + if( mImpl->mRenderer ) { unsigned int width = static_cast(size.width); unsigned int height = static_cast( size.height ); - RasterizingTaskPtr newTask = new RasterizingTask( this, mParsedImage, width, height ); + Vector2 dpi = Stage::GetCurrent().GetDpi(); + float meanDpi = ( dpi.height + dpi.width ) * 0.5f; + + RasterizingTaskPtr newTask = new RasterizingTask( this, mParsedImage, mImageUrl, meanDpi, width, height ); mFactoryCache.GetSVGRasterizationThread()->AddTask( newTask ); } } -void SvgVisual::ApplyRasterizedImage( PixelData rasterizedPixelData ) +void SvgVisual::ApplyRasterizedImage( NSVGimage* parsedSvg, PixelData rasterizedPixelData ) { - if( IsOnStage() ) + if( mParsedImage && IsOnStage() ) { TextureSet currentTextureSet = mImpl->mRenderer.GetTextures(); - if( mAtlasRect != FULL_TEXTURE_RECT ) + if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED ) { mFactoryCache.GetAtlasManager()->Remove( currentTextureSet, mAtlasRect ); } - Vector4 atlasRect; - TextureSet textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData ); - if( textureSet ) // atlasing + TextureSet textureSet; + + if( mAttemptAtlasing && !mImpl->mCustomShader ) { - if( textureSet != currentTextureSet ) + Vector4 atlasRect; + textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData ); + if( textureSet ) // atlasing { - mImpl->mRenderer.SetTextures( textureSet ); + if( textureSet != currentTextureSet ) + { + mImpl->mRenderer.SetTextures( textureSet ); + } + mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect ); + mAtlasRect = atlasRect; + mImpl->mFlags |= Impl::IS_ATLASING_APPLIED; } - mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect ); - mAtlasRect = atlasRect; - mImpl->mFlags |= Impl::IS_ATLASING_APPLIED; } - else // no atlasing + + if( !textureSet ) // no atlasing - mAttemptAtlasing is false or adding to atlas is failed { Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, Pixel::RGBA8888, rasterizedPixelData.GetWidth(), rasterizedPixelData.GetHeight() ); @@ -227,6 +284,9 @@ void SvgVisual::ApplyRasterizedImage( PixelData rasterizedPixelData ) // reset the weak handle so that the renderer only get added to actor once mPlacementActor.Reset(); } + + // Svg loaded and ready to display + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); } } @@ -234,7 +294,7 @@ void SvgVisual::OnSetTransform() { Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize ); - if( mParsedImage && IsOnStage() ) + if( IsOnStage() ) { if( visualSize != mVisualSize ) { @@ -242,6 +302,11 @@ void SvgVisual::OnSetTransform() mVisualSize = visualSize; } } + + if(mImpl->mRenderer) + { + mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT); + } } } // namespace Internal