// EXTERNAL HEADERS
#include <cstring> // for strlen()
#include <dali/public-api/actors/layer.h>
-#include <dali/public-api/common/stage.h>
-#include <dali/public-api/images/resource-image.h>
-#include <dali/public-api/images/native-image.h>
-#include <dali/devel-api/images/texture-set-image.h>
+#include <dali/devel-api/common/stage.h>
#include <dali/devel-api/adaptor-framework/image-loading.h>
+#include <dali/devel-api/rendering/renderer-devel.h>
+#include <dali/devel-api/rendering/texture-devel.h>
#include <dali/devel-api/scripting/enum-helper.h>
#include <dali/devel-api/scripting/scripting.h>
#include <dali/integration-api/debug.h>
namespace
{
-// property names
-const char * const IMAGE_FITTING_MODE( "fittingMode" );
-const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
-const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
-const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
-const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
-const char * const IMAGE_ATLASING("atlasing");
-const char * const ALPHA_MASK_URL("alphaMaskUrl");
-
// fitting modes
DALI_ENUM_TO_STRING_TABLE_BEGIN( FITTING_MODE )
DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SHRINK_TO_FIT )
const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
-const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
-
const float PIXEL_ALIGN_ON = 1.0f;
const float PIXEL_ALIGN_OFF = 0.0f;
} // unnamed namespace
+
ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache,
ImageVisualShaderFactory& shaderFactory,
const VisualUrl& imageUrl,
return new ImageVisual( factoryCache, shaderFactory, imageUrl, size, fittingMode, samplingMode );
}
-ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const Image& image )
-{
- return new ImageVisual( factoryCache, shaderFactory, image );
-}
-
ImageVisual::ImageVisual( VisualFactoryCache& factoryCache,
ImageVisualShaderFactory& shaderFactory,
const VisualUrl& imageUrl,
ImageDimensions size,
FittingMode::Type fittingMode,
Dali::SamplingMode::Type samplingMode )
-: Visual::Base( factoryCache, Visual::FittingMode::FILL ),
- mImage(),
+: Visual::Base( factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::IMAGE ),
mPixelArea( FULL_TEXTURE_RECT ),
mPlacementActor(),
mImageUrl( imageUrl ),
EnablePreMultipliedAlpha( mFactoryCache.GetPreMultiplyOnLoad() );
}
-ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const Image& image )
-: Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO ),
- mImage( image ),
- mPixelArea( FULL_TEXTURE_RECT ),
- mPlacementActor(),
- mImageUrl(),
- mMaskingData( ),
- mDesiredSize(),
- mTextureId( TextureManager::INVALID_TEXTURE_ID ),
- mTextures(),
- mImageVisualShaderFactory( shaderFactory ),
- mFittingMode( FittingMode::DEFAULT ),
- mSamplingMode( SamplingMode::DEFAULT ),
- mWrapModeU( WrapMode::DEFAULT ),
- mWrapModeV( WrapMode::DEFAULT ),
- 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 )
-{
- EnablePreMultipliedAlpha( mFactoryCache.GetPreMultiplyOnLoad() );
-}
-
ImageVisual::~ImageVisual()
{
if( Stage::IsInstalled() )
void ImageVisual::GetNaturalSize( Vector2& naturalSize )
{
- if(mImage)
- {
- naturalSize.x = mImage.GetWidth();
- naturalSize.y = mImage.GetHeight();
- return;
- }
- else if( mDesiredSize.GetWidth()>0 && mDesiredSize.GetHeight()>0)
+ if( mDesiredSize.GetWidth()>0 && mDesiredSize.GetHeight()>0)
{
naturalSize.x = mDesiredSize.GetWidth();
naturalSize.y = mDesiredSize.GetHeight();
if( textureSet )
{
auto texture = textureSet.GetTexture(0);
- naturalSize.x = texture.GetWidth();
- naturalSize.y = texture.GetHeight();
- return;
+ if( texture )
+ {
+ naturalSize.x = texture.GetWidth();
+ naturalSize.y = texture.GetHeight();
+ return;
+ }
}
}
}
else
{
- Image brokenImage = mFactoryCache.GetBrokenVisualImage();
+ Texture brokenImage = mFactoryCache.GetBrokenVisualImage();
naturalSize.x = brokenImage.GetWidth();
naturalSize.y = brokenImage.GetWidth();
return;
}
}
-
naturalSize = Vector2::ZERO;
}
void ImageVisual::CreateRenderer( TextureSet& textureSet )
{
Geometry geometry;
- Shader shader;
- if( !mImpl->mCustomShader )
+ // Get the geometry
+ if( mImpl->mCustomShader )
{
- geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
-
- shader = mImageVisualShaderFactory.GetShader( mFactoryCache,
- mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
- mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE );
+ geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
}
- else
+ else // Get any geometry associated with the texture
{
- geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
- if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
- {
- // Use custom hints
- shader = Shader::New( mImageVisualShaderFactory.GetVertexShaderSource(), mImageVisualShaderFactory.GetFragmentShaderSource(), mImpl->mCustomShader->mHints );
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
- }
- else
+ TextureManager& textureManager = mFactoryCache.GetTextureManager();
+
+ uint32_t firstElementCount {0u};
+ uint32_t secondElementCount {0u};
+ geometry = textureManager.GetRenderGeometry(mTextureId, firstElementCount, secondElementCount);
+
+ if(!firstElementCount && !secondElementCount) // Otherwise use quad
{
- shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader,
- mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader,
- mImpl->mCustomShader->mHints );
- if( mImpl->mCustomShader->mVertexShader.empty() )
- {
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
- }
+ geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
}
}
- // 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 shader = GetShader();
+ // Create the renderer
mImpl->mRenderer = Renderer::New( geometry, shader );
+
if( textureSet )
{
mImpl->mRenderer.SetTextures( textureSet );
EnablePreMultipliedAlpha( IsPreMultipliedAlphaEnabled() );
}
-void ImageVisual::CreateNativeImageRenderer( NativeImage& nativeImage )
-{
- Geometry geometry;
- Shader shader;
-
- std::string fragmentShader;
- const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
- const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
-
- if( fragmentPreFix )
- {
- fragmentShader = fragmentPreFix;
- fragmentShader += "\n";
- }
-
- if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
- {
- fragmentShader += mImpl->mCustomShader->mFragmentShader;
- }
- else
- {
- fragmentShader += mImageVisualShaderFactory.GetFragmentShaderSource();
- }
-
- if( customSamplerTypename )
- {
- fragmentShader.replace( fragmentShader.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
- }
-
- if( !mImpl->mCustomShader )
- {
- geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
-
- shader = Shader::New( mImageVisualShaderFactory.GetVertexShaderSource(), fragmentShader );
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
- }
- else
- {
- geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
- shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader,
- fragmentShader,
- mImpl->mCustomShader->mHints );
- if( mImpl->mCustomShader->mVertexShader.empty() )
- {
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
- }
- }
-
- mImpl->mRenderer = Renderer::New( geometry, shader );
-
- //Register transform properties
- 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,
TextureManager::ReloadPolicy forceReload )
: TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
textures = textureManager.LoadTexture( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode,
- mMaskingData, IsSynchronousResourceLoading(), mTextureId,
+ mMaskingData, IsSynchronousLoadingRequired(), mTextureId,
atlasRect, mAtlasRectSize, atlasing, mLoading, mWrapModeU,
mWrapModeV, textureObserver, atlasUploadObserver, atlasManager,
mOrientationCorrection, forceReload, preMultiplyOnLoad);
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
+ // Load Texture if mTextures is empty.
+ // mTextures is already set, the mTexture can be used to create Renderer.
+ // There are two cases mTextures is empty.
+ // 1. mTextureId == TextureManager::INVALID_TEXTURE_ID
+ // - Visual is on stage with LoadPolicy::ATTACHED
+ // 2. mTextureId != TextureManager::INVALID_TEXTURE_ID
+ // - If ReleasePolicy is DESTROYED, InitializeRenderer called every on stage called.
+ // - Then every resources those contained in Visual are Reset but mTextureId is remained when the Off stage time,
+ // - So, mTextures needed to be get from texture manager to created resources like mImpl->mRenderer.
+ if( ! mTextures )
{
- LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection,
- TextureManager::ReloadPolicy::CACHED );
+ if( mTextureId == TextureManager::INVALID_TEXTURE_ID )
+ {
+ LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection,
+ TextureManager::ReloadPolicy::CACHED );
+ }
+ else
+ {
+ mTextures = mFactoryCache.GetTextureManager().GetTextureSet( mTextureId );
+ }
}
CreateRenderer( mTextures );
}
}
-void ImageVisual::InitializeRenderer( const Image& image )
-{
- TextureSet textures = TextureSet::New();
-
- NativeImage nativeImage = NativeImage::DownCast( image );
- if( nativeImage )
- {
- CreateNativeImageRenderer( nativeImage );
- DALI_ASSERT_DEBUG( textures );
- mImpl->mRenderer.SetTextures( textures );
- }
- else
- {
- // reuse existing code for regular images
- CreateRenderer( textures ); // Textures will be retreived from Image
- }
- ApplyImageToSampler( image );
-}
-
-void ImageVisual::DoSetOnStage( Actor& actor )
+void ImageVisual::DoSetOnScene( Actor& actor )
{
if( mImageUrl.IsValid() )
{
InitializeRenderer();
}
- else if( mImage )
- {
- InitializeRenderer( mImage );
- }
if( !mImpl->mRenderer )
{
mPlacementActor = actor;
// Search the Actor tree to find if Layer UI behaviour set.
Layer layer = actor.GetLayer();
- if( layer && layer.GetBehavior() == Layer::LAYER_3D )
+ if( layer && layer.GetProperty<Layer::Behavior>( Layer::Property::BEHAVIOR ) == Layer::LAYER_3D )
{
// Layer 3D set, do not align pixels
mImpl->mRenderer.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );
}
}
-void ImageVisual::DoSetOffStage( Actor& actor )
+void ImageVisual::DoSetOffScene( Actor& actor )
{
- // Visual::Base::SetOffStage only calls DoSetOffStage if mRenderer exists (is on onstage)
+ // Visual::Base::SetOffScene only calls DoSetOffScene if mRenderer exists (is on onstage)
// Image release is dependent on the ReleasePolicy, renderer is destroyed.
actor.RemoveRenderer( mImpl->mRenderer);
mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING;
}
- if( mImageUrl.IsValid() )
- {
- // Legacy support for deprecated Dali::Image
- mImage.Reset();
- }
mLoading = false;
mImpl->mRenderer.Reset();
mPlacementActor.Reset();
map.Clear();
map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
- bool sync = IsSynchronousResourceLoading();
+ bool sync = IsSynchronousLoadingRequired();
map.Insert( SYNCHRONOUS_LOADING, sync );
if( mImageUrl.IsValid() )
{
map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
}
- else if( mImage )
- {
- map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
- map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
-
- ResourceImage resourceImage = ResourceImage::DownCast(mImage);
- if( resourceImage )
- {
- map.Insert( Toolkit::ImageVisual::Property::URL, resourceImage.GetUrl() );
- }
- }
map.Insert( Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode );
map.Insert( Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode );
map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
}
- else if( mImage )
- {
- map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
- map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
- }
}
void ImageVisual::OnDoAction( const Dali::Property::Index actionName, const Dali::Property::Value& attributes )
mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED );
}
-void ImageVisual::ApplyImageToSampler( const Image& image )
+void ImageVisual::UpdateShader()
{
- if( image )
+ if(mImpl->mRenderer)
{
- TextureSet textureSet = mImpl->mRenderer.GetTextures();
- DALI_ASSERT_DEBUG( textureSet ); // texture set should always exist by this time
-
- TextureSetImage( textureSet, 0u, image );
- Sampler sampler = Sampler::New();
- sampler.SetWrapMode( mWrapModeU, mWrapModeV );
- textureSet.SetSampler( 0u, sampler );
+ Shader shader = GetShader();
+ mImpl->mRenderer.SetShader(shader);
}
}
mPlacementActor.Reset();
}
- if( loadingSuccess )
+ if( !loadingSuccess )
{
- Sampler sampler = Sampler::New();
- sampler.SetWrapMode( mWrapModeU, mWrapModeV );
- textureSet.SetSampler( 0u, sampler );
- mImpl->mRenderer.SetTextures(textureSet);
- }
- else
- {
- Image brokenImage = mFactoryCache.GetBrokenVisualImage();
+ Texture brokenImage = mFactoryCache.GetBrokenVisualImage();
textureSet = TextureSet::New();
+ textureSet.SetTexture(0u, brokenImage);
mImpl->mRenderer.SetTextures( textureSet );
-
- ApplyImageToSampler( brokenImage );
}
+
+ Sampler sampler = Sampler::New();
+ sampler.SetWrapMode( mWrapModeU, mWrapModeV );
+ textureSet.SetSampler( 0u, sampler );
+ mImpl->mRenderer.SetTextures(textureSet);
+
}
// Storing TextureSet needed when renderer staged.
{
resourceStatus = Toolkit::Visual::ResourceStatus::FAILED;
}
+
+ // use geometry if needed
+ if( loadingSuccess )
+ {
+ uint32_t firstElementCount{0u};
+ uint32_t secondElementCount{0u};
+ auto geometry = mFactoryCache.GetTextureManager().GetRenderGeometry(mTextureId, firstElementCount, secondElementCount);
+ if (mImpl->mRenderer && geometry)
+ {
+ mImpl->mRenderer.SetGeometry(geometry);
+ Dali::DevelRenderer::DrawCommand drawCommand{};
+ drawCommand.drawType = DevelRenderer::DrawType::INDEXED;
+
+ if (firstElementCount)
+ {
+ drawCommand.firstIndex = 0;
+ drawCommand.elementCount = firstElementCount;
+ drawCommand.queue = DevelRenderer::RENDER_QUEUE_OPAQUE;
+ DevelRenderer::AddDrawCommand(mImpl->mRenderer, drawCommand);
+ }
+
+ if (secondElementCount)
+ {
+ drawCommand.firstIndex = firstElementCount;
+ drawCommand.elementCount = secondElementCount;
+ drawCommand.queue = DevelRenderer::RENDER_QUEUE_TRANSPARENT;
+ DevelRenderer::AddDrawCommand(mImpl->mRenderer, drawCommand);
+ }
+ }
+ }
+
// Signal to observers ( control ) that resources are ready. Must be all resources.
ResourceReady( resourceStatus );
mLoading = false;
}
}
+Shader ImageVisual::GetShader()
+{
+ Shader shader;
+
+ std::string_view vertexShaderView;
+ bool usesWholeTexture = true;
+ if(mImpl->mCustomShader && !mImpl->mCustomShader->mVertexShader.empty())
+ {
+ vertexShaderView = mImpl->mCustomShader->mVertexShader;
+ usesWholeTexture = false; // Impossible to tell.
+ }
+ else
+ {
+ vertexShaderView = mImageVisualShaderFactory.GetVertexShaderSource();
+ }
+
+ std::string_view fragmentShaderView;
+ if(mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty())
+ {
+ fragmentShaderView = mImpl->mCustomShader->mFragmentShader;
+ }
+ else
+ {
+ 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);
+ fragmentShaderString = std::string(fragmentShaderView);
+ modifiedFragmentShader = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragmentShaderString);
+ fragmentShaderView = fragmentShaderString;
+ }
+
+ const bool useStandardShader = !mImpl->mCustomShader && !modifiedFragmentShader;
+ if(useStandardShader)
+ {
+ // Create and cache the standard shader
+ shader = mImageVisualShaderFactory.GetShader(
+ mFactoryCache,
+ mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
+ mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE,
+ IsRoundedCornerRequired() );
+ }
+ else if(mImpl->mCustomShader)
+ {
+ shader = Shader::New(vertexShaderView, fragmentShaderView, mImpl->mCustomShader->mHints);
+ }
+ else
+ {
+ shader = Shader::New(vertexShaderView, fragmentShaderView);
+ }
+
+ if(usesWholeTexture)
+ {
+ 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 );
+
+ return shader;
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff