X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fimage%2Fimage-visual.cpp;h=59177546e29feae710280d7595f9323f195233b9;hp=295aeb8606fe54cf16a847c99efe4f6b614ac2de;hb=6ee3158c2bb9ef4993947d65f520c00eca6edde3;hpb=2bb13a39de0bd638bc8f436df99971c07c8a004b diff --git a/dali-toolkit/internal/visuals/image/image-visual.cpp b/dali-toolkit/internal/visuals/image/image-visual.cpp index 295aeb8..5917754 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); @@ -268,7 +269,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 +277,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,12 +300,14 @@ 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 ), mOrientationCorrection( true ) @@ -325,7 +331,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(); } @@ -394,24 +400,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::DevelImageVisual::Property::ORIENTATION_CORRECTION, keyValue.second ); + 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, mOrientationCorrection ); + auto attemptAtlasing = AttemptAtlasing(); + LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection, + TextureManager::ReloadPolicy::CACHED ); } } @@ -508,8 +514,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; } @@ -549,22 +554,22 @@ 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::DevelImageVisual::Property::ORIENTATION_CORRECTION: + case Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION: { bool orientationCorrection( mOrientationCorrection ); if( value.Get( orientationCorrection ) ) @@ -693,6 +698,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 ) @@ -749,13 +759,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, bool orientationCorrection ) +void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures, bool orientationCorrection, + TextureManager::ReloadPolicy forceReload ) { TextureManager& textureManager = mFactoryCache.GetTextureManager(); @@ -769,25 +779,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, mOrientationCorrection ); -} - -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, mOrientationCorrection ); + 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; } @@ -795,6 +802,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. @@ -879,7 +904,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 } @@ -935,9 +960,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::DevelImageVisual::Property::ORIENTATION_CORRECTION, mOrientationCorrection ); + 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 @@ -956,6 +981,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 ) @@ -1027,7 +1068,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 ) { @@ -1036,11 +1078,14 @@ 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(); @@ -1052,6 +1097,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 @@ -1062,8 +1111,6 @@ void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, Textur sampler.SetWrapMode( mWrapModeU, mWrapModeV ); textureSet.SetSampler( 0u, sampler ); mImpl->mRenderer.SetTextures(textureSet); - - resourceStatus = Toolkit::Visual::ResourceStatus::READY; } else { @@ -1073,20 +1120,26 @@ void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, Textur mImpl->mRenderer.SetTextures( textureSet ); ApplyImageToSampler( brokenImage ); - - resourceStatus = Toolkit::Visual::ResourceStatus::FAILED; } - // Image loaded and ready to display - ResourceReady( resourceStatus ); } } - // 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; }