X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fsvg%2Fsvg-visual.cpp;h=32ff4cfc07ab2a6cff428d5a7bcdce7b907c41d5;hb=23ef2e29789ebe7ba3c6af903fb0f55c782e39cc;hp=df53192bcdffaf4d9246065c9dc22b1fd7134f0e;hpb=574ce69b5c6abe40f245aa2dc7e36e55ca873995;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/visuals/svg/svg-visual.cpp b/dali-toolkit/internal/visuals/svg/svg-visual.cpp index df53192..32ff4cf 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,18 @@ // 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 +#include +#include namespace Dali { @@ -54,20 +40,40 @@ namespace Toolkit namespace Internal { -SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, const std::string& imageUrl ) +namespace { - SvgVisual* svgVisual = new SvgVisual( factoryCache ); - svgVisual->ParseFromUrl( imageUrl ); +// property name +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, shaderFactory, imageUrl ) ); + svgVisual->Load(); + svgVisual->SetProperties(properties); return svgVisual; } -SvgVisual::SvgVisual( VisualFactoryCache& factoryCache ) -: Visual::Base( factoryCache ), +SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl ) +{ + SvgVisualPtr svgVisual( new SvgVisual( factoryCache, shaderFactory, imageUrl ) ); + svgVisual->Load(); + return svgVisual; +} + +SvgVisual::SvgVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl ) +: Visual::Base( factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::SVG ), + mImageVisualShaderFactory( shaderFactory ), mAtlasRect( FULL_TEXTURE_RECT ), - mImageUrl(), - mParsedImage( NULL ), + mImageUrl( imageUrl ), + mVectorRenderer( VectorImageRenderer::New() ), + mDefaultWidth( 0 ), + mDefaultHeight( 0 ), + mLoaded( false ), mPlacementActor(), - mVisualSize(Vector2::ZERO) + mVisualSize(Vector2::ZERO), + mAttemptAtlasing( false ) { // the rasterized image is with pre-multiplied alpha format mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA; @@ -75,26 +81,78 @@ SvgVisual::SvgVisual( VisualFactoryCache& factoryCache ) SvgVisual::~SvgVisual() { - if( mParsedImage ) - { - nsvgDelete( mParsedImage ); - } } 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 ); + } + else if( keyValue.first == SYNCHRONOUS_LOADING ) + { + DoSetProperty( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second ); + } + } } -void SvgVisual::DoSetOnStage( Actor& actor ) +void SvgVisual::DoSetProperty( Property::Index index, const Property::Value& value ) { - Shader shader = ImageVisual::GetImageShader( mFactoryCache, true, true ); - Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); - if( !geometry ) + switch( index ) { - geometry = mFactoryCache.CreateQuadGeometry(); - mFactoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY, geometry ); + case Toolkit::ImageVisual::Property::ATLASING: + { + value.Get( mAttemptAtlasing ); + break; + } + case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING: + { + bool sync = false; + if( value.Get( sync ) ) + { + if( sync ) + { + mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING; + } + else + { + mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING; + } + } + else + { + DALI_LOG_ERROR("ImageVisual: synchronousLoading property has incorrect type\n"); + } + break; + } } +} + +void SvgVisual::DoSetOnScene( Actor& actor ) +{ + Shader shader; + if( !mImpl->mCustomShader ) + { + shader = mImageVisualShaderFactory.GetShader( mFactoryCache, mAttemptAtlasing, true, false ); + } + 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 ); @@ -106,23 +164,29 @@ 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 ) +void SvgVisual::DoSetOffScene( Actor& actor ) { mFactoryCache.GetSVGRasterizationThread()->RemoveTask( this ); 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 ) { - if( mParsedImage ) + if(mLoaded) { - naturalSize.x = mParsedImage->width; - naturalSize.y = mParsedImage->height; + naturalSize.x = mDefaultWidth; + naturalSize.y = mDefaultHeight; } else { @@ -133,68 +197,102 @@ void SvgVisual::GetNaturalSize( Vector2& naturalSize ) void SvgVisual::DoCreatePropertyMap( Property::Map& map ) const { map.Clear(); - map.Insert( Toolkit::VisualProperty::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 ); } + map.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired() ); } -void SvgVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue ) -{ - // TODO -} - -Dali::Property::Value SvgVisual::DoGetProperty( Dali::Property::Index index ) +void SvgVisual::DoCreateInstancePropertyMap( Property::Map& map ) const { - // TODO - return Dali::Property::Value(); + // Do nothing } -void SvgVisual::ParseFromUrl( const std::string& imageUrl ) +void SvgVisual::Load() { - mImageUrl = imageUrl; + // load remote resource on svg rasterize thread. + if(!mLoaded && mImageUrl.IsLocalResource()) + { + Dali::Vector buffer; + if(Dali::FileLoader::ReadFile(mImageUrl.GetUrl(), buffer)) + { + buffer.PushBack('\0'); - Vector2 dpi = Stage::GetCurrent().GetDpi(); - float meanDpi = (dpi.height + dpi.width) * 0.5f; - mParsedImage = nsvgParseFromFile( imageUrl.c_str(), UNITS, meanDpi ); + Vector2 dpi = Stage::GetCurrent().GetDpi(); + float meanDpi = (dpi.height + dpi.width) * 0.5f; + if(!mVectorRenderer.Load(buffer, meanDpi)) + { + DALI_LOG_ERROR("SvgVisual::Load: Failed to load file! [%s]\n", mImageUrl.GetUrl().c_str()); + return; + } + mVectorRenderer.GetDefaultSize(mDefaultWidth, mDefaultHeight); + mLoaded = true; + } + else + { + DALI_LOG_ERROR("SvgVisual::Load: Failed to read file! [%s]\n", mImageUrl.GetUrl().c_str()); + } + } } 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 ); - mFactoryCache.GetSVGRasterizationThread()->AddTask( newTask ); + Vector2 dpi = Stage::GetCurrent().GetDpi(); + float meanDpi = ( dpi.height + dpi.width ) * 0.5f; + + RasterizingTaskPtr newTask = new RasterizingTask(this, mVectorRenderer, mImageUrl, meanDpi, width, height, mLoaded); + if(IsSynchronousLoadingRequired()) + { + newTask->Load(); + newTask->Rasterize(); + ApplyRasterizedImage(newTask->GetVectorRenderer(), newTask->GetPixelData(), newTask->IsLoaded()); + } + else + { + mFactoryCache.GetSVGRasterizationThread()->AddTask( newTask ); + } } } -void SvgVisual::ApplyRasterizedImage( PixelData rasterizedPixelData ) +void SvgVisual::ApplyRasterizedImage( VectorImageRenderer vectorRenderer, PixelData rasterizedPixelData, bool isLoaded ) { - if( IsOnStage() ) + mLoaded = isLoaded; + + if(isLoaded && rasterizedPixelData && IsOnScene()) { 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() ); @@ -228,6 +326,13 @@ 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 ); + } + else if(!isLoaded || !rasterizedPixelData) + { + ResourceReady( Toolkit::Visual::ResourceStatus::FAILED ); } } @@ -235,7 +340,7 @@ void SvgVisual::OnSetTransform() { Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize ); - if( mParsedImage && IsOnStage() ) + if( IsOnScene() ) { if( visualSize != mVisualSize ) { @@ -243,6 +348,17 @@ void SvgVisual::OnSetTransform() mVisualSize = visualSize; } } + + if(mImpl->mRenderer) + { + mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT); + } +} + +bool SvgVisual::IsResourceReady() const +{ + return ( mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY || + mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED ); } } // namespace Internal