#include "image-renderer.h"
// EXTERNAL HEADER
+#include <cstring> // for strncasecmp
#include <dali/public-api/images/resource-image.h>
+#include <dali/public-api/images/native-image.h>
#include <dali/integration-api/debug.h>
// INTERNAL HEADER
#include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
#include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
#include <dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h>
+#include <dali-toolkit/internal/controls/renderers/image-atlas-manager.h>
namespace Dali
{
namespace
{
+const char HTTP_URL[] = "http://";
+const char HTTPS_URL[] = "https://";
+
const char * const RENDERER_TYPE("rendererType");
-const char * const RENDERER_TYPE_VALUE("imageRenderer");
+const char * const RENDERER_TYPE_VALUE("image");
// property names
const char * const IMAGE_URL_NAME( "imageUrl" );
const char * const NO_FILTER("noFilter");
const char * const DONT_CARE("dontCare");
-std::string TEXTURE_UNIFORM_NAME = "sTexture";
+const std::string ATLAS_RECT_UNIFORM_NAME = "uAtlasRect";
+const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
+
+const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
+
+const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
attribute mediump vec2 aPosition;\n
- varying mediump vec2 vTexCoord;\n
uniform mediump mat4 uMvpMatrix;\n
uniform mediump vec3 uSize;\n
+ uniform mediump vec4 uAtlasRect;\n
+ uniform mediump vec4 pixelArea;
+ varying mediump vec2 vTexCoord;\n
\n
void main()\n
{\n
vertexPosition.xyz *= uSize;\n
vertexPosition = uMvpMatrix * vertexPosition;\n
\n
- vTexCoord = aPosition + vec2(0.5);\n
+ vTexCoord = mix( uAtlasRect.xy, uAtlasRect.zw, pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) ) );\n
gl_Position = vertexPosition;\n
}\n
);
}\n
);
-Geometry GenerateGeometry( const Vector< Vector2 >& vertices, const Vector< unsigned int >& indices )
-{
- Property::Map vertexFormat;
- vertexFormat[ "aPosition" ] = Property::VECTOR2;
- PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat, vertices.Size() );
- if( vertices.Size() > 0 )
- {
- vertexPropertyBuffer.SetData( &vertices[ 0 ] );
- }
-
- Property::Map indexFormat;
- indexFormat[ "indices" ] = Property::INTEGER;
- PropertyBuffer indexPropertyBuffer = PropertyBuffer::New( indexFormat, indices.Size() );
- if( indices.Size() > 0 )
- {
- indexPropertyBuffer.SetData( &indices[ 0 ] );
- }
-
- // Create the geometry object
- Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexPropertyBuffer );
- geometry.SetIndexBuffer( indexPropertyBuffer );
- geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
-
- return geometry;
-}
-
Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gridSize )
{
Geometry geometry;
geometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
if( !geometry )
{
- geometry = factoryCache.CreateQuadGeometry();
+ geometry = RendererFactoryCache::CreateQuadGeometry();
factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );
}
}
else
{
- uint16_t gridWidth = gridSize.GetWidth();
- uint16_t gridHeight = gridSize.GetHeight();
-
- // Create vertices
- Vector< Vector2 > vertices;
- vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
-
- for( int y = 0; y < gridHeight + 1; ++y )
- {
- for( int x = 0; x < gridWidth + 1; ++x )
- {
- vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight - 0.5f) );
- }
- }
-
- // Create indices
- Vector< unsigned int > indices;
- indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
-
- for( unsigned int row = 0u; row < gridHeight; ++row )
- {
- unsigned int rowStartIndex = row*(gridWidth+1u);
- unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
-
- if( row != 0u ) // degenerate index on non-first row
- {
- indices.PushBack( rowStartIndex );
- }
-
- for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
- {
- indices.PushBack( rowStartIndex + column);
- indices.PushBack( nextRowStartIndex + column);
- }
-
- if( row != gridHeight-1u ) // degenerate index on non-last row
- {
- indices.PushBack( nextRowStartIndex + gridWidth );
- }
- }
-
- return GenerateGeometry( vertices, indices );
+ geometry = RendererFactoryCache::CreateGridGeometry( gridSize );
}
return geometry;
} //unnamed namespace
-ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache )
+ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
: ControlRenderer( factoryCache ),
+ mAtlasManager( atlasManager ),
mDesiredSize(),
mFittingMode( FittingMode::DEFAULT ),
- mSamplingMode( SamplingMode::DEFAULT )
+ mSamplingMode( SamplingMode::DEFAULT ),
+ mNativeFragmentShaderCode( ),
+ mNativeImageFlag( false )
{
}
mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
}
+ // remove old renderer if exit
if( mImpl->mRenderer )
{
- //remove old renderer
- if( actor )
+ if( actor ) //remove old renderer from actor
{
actor.RemoveRenderer( mImpl->mRenderer );
}
-
- //clean the cache
- if( !oldImageUrl.empty() )
+ if( !oldImageUrl.empty() ) //clean old renderer from cache
{
- mFactoryCache.CleanRendererCache( oldImageUrl );
+ CleanCache( oldImageUrl );
}
+ }
- //Initialize the renderer
- if( !mImageUrl.empty() )
- {
- InitializeRenderer( mImageUrl );
- }
- else if( mImage )
- {
- InitializeRenderer( mImage );
- }
+ NativeImage nativeImage = NativeImage::DownCast( mImage );
- //add the new renderer to the actor
- if( actor && mImpl->mRenderer )
- {
- actor.AddRenderer( mImpl->mRenderer );
- }
+ if( nativeImage )
+ {
+ SetNativeFragmentShaderCode( nativeImage );
+ }
+
+ // if actor is on stage, create new renderer and apply to actor
+ if( actor && actor.OnStage() )
+ {
+ SetOnStage( actor );
}
}
Geometry geometry;
Shader shader;
+ // If mImage is nativeImage with custom sampler or prefix, mNativeFragmentShaderCode will be applied.
+ // Renderer can't be shared between NativeImage and other image types.
+ if( !mNativeFragmentShaderCode.empty() )
+ {
+ return CreateNativeImageRenderer();
+ }
+
if( !mImpl->mCustomShader )
{
geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
- shader = mFactoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
- if( !shader )
- {
- shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
- mFactoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
- }
+
+ shader = GetImageShader(mFactoryCache);
}
else
{
geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
{
- shader = mFactoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
- if( !shader )
+ shader = GetImageShader(mFactoryCache);
+ }
+ else
+ {
+ shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
+ mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
+ mImpl->mCustomShader->mHints );
+ if( mImpl->mCustomShader->mVertexShader.empty() )
{
- shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
- mFactoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
+ shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
}
}
+ }
+
+ TextureSet textureSet = TextureSet::New();
+
+ Renderer renderer = Renderer::New( geometry, shader );
+ renderer.SetTextures( textureSet );
+
+ return renderer;
+}
+
+Renderer ImageRenderer::CreateNativeImageRenderer() const
+{
+ Geometry geometry;
+ Shader shader;
+
+ if( !mImpl->mCustomShader )
+ {
+ geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+
+ shader = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
+ shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ }
+ else
+ {
+ geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
+ if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
+ {
+ shader = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
+ }
else
{
shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
- mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
+ mNativeFragmentShaderCode,
mImpl->mCustomShader->mHints );
+ if( mImpl->mCustomShader->mVertexShader.empty() )
+ {
+ shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ }
}
}
- Material material = Material::New( shader );
- return Renderer::New( geometry, material );
+ TextureSet textureSet = TextureSet::New();
+ Renderer renderer = Renderer::New( geometry, shader );
+ renderer.SetTextures( textureSet );
+
+ return renderer;
}
void ImageRenderer::InitializeRenderer( const std::string& imageUrl )
{
- if( mImageUrl.empty() )
+ if( imageUrl.empty() )
{
- mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
return;
}
+ mImageUrl = imageUrl;
mImpl->mRenderer.Reset();
- if( !mImpl->mCustomShader )
+
+ if( !mImpl->mCustomShader &&
+ ( strncasecmp( imageUrl.c_str(), HTTP_URL, sizeof(HTTP_URL) -1 ) != 0 ) && // ignore remote images
+ ( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof(HTTPS_URL) -1 ) != 0 ) )
{
mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
if( !mImpl->mRenderer )
{
- mImpl->mRenderer = CreateRenderer();
+ Vector4 atlasRect;
+ TextureSet textureSet = mAtlasManager.Add(atlasRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+ if( textureSet )
+ {
+ Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+ Shader shader( GetImageShader(mFactoryCache) );
+ mImpl->mRenderer = Renderer::New( geometry, shader );
+ mImpl->mRenderer.SetTextures( textureSet );
+ mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
+ }
+ else // big image, atlasing is not applied
+ {
+ mImpl->mRenderer = CreateRenderer();
- ResourceImage image = Dali::ResourceImage::New( imageUrl );
- image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- Material material = mImpl->mRenderer.GetMaterial();
- material.AddTexture( image, TEXTURE_UNIFORM_NAME );
+ ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+ image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+ TextureSet textureSet = mImpl->mRenderer.GetTextures();
+ textureSet.SetImage( 0u, image );
+ }
mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
}
+
mImpl->mFlags |= Impl::IS_FROM_CACHE;
}
else
{
+ // for custom shader or remote image, renderer is not cached and atlas is not applied
+
mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
mImpl->mRenderer = CreateRenderer();
- ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- ApplyImageToSampler( image );
+ ResourceImage resourceImage = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+ resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+ ApplyImageToSampler( resourceImage );
}
}
{
mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
- if( !image )
+ mImpl->mRenderer = CreateRenderer();
+
+ if( image )
{
- return;
+ ApplyImageToSampler( image );
}
-
- mImpl->mRenderer = CreateRenderer();
- ApplyImageToSampler( image );
}
{
InitializeRenderer( mImageUrl );
}
- else if( mImage )
+ else
{
InitializeRenderer( mImage );
}
- if( !GetIsFromCache() )
- {
- Image image = mImage;
- if( !mImageUrl.empty() )
- {
- ResourceImage resourceImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- image = resourceImage;
- }
-
- ApplyImageToSampler( image );
- }
}
void ImageRenderer::DoSetOffStage( Actor& actor )
//If we own the image then make sure we release it when we go off stage
if( !mImageUrl.empty() )
{
- //clean the renderer from the cache since it may no longer be in use
- mFactoryCache.CleanRendererCache( mImageUrl );
-
+ actor.RemoveRenderer( mImpl->mRenderer );
+ CleanCache(mImageUrl);
mImage.Reset();
}
+ else
+ {
+ actor.RemoveRenderer( mImpl->mRenderer );
+ mImpl->mRenderer.Reset();
+ }
}
void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const
}
}
-void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl )
+Shader ImageRenderer::GetImageShader( RendererFactoryCache& factoryCache )
{
- SetImage( actor, imageUrl, 0, 0, Dali::FittingMode::DEFAULT, Dali::SamplingMode::DEFAULT );
+ Shader shader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
+ if( !shader )
+ {
+ shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+ factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
+ shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ }
+ return shader;
}
-void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, int desiredWidth, int desiredHeight, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
+void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
{
if( mImageUrl != imageUrl )
{
+ std::string oldImageUrl = mImageUrl;
+ mImageUrl = imageUrl;
+ mDesiredSize = size;
+ mFittingMode = fittingMode;
+ mSamplingMode = samplingMode;
+ mImage.Reset();
+
if( mImpl->mRenderer )
{
- if( GetIsFromCache() )
+ if( GetIsFromCache() ) // if renderer is from cache, remove the old one
{
//remove old renderer
if( actor )
}
//clean the cache
- if( !mImageUrl.empty() )
+ if( !oldImageUrl.empty() )
{
- mFactoryCache.CleanRendererCache( mImageUrl );
+ CleanCache(oldImageUrl);
}
- //Initialize the renderer
- InitializeRenderer( imageUrl );
-
- //add the new renderer to the actor
- if( actor && mImpl->mRenderer )
+ if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
{
- actor.AddRenderer( mImpl->mRenderer );
+ SetOnStage(actor);
}
}
- else
+ else // if renderer is not from cache, reuse the same renderer and only change the texture
{
ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
ApplyImageToSampler( image );
}
}
-
- mImageUrl = imageUrl;
- mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
- mFittingMode = fittingMode;
- mSamplingMode = samplingMode;
- mImage.Reset();
}
}
{
if( mImage != image )
{
+ NativeImage newNativeImage = NativeImage::DownCast( image );
+ bool newRendererFlag = true;
+
+ if( newNativeImage && !mNativeImageFlag )
+ {
+ SetNativeFragmentShaderCode( newNativeImage );
+ }
+
+ if( ( newNativeImage && mNativeImageFlag ) || ( !newNativeImage && !mNativeImageFlag ) )
+ {
+ newRendererFlag = false;
+ }
+
+ if( newNativeImage )
+ {
+ mNativeImageFlag = true;
+ }
+ else
+ {
+ mNativeFragmentShaderCode.clear();
+ mNativeImageFlag = false;
+ }
+
+ mImage = image;
+
if( mImpl->mRenderer )
{
+ // if renderer is from cache, remove the old one, and create new renderer
if( GetIsFromCache() )
{
//remove old renderer
//clean the cache
if( !mImageUrl.empty() )
{
- mFactoryCache.CleanRendererCache( mImageUrl );
+ CleanCache(mImageUrl);
}
+ mImageUrl.clear();
- //Initialize the renderer
- InitializeRenderer( image );
+ if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
+ {
+ SetOnStage(actor);
+ }
+ }
+ // if input image is nativeImage and mImage is regular image or the reverse, remove the old one, and create new renderer
+ else if( newRendererFlag )
+ {
+ //remove old renderer
+ if( actor )
+ {
+ actor.RemoveRenderer( mImpl->mRenderer );
+ }
- //add the new renderer to the actor
- if( actor && mImpl->mRenderer )
+ if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
{
- actor.AddRenderer( mImpl->mRenderer );
+ SetOnStage(actor);
}
}
- else
+ else // if renderer is not from cache, reuse the same renderer and only change the texture
{
ApplyImageToSampler( image );
}
}
- mImage = image;
mImageUrl.clear();
mDesiredSize = ImageDimensions();
mFittingMode = FittingMode::DEFAULT;
{
if( image )
{
- Material material = mImpl->mRenderer.GetMaterial();
- if( material )
+ TextureSet textureSet = mImpl->mRenderer.GetTextures();
+ if( textureSet )
{
- int index = material.GetTextureIndex( TEXTURE_UNIFORM_NAME );
- if( index != -1 )
- {
- material.SetTextureImage( index, image );
- return;
- }
-
- material.AddTexture( image, TEXTURE_UNIFORM_NAME );
+ textureSet.SetImage( 0u, image );
}
}
}
{
if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
{
- Image image = RendererFactory::GetBrokenRendererImage();
+ Image brokenImage = RendererFactory::GetBrokenRendererImage();
if( mImpl->mRenderer )
{
- ApplyImageToSampler( image );
+ ApplyImageToSampler( brokenImage );
}
}
}
+void ImageRenderer::CleanCache(const std::string& url)
+{
+ TextureSet textureSet = mImpl->mRenderer.GetTextures();
+
+ Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
+ Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
+ if( index != Property::INVALID_INDEX )
+ {
+ Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
+ atlasRectValue.Get( atlasRect );
+ }
+
+ mImpl->mRenderer.Reset();
+ if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
+ {
+ mAtlasManager.Remove( textureSet, atlasRect );
+ }
+}
+
+void ImageRenderer::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
+{
+ const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
+ const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
+
+ if( fragmentPreFix )
+ {
+ mNativeFragmentShaderCode = fragmentPreFix;
+ mNativeFragmentShaderCode += "\n";
+ }
+
+ if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
+ {
+ mNativeFragmentShaderCode += mImpl->mCustomShader->mFragmentShader;
+ }
+ else
+ {
+ mNativeFragmentShaderCode += FRAGMENT_SHADER;
+ }
+
+ if( customSamplerTypename )
+ {
+ mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
+ }
+
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff