/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
{
ImageVisualPtr imageVisualPtr( new ImageVisual( factoryCache, shaderFactory, imageUrl, size, fittingMode, samplingMode ) );
imageVisualPtr->SetProperties( properties );
+ imageVisualPtr->Initialize();
return imageVisualPtr;
}
FittingMode::Type fittingMode,
Dali::SamplingMode::Type samplingMode )
{
- return new ImageVisual( factoryCache, shaderFactory, imageUrl, size, fittingMode, samplingMode );
+ ImageVisualPtr imageVisualPtr(new ImageVisual(factoryCache, shaderFactory, imageUrl, size, fittingMode, samplingMode));
+ imageVisualPtr->Initialize();
+ return imageVisualPtr;
}
-ImageVisual::ImageVisual( VisualFactoryCache& factoryCache,
- ImageVisualShaderFactory& shaderFactory,
- const VisualUrl& imageUrl,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- Dali::SamplingMode::Type samplingMode )
-: Visual::Base( factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::IMAGE ),
- mPixelArea( FULL_TEXTURE_RECT ),
+ImageVisual::ImageVisual(VisualFactoryCache& factoryCache,
+ ImageVisualShaderFactory& shaderFactory,
+ const VisualUrl& imageUrl,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ Dali::SamplingMode::Type samplingMode)
+: Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::IMAGE),
+ mPixelArea(FULL_TEXTURE_RECT),
mPlacementActor(),
- mImageUrl( imageUrl ),
- mMaskingData( ),
- mDesiredSize( size ),
- mTextureId( TextureManager::INVALID_TEXTURE_ID ),
+ mImageUrl(imageUrl),
+ mMaskingData(),
+ mDesiredSize(size),
+ mTextureId(TextureManager::INVALID_TEXTURE_ID),
mTextures(),
- mImageVisualShaderFactory( shaderFactory ),
- mFittingMode( fittingMode ),
- mSamplingMode( samplingMode ),
- mWrapModeU( WrapMode::DEFAULT ),
- mWrapModeV( WrapMode::DEFAULT ),
- mLoadPolicy( Toolkit::ImageVisual::LoadPolicy::ATTACHED ),
- mReleasePolicy( Toolkit::ImageVisual::ReleasePolicy::DETACHED ),
- mAtlasRect( 0.0f, 0.0f, 0.0f, 0.0f ),
- mAtlasRectSize( 0, 0 ),
- mAttemptAtlasing( false ),
- mLoading( false ),
- mOrientationCorrection( true )
+ mImageVisualShaderFactory(shaderFactory),
+ mFittingMode(fittingMode),
+ mSamplingMode(samplingMode),
+ mWrapModeU(WrapMode::DEFAULT),
+ mWrapModeV(WrapMode::DEFAULT),
+ mLoadPolicy(Toolkit::ImageVisual::LoadPolicy::ATTACHED),
+ mReleasePolicy(Toolkit::ImageVisual::ReleasePolicy::DETACHED),
+ mAtlasRect(0.0f, 0.0f, 0.0f, 0.0f),
+ mAtlasRectSize(0, 0),
+ mLoadState(TextureManager::LoadState::NOT_STARTED),
+ mAttemptAtlasing(false),
+ mOrientationCorrection(true)
{
EnablePreMultipliedAlpha( mFactoryCache.GetPreMultiplyOnLoad() );
}
naturalSize = Vector2::ZERO;
}
-void ImageVisual::CreateRenderer( TextureSet& textureSet )
+void ImageVisual::OnInitialize()
{
Geometry geometry;
// Create the renderer
mImpl->mRenderer = Renderer::New( geometry, shader );
- if( textureSet )
- {
- mImpl->mRenderer.SetTextures( textureSet );
- }
- // else still waiting for texture load to finish.
-
//Register transform properties
mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
EnablePreMultipliedAlpha( IsPreMultipliedAlphaEnabled() );
}
-
void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures, bool orientationCorrection,
TextureManager::ReloadPolicy forceReload )
{
? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD
: TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
- textures = textureManager.LoadTexture( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode,
- mMaskingData, IsSynchronousLoadingRequired(), mTextureId,
- atlasRect, mAtlasRectSize, atlasing, mLoading, mWrapModeU,
- mWrapModeV, textureObserver, atlasUploadObserver, atlasManager,
- mOrientationCorrection, forceReload, preMultiplyOnLoad);
+ bool synchronousLoading = IsSynchronousLoadingRequired();
+ bool loadingStatus;
+
+ textures = textureManager.LoadTexture(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, mMaskingData, synchronousLoading, mTextureId, atlasRect, mAtlasRectSize, atlasing, loadingStatus, mWrapModeU, mWrapModeV, textureObserver, atlasUploadObserver, atlasManager, mOrientationCorrection, forceReload, preMultiplyOnLoad);
if( textures )
{
+ if(loadingStatus)
+ {
+ mLoadState = TextureManager::LoadState::LOADING;
+ }
+ else
+ {
+ mLoadState = TextureManager::LoadState::LOAD_FINISHED;
+ }
+
EnablePreMultipliedAlpha( preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD );
}
+ else if(synchronousLoading)
+ {
+ // Synchronous loading is failed
+ mLoadState = TextureManager::LoadState::LOAD_FAILED;
+ }
if( atlasing ) // Flag needs to be set before creating renderer
{
}
}
- CreateRenderer( mTextures );
- mTextures.Reset(); // Visual should not keep a handle to the texture after this point.
+ if(mTextures)
+ {
+ mImpl->mRenderer.SetTextures(mTextures);
+ mTextures.Reset(); // Visual should not keep a handle to the texture after this point.
+ }
if( attemptAtlasing ) // the texture is packed inside atlas
{
mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
}
- if( mLoading == false )
+ if(mLoadState == TextureManager::LoadState::LOAD_FINISHED)
{
actor.AddRenderer( mImpl->mRenderer );
mPlacementActor.Reset();
// Image loaded and ready to display
ResourceReady( Toolkit::Visual::ResourceStatus::READY );
}
+ else if(mLoadState == TextureManager::LoadState::LOAD_FAILED)
+ {
+ Texture brokenImage = mFactoryCache.GetBrokenVisualImage();
+
+ mTextures = TextureSet::New();
+ mTextures.SetTexture(0u, brokenImage);
+ mImpl->mRenderer.SetTextures(mTextures);
+
+ actor.AddRenderer(mImpl->mRenderer);
+ mPlacementActor.Reset();
+
+ ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
+ }
}
void ImageVisual::DoSetOffScene( Actor& actor )
{
// Visual::Base::SetOffScene only calls DoSetOffScene if mRenderer exists (is on onstage)
- // Image release is dependent on the ReleasePolicy, renderer is destroyed.
+ // Image release is dependent on the ReleasePolicy, renderer is removed.
actor.RemoveRenderer( mImpl->mRenderer);
if( mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED )
{
RemoveTexture(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas
mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING;
+
+ TextureSet textureSet = TextureSet::New();
+ mImpl->mRenderer.SetTextures(textureSet);
+
+ mLoadState = TextureManager::LoadState::NOT_STARTED;
}
- mLoading = false;
- mImpl->mRenderer.Reset();
mPlacementActor.Reset();
}
// 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;
+ mLoadState = TextureManager::LoadState::LOAD_FINISHED;
}
// From Texture Manager
if( loadingSuccess )
{
resourceStatus = Toolkit::Visual::ResourceStatus::READY;
+ mLoadState = TextureManager::LoadState::LOAD_FINISHED;
}
else
{
resourceStatus = Toolkit::Visual::ResourceStatus::FAILED;
+ mLoadState = TextureManager::LoadState::LOAD_FAILED;
}
// use geometry if needed
// Signal to observers ( control ) that resources are ready. Must be all resources.
ResourceReady( resourceStatus );
- mLoading = false;
}
void ImageVisual::RemoveTexture()
}
TextureSet textureSet = mImpl->mRenderer.GetTextures();
- mImpl->mRenderer.Reset();
if( index != Property::INVALID_INDEX )
{
{
Shader shader;
- std::string vertexShader;
- bool usesWholeTexture = true;
+ std::string_view vertexShaderView;
+ bool usesWholeTexture = true;
if(mImpl->mCustomShader && !mImpl->mCustomShader->mVertexShader.empty())
{
- vertexShader = mImpl->mCustomShader->mVertexShader;
+ vertexShaderView = mImpl->mCustomShader->mVertexShader;
usesWholeTexture = false; // Impossible to tell.
}
else
{
- vertexShader = mImageVisualShaderFactory.GetVertexShaderSource().data();
+ vertexShaderView = mImageVisualShaderFactory.GetVertexShaderSource();
}
- std::string fragmentShader;
+ std::string_view fragmentShaderView;
if(mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty())
{
- fragmentShader = mImpl->mCustomShader->mFragmentShader;
+ fragmentShaderView = mImpl->mCustomShader->mFragmentShader;
}
else
{
- fragmentShader = mImageVisualShaderFactory.GetFragmentShaderSource().data();
+ fragmentShaderView = mImageVisualShaderFactory.GetFragmentShaderSource();
}
// If the texture is native, we may need to change prefix and sampler in
// the fragment shader
bool modifiedFragmentShader = false;
+ std::string fragmentShaderString;
if(mTextures && DevelTexture::IsNative(mTextures.GetTexture(0)))
{
- Texture nativeTexture = mTextures.GetTexture(0);
- modifiedFragmentShader = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragmentShader);
+ Texture nativeTexture = mTextures.GetTexture(0);
+ fragmentShaderString = std::string(fragmentShaderView);
+ modifiedFragmentShader = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragmentShaderString);
+ fragmentShaderView = fragmentShaderString;
}
const bool useStandardShader = !mImpl->mCustomShader && !modifiedFragmentShader;
mFactoryCache,
mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE,
- IsRoundedCornerRequired());
+ IsRoundedCornerRequired() );
}
else if(mImpl->mCustomShader)
{
- shader = Shader::New(vertexShader, fragmentShader, mImpl->mCustomShader->mHints);
+ shader = Shader::New(vertexShaderView, fragmentShaderView, mImpl->mCustomShader->mHints);
}
else
{
- shader = Shader::New(vertexShader, fragmentShader);
+ shader = Shader::New(vertexShaderView, fragmentShaderView);
}
if(usesWholeTexture)
{
- shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
}
// Set pixel align off as default.
// ToDo: Pixel align causes issues such as rattling image animation.
// We should trun it off until issues are resolved
- shader.RegisterProperty(PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF);
+ shader.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );
return shader;
}
projects / platform / core / uifw / dali-toolkit.git / blobdiff