X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fimage%2Fimage-visual.cpp;h=bd32b97d64692ed92534f948526ad39f2abe9a66;hb=refs%2Fchanges%2F91%2F170491%2F7;hp=9522618406c360b384e2e71abd7183a5f6d81e0a;hpb=48d13d45cb7f363d3cf8da048ce6cef074c55060;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/visuals/image/image-visual.cpp b/dali-toolkit/internal/visuals/image/image-visual.cpp index 9522618..bd32b97 100644 --- a/dali-toolkit/internal/visuals/image/image-visual.cpp +++ b/dali-toolkit/internal/visuals/image/image-visual.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * Copyright (c) 2018 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. @@ -33,6 +33,7 @@ // INTERNAL HEADERS #include #include +#include #include #include #include @@ -93,15 +94,15 @@ DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE ) // load policies DALI_ENUM_TO_STRING_TABLE_BEGIN( LOAD_POLICY ) -DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::LoadPolicy, IMMEDIATE ) -DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::LoadPolicy, ATTACHED ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::LoadPolicy, IMMEDIATE ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::LoadPolicy, ATTACHED ) DALI_ENUM_TO_STRING_TABLE_END( LOAD_POLICY ) // release policies DALI_ENUM_TO_STRING_TABLE_BEGIN( RELEASE_POLICY ) -DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DETACHED ) -DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DESTROYED ) -DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, NEVER ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::ReleasePolicy, DETACHED ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::ReleasePolicy, DESTROYED ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::ReleasePolicy, NEVER ) DALI_ENUM_TO_STRING_TABLE_END( RELEASE_POLICY ) const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); @@ -151,16 +152,11 @@ const char* FRAGMENT_SHADER_NO_ATLAS = DALI_COMPOSE_SHADER( uniform sampler2D sTexture;\n uniform lowp vec4 uColor;\n uniform lowp vec3 mixColor;\n - uniform lowp float opacity;\n uniform lowp float preMultipliedAlpha;\n \n - lowp vec4 visualMixColor()\n - {\n - return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n - }\n void main()\n {\n - gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * visualMixColor();\n + gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n }\n ); @@ -170,18 +166,12 @@ const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER( uniform mediump vec4 uAtlasRect;\n uniform lowp vec4 uColor;\n uniform lowp vec3 mixColor;\n - uniform lowp float opacity;\n uniform lowp float preMultipliedAlpha;\n \n - lowp vec4 visualMixColor()\n - {\n - return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n - }\n - \n void main()\n {\n mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n - gl_FragColor = texture2D( sTexture, texCoord ) * uColor * visualMixColor();\n + gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n }\n ); @@ -193,7 +183,6 @@ const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER( uniform lowp vec2 wrapMode;\n uniform lowp vec4 uColor;\n uniform lowp vec3 mixColor;\n - uniform lowp float opacity;\n uniform lowp float preMultipliedAlpha;\n \n mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n @@ -206,16 +195,11 @@ const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER( return clamp( mix(range.x, range.y, coord), range.x, range.y ); }\n \n - lowp vec4 visualMixColor()\n - {\n - return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n - }\n - \n void main()\n {\n mediump vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ), wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );\n - gl_FragColor = texture2D( sTexture, texCoord ) * uColor * visualMixColor();\n + gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n }\n ); @@ -268,7 +252,7 @@ ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, ImageDimensions size, FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode ) -: Visual::Base( factoryCache ), +: Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO ), mImage(), mPixelArea( FULL_TEXTURE_RECT ), mPlacementActor(), @@ -276,19 +260,22 @@ ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, mMaskingData( ), mDesiredSize( size ), mTextureId( TextureManager::INVALID_TEXTURE_ID ), + mTextures(), mFittingMode( fittingMode ), mSamplingMode( samplingMode ), mWrapModeU( WrapMode::DEFAULT ), mWrapModeV( WrapMode::DEFAULT ), - mLoadPolicy( DevelImageVisual::LoadPolicy::ATTACHED ), - mReleasePolicy( DevelImageVisual::ReleasePolicy::DETACHED ), + mLoadPolicy( Toolkit::ImageVisual::LoadPolicy::ATTACHED ), + mReleasePolicy( Toolkit::ImageVisual::ReleasePolicy::DETACHED ), + mAtlasRect( 0.0f, 0.0f, 0.0f, 0.0f ), mAttemptAtlasing( false ), - mLoading( false ) + mLoading( false ), + mOrientationCorrection( true ) { } ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image ) -: Visual::Base( factoryCache ), +: Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO ), mImage( image ), mPixelArea( FULL_TEXTURE_RECT ), mPlacementActor(), @@ -296,14 +283,17 @@ ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image ) mMaskingData( ), mDesiredSize(), mTextureId( TextureManager::INVALID_TEXTURE_ID ), + mTextures(), mFittingMode( FittingMode::DEFAULT ), mSamplingMode( SamplingMode::DEFAULT ), mWrapModeU( WrapMode::DEFAULT ), mWrapModeV( WrapMode::DEFAULT ), - mLoadPolicy( DevelImageVisual::LoadPolicy::ATTACHED ), - mReleasePolicy( DevelImageVisual::ReleasePolicy::DESTROYED ), + mLoadPolicy( Toolkit::ImageVisual::LoadPolicy::ATTACHED ), + mReleasePolicy( Toolkit::ImageVisual::ReleasePolicy::DESTROYED ), + mAtlasRect( 0.0f, 0.0f, 0.0f, 0.0f ), mAttemptAtlasing( false ), - mLoading( false ) + mLoading( false ), + mOrientationCorrection( true ) { } @@ -324,7 +314,7 @@ ImageVisual::~ImageVisual() } // ImageVisual destroyed so remove texture unless ReleasePolicy is set to never release - if( ( mTextureId != TextureManager::INVALID_TEXTURE_ID ) && ( mReleasePolicy != DevelImageVisual::ReleasePolicy::NEVER ) ) + if( ( mTextureId != TextureManager::INVALID_TEXTURE_ID ) && ( mReleasePolicy != Toolkit::ImageVisual::ReleasePolicy::NEVER ) ) { RemoveTexture(); } @@ -393,20 +383,24 @@ void ImageVisual::DoSetProperties( const Property::Map& propertyMap ) } else if ( keyValue.first == LOAD_POLICY_NAME ) { - DoSetProperty( Toolkit::DevelImageVisual::Property::LOAD_POLICY, keyValue.second ); + DoSetProperty( Toolkit::ImageVisual::Property::LOAD_POLICY, keyValue.second ); } else if( keyValue.first == RELEASE_POLICY_NAME ) { - DoSetProperty( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, keyValue.second ); + DoSetProperty( Toolkit::ImageVisual::Property::RELEASE_POLICY, keyValue.second ); + } + else if( keyValue.first == ORIENTATION_CORRECTION_NAME ) + { + DoSetProperty( Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION, keyValue.second ); } } } - // Load image immediately if LOAD_POLICY requires it - if ( mLoadPolicy == DevelImageVisual::LoadPolicy::IMMEDIATE ) + if ( mLoadPolicy == Toolkit::ImageVisual::LoadPolicy::IMMEDIATE ) { - auto attemptAtlasing = mAttemptAtlasing; - LoadTexture( attemptAtlasing, mAtlasRect, mTextures ); + auto attemptAtlasing = AttemptAtlasing(); + LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection, + TextureManager::ReloadPolicy::CACHED ); } } @@ -503,8 +497,7 @@ void ImageVisual::DoSetProperty( Property::Index index, const Property::Value& v case Toolkit::ImageVisual::Property::ATLASING: { - bool atlasing = false; - mAttemptAtlasing = value.Get( atlasing ); + value.Get( mAttemptAtlasing ); break; } @@ -544,19 +537,29 @@ void ImageVisual::DoSetProperty( Property::Index index, const Property::Value& v break; } - case Toolkit::DevelImageVisual::Property::RELEASE_POLICY: + case Toolkit::ImageVisual::Property::RELEASE_POLICY: { int releasePolicy; Scripting::GetEnumerationProperty( value, RELEASE_POLICY_TABLE, RELEASE_POLICY_TABLE_COUNT, releasePolicy ); - mReleasePolicy = DevelImageVisual::ReleasePolicy::Type( releasePolicy ); + mReleasePolicy = Toolkit::ImageVisual::ReleasePolicy::Type( releasePolicy ); break; } - case Toolkit::DevelImageVisual::Property::LOAD_POLICY: + case Toolkit::ImageVisual::Property::LOAD_POLICY: { int loadPolicy; Scripting::GetEnumerationProperty( value, LOAD_POLICY_TABLE, LOAD_POLICY_TABLE_COUNT, loadPolicy ); - mLoadPolicy = DevelImageVisual::LoadPolicy::Type( loadPolicy ); + mLoadPolicy = Toolkit::ImageVisual::LoadPolicy::Type( loadPolicy ); + break; + } + case Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION: + { + bool orientationCorrection( mOrientationCorrection ); + if( value.Get( orientationCorrection ) ) + { + mOrientationCorrection = orientationCorrection; + } + break; } } } @@ -678,6 +681,11 @@ void ImageVisual::CreateRenderer( TextureSet& textureSet ) //Register transform properties mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); + + if( IsPreMultipliedAlphaEnabled() ) + { + EnablePreMultipliedAlpha( true ); + } } void ImageVisual::CreateNativeImageRenderer( NativeImage& nativeImage ) @@ -734,13 +742,13 @@ void ImageVisual::CreateNativeImageRenderer( NativeImage& nativeImage ) mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); } - bool ImageVisual::IsSynchronousResourceLoading() const { return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING; } -void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures ) +void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures, bool orientationCorrection, + TextureManager::ReloadPolicy forceReload ) { TextureManager& textureManager = mFactoryCache.GetTextureManager(); @@ -754,25 +762,22 @@ void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& t atlasUploadObserver = this; } + auto preMultiplyOnLoad = mFactoryCache.GetPreMultiplyOnLoad() && !mImpl->mCustomShader + ? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD + : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY; + textures = textureManager.LoadTexture( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, mMaskingData, IsSynchronousResourceLoading(), mTextureId, atlasRect, atlasing, mLoading, mWrapModeU, - mWrapModeV, textureObserver, atlasUploadObserver, atlasManager ); -} - -void ImageVisual::InitializeRenderer() -{ - auto attemptAtlasing = ( ! mImpl->mCustomShader && mImageUrl.GetProtocolType() == VisualUrl::LOCAL && mAttemptAtlasing ); + mWrapModeV, textureObserver, atlasUploadObserver, atlasManager, + mOrientationCorrection, forceReload, preMultiplyOnLoad); - // texture set has to be created first as we need to know if atlasing succeeded or not - // when selecting the shader - - if( mTextureId == TextureManager::INVALID_TEXTURE_ID && ! mTextures ) // Only load the texture once + if( textures && preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD) { - LoadTexture( attemptAtlasing, mAtlasRect, mTextures ); + EnablePreMultipliedAlpha( true ); } - if( attemptAtlasing ) // Flag needs to be set before creating renderer + if( atlasing ) // Flag needs to be set before creating renderer { mImpl->mFlags |= Impl::IS_ATLASING_APPLIED; } @@ -780,6 +785,24 @@ void ImageVisual::InitializeRenderer() { mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED; } +} + +bool ImageVisual::AttemptAtlasing() +{ + return ( ! mImpl->mCustomShader && mImageUrl.GetProtocolType() == VisualUrl::LOCAL && mAttemptAtlasing ); +} + +void ImageVisual::InitializeRenderer() +{ + auto attemptAtlasing = AttemptAtlasing(); + // texture set has to be created first as we need to know if atlasing succeeded or not + // when selecting the shader + + if( mTextureId == TextureManager::INVALID_TEXTURE_ID && ! mTextures ) // Only load the texture once + { + LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection, + TextureManager::ReloadPolicy::CACHED ); + } CreateRenderer( mTextures ); mTextures.Reset(); // Visual should not keep a handle to the texture after this point. @@ -854,7 +877,7 @@ void ImageVisual::DoSetOnStage( Actor& actor ) mPlacementActor.Reset(); // Image loaded and ready to display - ResourceReady(); + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); } } @@ -864,7 +887,7 @@ void ImageVisual::DoSetOffStage( Actor& actor ) // Image release is dependent on the ReleasePolicy, renderer is destroyed. actor.RemoveRenderer( mImpl->mRenderer); - if( mReleasePolicy == DevelImageVisual::ReleasePolicy::DETACHED ) + if( mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED ) { RemoveTexture(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas } @@ -912,6 +935,7 @@ void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV ); map.Insert( Toolkit::ImageVisual::Property::ATLASING, mAttemptAtlasing ); + if( mMaskingData != NULL ) { map.Insert( Toolkit::ImageVisual::Property::ALPHA_MASK_URL, mMaskingData->mAlphaMaskUrl.GetUrl() ); @@ -919,9 +943,9 @@ void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const map.Insert( Toolkit::ImageVisual::Property::CROP_TO_MASK, mMaskingData->mCropToMask ); } - map.Insert( Toolkit::DevelImageVisual::Property::LOAD_POLICY, mLoadPolicy ); - map.Insert( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, mReleasePolicy ); - + map.Insert( Toolkit::ImageVisual::Property::LOAD_POLICY, mLoadPolicy ); + map.Insert( Toolkit::ImageVisual::Property::RELEASE_POLICY, mReleasePolicy ); + map.Insert( Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION, mOrientationCorrection ); } void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const @@ -940,6 +964,22 @@ void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const } } +void ImageVisual::OnDoAction( const Dali::Property::Index actionName, const Dali::Property::Value& attributes ) +{ + // Check if action is valid for this visual type and perform action if possible + + switch ( actionName ) + { + case DevelImageVisual::Action::RELOAD: + { + auto attemptAtlasing = AttemptAtlasing(); + LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection, + TextureManager::ReloadPolicy::FORCED ); + break; + } + } +} + void ImageVisual::OnSetTransform() { if( mImpl->mRenderer ) @@ -948,6 +988,12 @@ void ImageVisual::OnSetTransform() } } +bool ImageVisual::IsResourceReady() const +{ + return ( mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY || + mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED ); +} + Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping ) { Shader shader; @@ -1005,7 +1051,8 @@ void ImageVisual::ApplyImageToSampler( const Image& image ) // From existing atlas manager void ImageVisual::UploadCompleted() { - // Texture has been uploaded. If weak handle is holding a placement actor, it is the time to add the renderer to actor. + // Texture has been uploaded. If weak handle is holding a placement actor, + // it is the time to add the renderer to actor. Actor actor = mPlacementActor.GetHandle(); if( actor ) { @@ -1014,12 +1061,16 @@ void ImageVisual::UploadCompleted() // reset the weak handle so that the renderer only get added to actor once mPlacementActor.Reset(); } + // Image loaded + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); mLoading = false; } // From Texture Manager -void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, TextureSet textureSet, bool usingAtlas, const Vector4& atlasRectangle ) +void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, TextureSet textureSet, bool usingAtlas, + const Vector4& atlasRectangle, bool preMultiplied ) { + Toolkit::Visual::ResourceStatus resourceStatus; Actor actor = mPlacementActor.GetHandle(); if( actor ) { @@ -1029,6 +1080,10 @@ void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, Textur { mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect ); } + else if( preMultiplied ) + { + EnablePreMultipliedAlpha( true ); + } actor.AddRenderer( mImpl->mRenderer ); // reset the weak handle so that the renderer only get added to actor once @@ -1049,10 +1104,25 @@ void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, Textur ApplyImageToSampler( brokenImage ); } - // Image loaded and ready to display - ResourceReady(); } } + // Storing TextureSet needed when renderer staged. + if( ! mImpl->mRenderer ) + { + mTextures = textureSet; + } + + // Image loaded, set status regardless of staged status. + if( loadingSuccess ) + { + resourceStatus = Toolkit::Visual::ResourceStatus::READY; + } + else + { + resourceStatus = Toolkit::Visual::ResourceStatus::FAILED; + } + // Signal to observers ( control ) that resources are ready. Must be all resources. + ResourceReady( resourceStatus ); mLoading = false; }