X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Frenderers%2Fimage%2Fimage-renderer.cpp;h=7862d5326809420c683e4ddb66c12dff2ce1b684;hb=d43575da616e1370372b1331f47dce36dc4ac145;hp=477096035d44ab9976ba7d661e2280fd3db11f64;hpb=4c1f4bfb9eb5b956b64a6c9bf077217fc0ca9234;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp index 4770960..7862d53 100644 --- a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp +++ b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp @@ -19,6 +19,7 @@ #include "image-renderer.h" // EXTERNAL HEADER +#include // for strncasecmp #include #include @@ -27,6 +28,7 @@ #include #include #include +#include namespace Dali { @@ -39,39 +41,51 @@ namespace Internal namespace { -const char * const RENDERER_TYPE("renderer-type"); -const char * const RENDERER_TYPE_VALUE("image-renderer"); +const char HTTP_URL[] = "http://"; +const char HTTPS_URL[] = "https://"; + +const char * const RENDERER_TYPE("rendererType"); +const char * const RENDERER_TYPE_VALUE("imageRenderer"); // property names -const char * const IMAGE_URL_NAME( "image-url" ); -const char * const IMAGE_FITTING_MODE( "image-fitting-mode" ); -const char * const IMAGE_SAMPLING_MODE( "image-sampling-mode" ); -const char * const IMAGE_DESIRED_WIDTH( "image-desired-width" ); -const char * const IMAGE_DESIRED_HEIGHT( "image-desired-height" ); +const char * const IMAGE_URL_NAME( "imageUrl" ); +const char * const IMAGE_FITTING_MODE( "imageFittingMode" ); +const char * const IMAGE_SAMPLING_MODE( "imageSamplingMode" ); +const char * const IMAGE_DESIRED_WIDTH( "imageDesiredWidth" ); +const char * const IMAGE_DESIRED_HEIGHT( "imageDesiredHeight" ); // fitting modes -const char * const SHRINK_TO_FIT("shrink-to-fit"); -const char * const SCALE_TO_FILL("scale-to-fill"); -const char * const FIT_WIDTH("fit-width"); -const char * const FIT_HEIGHT("fit-height"); +const char * const SHRINK_TO_FIT("shrinkToFit"); +const char * const SCALE_TO_FILL("scaleToFill"); +const char * const FIT_WIDTH("fitWidth"); +const char * const FIT_HEIGHT("fitHeight"); const char * const DEFAULT("default"); // sampling modes const char * const BOX("box"); const char * const NEAREST("nearest"); const char * const LINEAR("linear"); -const char * const BOX_THEN_NEAREST("box-then-nearest"); -const char * const BOX_THEN_LINEAR("box-then-linear"); -const char * const NO_FILTER("no-filter"); -const char * const DONT_CARE("dont-care"); +const char * const BOX_THEN_NEAREST("boxThenNearest"); +const char * const BOX_THEN_LINEAR("boxThenLinear"); +const char * const NO_FILTER("noFilter"); +const char * const DONT_CARE("dontCare"); + +const std::string TEXTURE_UNIFORM_NAME = "sTexture"; +const std::string ATLAS_RECT_UNIFORM_NAME = "uAtlasRect"; +const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea"; + +// Set this uniform to 1.0 for conventional alpha blending; if pre-multiplied alpha blending, set this uniform to 0.0 +const std::string ALPHA_BLENDING_UNIFORM_NAME = "uAlphaBlending"; -std::string TEXTURE_UNIFORM_NAME = "sTexture"; +const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); 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 @@ -79,7 +93,7 @@ const char* VERTEX_SHADER = DALI_COMPOSE_SHADER( 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 ); @@ -88,24 +102,14 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER( varying mediump vec2 vTexCoord;\n uniform sampler2D sTexture;\n uniform lowp vec4 uColor;\n + uniform lowp float uAlphaBlending; // Set to 1.0 for conventional alpha blending; if pre-multiplied alpha blending, set to 0.0 \n void main()\n {\n - gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n + gl_FragColor = texture2D( sTexture, vTexCoord ) * vec4( uColor.rgb*max( uAlphaBlending, uColor.a ), uColor.a );\n }\n ); -void AddQuadIndices( Vector< unsigned int >& indices, unsigned int rowIdx, unsigned int nextRowIdx ) -{ - indices.PushBack( rowIdx ); - indices.PushBack( nextRowIdx + 1 ); - indices.PushBack( rowIdx + 1 ); - - indices.PushBack( rowIdx ); - indices.PushBack( nextRowIdx ); - indices.PushBack( nextRowIdx + 1 ); -} - Geometry GenerateGeometry( const Vector< Vector2 >& vertices, const Vector< unsigned int >& indices ) { Property::Map vertexFormat; @@ -128,6 +132,7 @@ Geometry GenerateGeometry( const Vector< Vector2 >& vertices, const Vector< unsi Geometry geometry = Geometry::New(); geometry.AddVertexBuffer( vertexPropertyBuffer ); geometry.SetIndexBuffer( indexPropertyBuffer ); + geometry.SetGeometryType( Geometry::TRIANGLE_STRIP ); return geometry; } @@ -164,15 +169,27 @@ Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gri // Create indices Vector< unsigned int > indices; - indices.Reserve( gridWidth * gridHeight * 6 ); + indices.Reserve( (gridWidth+2)*gridHeight*2 - 2); - unsigned int rowIdx = 0; - unsigned int nextRowIdx = gridWidth + 1; - for( int y = 0; y < gridHeight; ++y, ++nextRowIdx, ++rowIdx ) + for( unsigned int row = 0u; row < gridHeight; ++row ) { - for( int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx ) + unsigned int rowStartIndex = row*(gridWidth+1u); + unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u; + + if( row != 0u ) // degenerate index on non-first row { - AddQuadIndices( indices, rowIdx, nextRowIdx ); + 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 ); } } @@ -184,11 +201,13 @@ Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gri } //unnamed namespace -ImageRenderer::ImageRenderer() -: ControlRenderer(), +ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache, ImageAtlasManager& atlasManager ) +: ControlRenderer( factoryCache ), + mAtlasManager( atlasManager ), mDesiredSize(), mFittingMode( FittingMode::DEFAULT ), - mSamplingMode( SamplingMode::DEFAULT ) + mSamplingMode( SamplingMode::DEFAULT ), + mIsAlphaPreMultiplied( false ) { } @@ -196,9 +215,9 @@ ImageRenderer::~ImageRenderer() { } -void ImageRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap ) +void ImageRenderer::DoInitialize( Actor& actor, const Property::Map& propertyMap ) { - Initialize(factoryCache); + std::string oldImageUrl = mImageUrl; Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME ); if( imageURLValue ) @@ -303,6 +322,25 @@ void ImageRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Prop mDesiredSize = ImageDimensions( desiredWidth, desiredHeight ); } + + // remove old renderer if exit + if( mImpl->mRenderer ) + { + if( actor ) //remove old renderer from actor + { + actor.RemoveRenderer( mImpl->mRenderer ); + } + if( !oldImageUrl.empty() ) //clean old renderer from cache + { + CleanCache( oldImageUrl ); + } + } + + // if actor is on stage, create new renderer and apply to actor + if( actor && actor.OnStage() ) + { + SetOnStage( actor ); + } } void ImageRenderer::SetSize( const Vector2& size ) @@ -344,14 +382,118 @@ void ImageRenderer::SetOffset( const Vector2& offset ) { } +Renderer ImageRenderer::CreateRenderer() const +{ + Geometry geometry; + Shader shader; + + if( !mImpl->mCustomShader ) + { + geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) ); + shader = GetImageShader(mFactoryCache); + } + else + { + geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize ); + if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() ) + { + 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.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT ); + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + shader.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 1.f ); + } + } + } + + Material material = Material::New( shader ); + return Renderer::New( geometry, material ); +} + +void ImageRenderer::InitializeRenderer( const std::string& imageUrl ) +{ + if( imageUrl.empty() ) + { + return; + } + + mImageUrl = imageUrl; + mImpl->mRenderer.Reset(); + + 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 ) + { + Vector4 atlasRect; + Material material = mAtlasManager.Add(atlasRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + if( material ) + { + Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) ); + mImpl->mRenderer = Renderer::New( geometry, material ); + mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect ); + } + else // big image, atlasing is not applied + { + mImpl->mRenderer = CreateRenderer(); + + ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded ); + Material material = mImpl->mRenderer.GetMaterial(); + material.AddTexture( image, TEXTURE_UNIFORM_NAME ); + } + + 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 resourceImage = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded ); + ApplyImageToSampler( resourceImage ); + } +} + +void ImageRenderer::InitializeRenderer( const Image& image ) +{ + mImpl->mFlags &= ~Impl::IS_FROM_CACHE; + + mImpl->mRenderer = CreateRenderer(); + + if( image ) + { + ApplyImageToSampler( image ); + } +} + + void ImageRenderer::DoSetOnStage( Actor& actor ) { - if( !mImageUrl.empty() && !mImage ) + if( !mImageUrl.empty() ) + { + InitializeRenderer( mImageUrl ); + } + else { - mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + InitializeRenderer( mImage ); } - ApplyImageToSampler(); + EnablePreMultipliedAlpha( mIsAlphaPreMultiplied ); } void ImageRenderer::DoSetOffStage( Actor& actor ) @@ -359,8 +501,16 @@ void ImageRenderer::DoSetOffStage( Actor& actor ) //If we own the image then make sure we release it when we go off stage if( !mImageUrl.empty() ) { + actor.RemoveRenderer( mImpl->mRenderer ); + CleanCache(mImageUrl); + mImage.Reset(); } + else + { + actor.RemoveRenderer( mImpl->mRenderer ); + mImpl->mRenderer.Reset(); + } } void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const @@ -459,121 +609,181 @@ void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const } } -void ImageRenderer::Initialize( RendererFactoryCache& factoryCache ) +Shader ImageRenderer::GetImageShader( RendererFactoryCache& factoryCache ) { - if( !mImpl->mCustomShader ) + Shader shader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER ); + if( !shader ) { - mImpl->mGeometry = CreateGeometry( factoryCache, ImageDimensions( 1, 1 ) ); - - mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER ); - - if( !mImpl->mShader ) - { - mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); - factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader ); - } + 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 ); + shader.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 1.f ); } - else + return shader; +} + +void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode ) +{ + if( mImageUrl != imageUrl ) { - mImpl->mGeometry = CreateGeometry( factoryCache, mImpl->mCustomShader->mGridSize ); + std::string oldImageUrl = mImageUrl; + mImageUrl = imageUrl; + mDesiredSize = size; + mFittingMode = fittingMode; + mSamplingMode = samplingMode; + mImage.Reset(); - if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() ) + if( mImpl->mRenderer ) { - mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER ); + if( GetIsFromCache() ) // if renderer is from cache, remove the old one + { + //remove old renderer + if( actor ) + { + actor.RemoveRenderer( mImpl->mRenderer ); + } + + //clean the cache + if( !oldImageUrl.empty() ) + { + CleanCache(oldImageUrl); + } - if( !mImpl->mShader ) + if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor + { + SetOnStage(actor); + } + } + else // if renderer is not from cache, reuse the same renderer and only change the texture { - mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); - factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader ); + ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded ); + ApplyImageToSampler( image ); } } - else - { - mImpl->mShader = 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->mRenderer ) +void ImageRenderer::SetImage( Actor& actor, const Image& image ) +{ + if( mImage != image ) { - mImpl->mRenderer.SetGeometry( mImpl->mGeometry ); - Material material = mImpl->mRenderer.GetMaterial(); - if( material ) + mImage = image; + + if( mImpl->mRenderer ) { - material.SetShader( mImpl->mShader ); + if( GetIsFromCache() ) // if renderer is from cache, remove the old one + { + //remove old renderer + if( actor ) + { + actor.RemoveRenderer( mImpl->mRenderer ); + } + + //clean the cache + if( !mImageUrl.empty() ) + { + CleanCache(mImageUrl); + } + mImageUrl.clear(); + + if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor + { + SetOnStage(actor); + } + } + else // if renderer is not from cache, reuse the same renderer and only change the texture + { + ApplyImageToSampler( image ); + } } - } -} -void ImageRenderer::SetImage( const std::string& imageUrl ) -{ - SetImage( imageUrl, 0, 0, Dali::FittingMode::DEFAULT, Dali::SamplingMode::DEFAULT ); + mImageUrl.clear(); + mDesiredSize = ImageDimensions(); + mFittingMode = FittingMode::DEFAULT; + mSamplingMode = SamplingMode::DEFAULT; + } } -void ImageRenderer::SetImage( const std::string& imageUrl, int desiredWidth, int desiredHeight, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode ) +void ImageRenderer::EnablePreMultipliedAlpha( bool preMultipled ) { - if( mImageUrl != imageUrl ) + mIsAlphaPreMultiplied = preMultipled; + if( mImpl->mRenderer ) { - mImageUrl = imageUrl; - mDesiredSize = ImageDimensions( desiredWidth, desiredHeight ); - mFittingMode = fittingMode; - mSamplingMode = samplingMode; + Material material = mImpl->mRenderer.GetMaterial(); - if( !mImageUrl.empty() && mImpl->mIsOnStage ) + if( preMultipled ) { - mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode ); - ApplyImageToSampler(); + material.SetBlendFunc( BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA, + BlendingFactor::ONE, BlendingFactor::ONE ); + if( !mImpl->mCustomShader || mImpl->mCustomShader->mVertexShader.empty()) + { + material.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 0.f ); + } } else { - mImage.Reset(); + // using default blend func + material.SetBlendFunc( BlendingFactor::SRC_ALPHA, BlendingFactor::ONE_MINUS_SRC_ALPHA, + BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA ); + + Property::Index index = material.GetPropertyIndex( ALPHA_BLENDING_UNIFORM_NAME ); + if( index != Property::INVALID_INDEX ) // only set value when the property already exist on the Material + { + material.SetProperty( index, 1.f ); + } } } } -void ImageRenderer::SetImage( Image image ) +void ImageRenderer::ApplyImageToSampler( const Image& image ) { - if( mImage != image ) + if( image ) { - mImageUrl.clear(); - mDesiredSize = ImageDimensions(); - mFittingMode = FittingMode::DEFAULT; - mSamplingMode = SamplingMode::DEFAULT; - mImage = image; - - if( mImage && mImpl->mIsOnStage ) + Material material = mImpl->mRenderer.GetMaterial(); + if( material ) { - ApplyImageToSampler(); + int index = material.GetTextureIndex( TEXTURE_UNIFORM_NAME ); + if( index != -1 ) + { + material.SetTextureImage( index, image ); + return; + } + + material.AddTexture( image, TEXTURE_UNIFORM_NAME ); } } } -Image ImageRenderer::GetImage() const +void ImageRenderer::OnImageLoaded( ResourceImage image ) { - return mImage; + if( image.GetLoadingState() == Dali::ResourceLoadingFailed ) + { + Image brokenImage = RendererFactory::GetBrokenRendererImage(); + if( mImpl->mRenderer ) + { + ApplyImageToSampler( brokenImage ); + } + } } -void ImageRenderer::ApplyImageToSampler() +void ImageRenderer::CleanCache(const std::string& url) { - if( mImage ) + Material material = mImpl->mRenderer.GetMaterial(); + + 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 ) { - Material material = mImpl->mRenderer.GetMaterial(); - if( material ) - { - for( std::size_t i = 0; i < material.GetNumberOfSamplers(); ++i ) - { - Sampler sampler = material.GetSamplerAt( i ); - if( sampler.GetUniformName() == TEXTURE_UNIFORM_NAME ) - { - sampler.SetImage( mImage ); - return; - } - } + Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index ); + atlasRectValue.Get( atlasRect ); + } - Sampler sampler = Sampler::New( mImage, TEXTURE_UNIFORM_NAME ); - material.AddSampler( sampler ); - } + mImpl->mRenderer.Reset(); + if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX ) + { + mAtlasManager.Remove( material, atlasRect ); } }