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=8845541bfcb5c903545e3dbbd65904c9580f3f31;hp=82f7fd14cb34450513ea055a55f5211a802f59d9;hb=5e351965bad7e1de2e94027548b022bac692603c;hpb=5cf630aa32334b56da941376938d5bef1dbc0857 diff --git a/dali-toolkit/internal/visuals/image/image-visual.cpp b/dali-toolkit/internal/visuals/image/image-visual.cpp index 82f7fd1..8845541 100644 --- a/dali-toolkit/internal/visuals/image/image-visual.cpp +++ b/dali-toolkit/internal/visuals/image/image-visual.cpp @@ -33,6 +33,7 @@ // INTERNAL HEADERS #include #include +#include #include #include #include @@ -91,6 +92,12 @@ DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT ) DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT ) 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_TABLE_END( LOAD_POLICY ) + // release policies DALI_ENUM_TO_STRING_TABLE_BEGIN( RELEASE_POLICY ) DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DETACHED ) @@ -270,13 +277,17 @@ 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 ), + mAtlasRect( 0.0f, 0.0f, 0.0f, 0.0f ), mAttemptAtlasing( false ), - mLoading( false ) + mLoading( false ), + mOrientationCorrection( true ) { } @@ -289,13 +300,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 ), + mAtlasRect( 0.0f, 0.0f, 0.0f, 0.0f ), mAttemptAtlasing( false ), - mLoading( false ) + mLoading( false ), + mOrientationCorrection( true ) { } @@ -383,12 +398,27 @@ void ImageVisual::DoSetProperties( const Property::Map& propertyMap ) { DoSetProperty( Toolkit::ImageVisual::Property::CROP_TO_MASK, keyValue.second ); } + else if ( keyValue.first == LOAD_POLICY_NAME ) + { + DoSetProperty( Toolkit::DevelImageVisual::Property::LOAD_POLICY, keyValue.second ); + } else if( keyValue.first == RELEASE_POLICY_NAME ) { DoSetProperty( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, keyValue.second ); } + else if( keyValue.first == ORIENTATION_CORRECTION_NAME ) + { + DoSetProperty( Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION, keyValue.second ); + } } } + // Load image immediately if LOAD_POLICY requires it + if ( mLoadPolicy == DevelImageVisual::LoadPolicy::IMMEDIATE ) + { + auto attemptAtlasing = AttemptAtlasing(); + LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection, + TextureManager::ReloadPolicy::CACHED ); + } } void ImageVisual::DoSetProperty( Property::Index index, const Property::Value& value ) @@ -484,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; } @@ -532,6 +561,23 @@ void ImageVisual::DoSetProperty( Property::Index index, const Property::Value& v mReleasePolicy = DevelImageVisual::ReleasePolicy::Type( releasePolicy ); break; } + + case Toolkit::DevelImageVisual::Property::LOAD_POLICY: + { + int loadPolicy; + Scripting::GetEnumerationProperty( value, LOAD_POLICY_TABLE, LOAD_POLICY_TABLE_COUNT, loadPolicy ); + mLoadPolicy = DevelImageVisual::LoadPolicy::Type( loadPolicy ); + break; + } + case Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION: + { + bool orientationCorrection( mOrientationCorrection ); + if( value.Get( orientationCorrection ) ) + { + mOrientationCorrection = orientationCorrection; + } + break; + } } } @@ -714,61 +760,70 @@ bool ImageVisual::IsSynchronousResourceLoading() const return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING; } -/* -( VisualUrl& url, Dali::ImageDimensions desiredSize, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode, - ImageVisual::MaskingData* maskInfo, bool synchronousLoading, - TextureManager::TextureId textureId, Vector4& textureRect, bool& atlasingStatus, bool& loadingStatus - */ -void ImageVisual::InitializeRenderer() +void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures, bool orientationCorrection, + TextureManager::ReloadPolicy forceReload ) { - mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED; - TextureManager& textureManager = mFactoryCache.GetTextureManager(); - if( ! mImpl->mCustomShader && mImageUrl.GetProtocolType() == VisualUrl::LOCAL ) + ImageAtlasManagerPtr atlasManager = nullptr; + AtlasUploadObserver* atlasUploadObserver = nullptr; + auto textureObserver = this; + + if( atlasing ) { - bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE; + atlasManager = mFactoryCache.GetAtlasManager(); + atlasUploadObserver = this; + } - Vector4 atlasRect; + textures = textureManager.LoadTexture( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, + mMaskingData, IsSynchronousResourceLoading(), mTextureId, + atlasRect, atlasing, mLoading, mWrapModeU, + mWrapModeV, textureObserver, atlasUploadObserver, atlasManager, + mOrientationCorrection, + forceReload ); - auto attemptAtlasing = mAttemptAtlasing; + if( atlasing ) // Flag needs to be set before creating renderer + { + mImpl->mFlags |= Impl::IS_ATLASING_APPLIED; + } + else + { + mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED; + } +} - // texture set has to be created first as we need to know if atlasing succeeded or not - // when selecting the shader - TextureSet textures = - textureManager.LoadTexture(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, - mMaskingData, IsSynchronousResourceLoading(), mTextureId, - atlasRect, attemptAtlasing, mLoading, mWrapModeU, - mWrapModeV, this, this, mFactoryCache.GetAtlasManager()); - if(attemptAtlasing) - { - mImpl->mFlags |= Impl::IS_ATLASING_APPLIED; - } - CreateRenderer( textures ); +bool ImageVisual::AttemptAtlasing() +{ + return ( ! mImpl->mCustomShader && mImageUrl.GetProtocolType() == VisualUrl::LOCAL && mAttemptAtlasing ); +} - if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED ) // the texture is packed inside atlas - { - mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect ); - if( !defaultWrapMode ) // custom wrap mode - { - Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE); - wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) ); - mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode ); - } - } +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 ); } - else + + CreateRenderer( mTextures ); + mTextures.Reset(); // Visual should not keep a handle to the texture after this point. + + if( attemptAtlasing ) // the texture is packed inside atlas { - auto attemptAtlasing = false; - // for custom shader or remote image, atlas is not applied - Vector4 atlasRect; // ignored in this case - TextureSet textures = - textureManager.LoadTexture(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, - mMaskingData, IsSynchronousResourceLoading(), mTextureId, - atlasRect, attemptAtlasing, mLoading, mWrapModeU, mWrapModeV, this, - nullptr, nullptr); // no atlasing - DALI_ASSERT_DEBUG(attemptAtlasing == false); - CreateRenderer( textures ); + mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect ); + + bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE; + + if( !defaultWrapMode ) // custom wrap mode + { + Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE); + wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) ); + mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode ); + } } } @@ -786,7 +841,7 @@ void ImageVisual::InitializeRenderer( const Image& image ) else { // reuse existing code for regular images - CreateRenderer( textures ); + CreateRenderer( textures ); // Textures will be retreived from Image } ApplyImageToSampler( image ); } @@ -827,7 +882,7 @@ void ImageVisual::DoSetOnStage( Actor& actor ) mPlacementActor.Reset(); // Image loaded and ready to display - ResourceReady(); + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); } } @@ -885,6 +940,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() ); @@ -892,8 +948,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 ); } void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const @@ -912,6 +969,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 ) @@ -920,6 +993,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; @@ -977,30 +1056,39 @@ 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 ) { + mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect ); actor.AddRenderer( mImpl->mRenderer ); - // 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 ) { + Toolkit::Visual::ResourceStatus resourceStatus; Actor actor = mPlacementActor.GetHandle(); if( actor ) { if( mImpl->mRenderer ) { + if( usingAtlas ) + { + mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect ); + } + actor.AddRenderer( mImpl->mRenderer ); // reset the weak handle so that the renderer only get added to actor once mPlacementActor.Reset(); - if( loadingSuccess ) { Sampler sampler = Sampler::New(); @@ -1017,10 +1105,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; }