X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Frenderers%2Fimage%2Fimage-renderer.cpp;h=27c6af5c908b277934668ce4a8002f436f5d6b45;hp=0fad54314888167adac0d49ff7e5ad7d46ea848b;hb=af4073fd7a4f946e26110ecd608ef8e748c078aa;hpb=18c250b7c2de9dba09bff61a6425c67f490e5d41 diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp index 0fad543..27c6af5 100644 --- a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp +++ b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp @@ -27,6 +27,7 @@ #include #include #include +#include namespace Dali { @@ -39,39 +40,42 @@ namespace Internal namespace { -const char * const RENDERER_TYPE("renderer-type"); -const char * const RENDERER_TYPE_VALUE("image-renderer"); +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"); -std::string TEXTURE_UNIFORM_NAME = "sTexture"; +const std::string TEXTURE_UNIFORM_NAME = "sTexture"; +const std::string TEXTURE_RECT_UNIFORM_NAME = "uTextureRect"; +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 uTextureRect;\n \n void main()\n {\n @@ -79,7 +83,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( uTextureRect.xy, uTextureRect.zw, aPosition + vec2(0.5));\n gl_Position = vertexPosition;\n }\n ); @@ -186,8 +190,10 @@ Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gri } //unnamed namespace -ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache ) +ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache, ImageAtlasManager& atlasManager ) : ControlRenderer( factoryCache ), + mAtlasManager( atlasManager ), + mTextureRect( FULL_TEXTURE_RECT ), mDesiredSize(), mFittingMode( FittingMode::DEFAULT ), mSamplingMode( SamplingMode::DEFAULT ) @@ -198,15 +204,16 @@ ImageRenderer::~ImageRenderer() { } -void ImageRenderer::DoInitialize( const Property::Map& propertyMap ) +void ImageRenderer::DoInitialize( Actor& actor, const Property::Map& propertyMap ) { + std::string oldImageUrl = mImageUrl; + Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME ); if( imageURLValue ) { imageURLValue->Get( mImageUrl ); if( !mImageUrl.empty() ) { - SetCachedRendererKey( mImageUrl ); mImage.Reset(); } @@ -304,6 +311,37 @@ void ImageRenderer::DoInitialize( const Property::Map& propertyMap ) mDesiredSize = ImageDimensions( desiredWidth, desiredHeight ); } + + if( mImpl->mRenderer ) + { + //remove old renderer + if( actor ) + { + actor.RemoveRenderer( mImpl->mRenderer ); + } + + //clean the cache + if( !oldImageUrl.empty() ) + { + CleanCache( oldImageUrl ); + } + + //Initialize the renderer + if( !mImageUrl.empty() ) + { + InitializeRenderer( mImageUrl ); + } + else if( mImage ) + { + InitializeRenderer( mImage ); + } + + //add the new renderer to the actor + if( actor && mImpl->mRenderer ) + { + actor.AddRenderer( mImpl->mRenderer ); + } + } } void ImageRenderer::SetSize( const Vector2& size ) @@ -345,33 +383,22 @@ void ImageRenderer::SetOffset( const Vector2& offset ) { } -void ImageRenderer::InitializeRenderer( Renderer& renderer ) +Renderer ImageRenderer::CreateRenderer() const { Geometry geometry; Shader shader; + 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 = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); - mFactoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader ); - } + shader = GetImageShader(mFactoryCache); } else { @@ -381,30 +408,102 @@ void ImageRenderer::InitializeRenderer( Renderer& renderer ) } } - if( !renderer ) + Material material = Material::New( shader ); + return Renderer::New( geometry, material ); +} + +void ImageRenderer::InitializeRenderer( const std::string& imageUrl ) +{ + if( mImageUrl.empty() ) { - Material material = Material::New( shader ); - renderer = Renderer::New( geometry, material ); + mImpl->mFlags &= ~Impl::IS_FROM_CACHE; + return; } - else + + mImpl->mRenderer.Reset(); + if( !mImpl->mCustomShader ) { - renderer.SetGeometry( geometry ); - Material material = renderer.GetMaterial(); - if( material ) + mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl ); + if( !mImpl->mRenderer ) + { + Material material = mAtlasManager.Add(mTextureRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + if( material ) + { + Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) ); + mImpl->mRenderer = Renderer::New( geometry, material ); + SetTextureRectUniform(mTextureRect); + } + else // big image, atlasing is not applied + { + mImpl->mRenderer = CreateRenderer(); + SetTextureRectUniform(FULL_TEXTURE_RECT); + + ResourceImage image = Dali::ResourceImage::New( imageUrl ); + image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded ); + Material material = mImpl->mRenderer.GetMaterial(); + material.AddTexture( image, TEXTURE_UNIFORM_NAME ); + } + + mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer ); + } + else { - material.SetShader( shader ); + Property::Value textureRect = mImpl->mRenderer.GetProperty( mImpl->mRenderer.GetPropertyIndex(TEXTURE_RECT_UNIFORM_NAME) ); + textureRect.Get( mTextureRect ); } + mImpl->mFlags |= Impl::IS_FROM_CACHE; + } + else + { + 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 ); + } +} + +void ImageRenderer::InitializeRenderer( const Image& image ) +{ + mImpl->mFlags &= ~Impl::IS_FROM_CACHE; + + if( !image ) + { + return; } + + mImpl->mRenderer = CreateRenderer(); + ApplyImageToSampler( image ); + SetTextureRectUniform( FULL_TEXTURE_RECT ); } + void ImageRenderer::DoSetOnStage( Actor& actor ) { - if( !mImageUrl.empty() && !mImage ) + if( !mImageUrl.empty() ) { - mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + InitializeRenderer( mImageUrl ); + } + else if( mImage ) + { + InitializeRenderer( mImage ); } - ApplyImageToSampler(); + 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; + + // Set value to the uTextureRect uniform + SetTextureRectUniform( FULL_TEXTURE_RECT ); + } + + ApplyImageToSampler( image ); + } } void ImageRenderer::DoSetOffStage( Actor& actor ) @@ -412,8 +511,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 @@ -512,71 +619,162 @@ void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const } } -void ImageRenderer::SetImage( const std::string& imageUrl ) +Shader ImageRenderer::GetImageShader( RendererFactoryCache& factoryCache ) { - SetImage( 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 ); + } + return shader; } -void ImageRenderer::SetImage( 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 ) { + mDesiredSize = size; + mFittingMode = fittingMode; + mSamplingMode = samplingMode; + if( mImageUrl != imageUrl ) { - mImageUrl = imageUrl; - SetCachedRendererKey( mImageUrl ); - mDesiredSize = ImageDimensions( desiredWidth, desiredHeight ); - mFittingMode = fittingMode; - mSamplingMode = samplingMode; - - if( !mImageUrl.empty() && mImpl->mIsOnStage ) - { - mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode ); - ApplyImageToSampler(); - } - else + if( mImpl->mRenderer ) { - mImage.Reset(); + if( GetIsFromCache() ) + { + //remove old renderer + if( actor ) + { + actor.RemoveRenderer( mImpl->mRenderer ); + } + + //clean the cache + if( !mImageUrl.empty() ) + { + CleanCache(mImageUrl); + } + + //Initialize the renderer + InitializeRenderer( imageUrl ); + + //add the new renderer to the actor + if( actor && mImpl->mRenderer ) + { + actor.AddRenderer( mImpl->mRenderer ); + } + } + else + { + ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode ); + image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded ); + ApplyImageToSampler( image ); + } } + + mImageUrl = imageUrl; + + mImage.Reset(); } } -void ImageRenderer::SetImage( Image image ) +void ImageRenderer::SetImage( Actor& actor, const Image& image ) { if( mImage != image ) { + if( mImpl->mRenderer ) + { + if( GetIsFromCache() ) + { + //remove old renderer + if( actor ) + { + actor.RemoveRenderer( mImpl->mRenderer ); + } + + //clean the cache + if( !mImageUrl.empty() ) + { + CleanCache(mImageUrl); + } + + //Initialize the renderer + InitializeRenderer( image ); + + //add the new renderer to the actor + if( actor && mImpl->mRenderer ) + { + actor.AddRenderer( mImpl->mRenderer ); + } + } + else + { + ApplyImageToSampler( image ); + } + } + SetTextureRectUniform( FULL_TEXTURE_RECT ); + + mImage = image; mImageUrl.clear(); mDesiredSize = ImageDimensions(); mFittingMode = FittingMode::DEFAULT; mSamplingMode = SamplingMode::DEFAULT; - mImage = image; - - if( mImage && mImpl->mIsOnStage ) - { - ApplyImageToSampler(); - } } } -Image ImageRenderer::GetImage() const -{ - return mImage; -} - -void ImageRenderer::ApplyImageToSampler() +void ImageRenderer::ApplyImageToSampler( const Image& image ) { - if( mImage ) + if( image ) { Material material = mImpl->mRenderer.GetMaterial(); if( material ) { - int index = material.GetTextureIndex(TEXTURE_UNIFORM_NAME); + int index = material.GetTextureIndex( TEXTURE_UNIFORM_NAME ); if( index != -1 ) { - material.SetTextureImage( index, mImage ); + material.SetTextureImage( index, image ); return; } - material.AddTexture( mImage,TEXTURE_UNIFORM_NAME ); + material.AddTexture( image, TEXTURE_UNIFORM_NAME ); + } + } +} + +void ImageRenderer::OnImageLoaded( ResourceImage image ) +{ + if( image.GetLoadingState() == Dali::ResourceLoadingFailed ) + { + Image brokenImage = RendererFactory::GetBrokenRendererImage(); + if( mImpl->mRenderer ) + { + ApplyImageToSampler( brokenImage ); + } + } +} + +void ImageRenderer::SetTextureRectUniform( const Vector4& textureRect ) +{ + if( mImpl->mRenderer ) + { + Property::Index index = mImpl->mRenderer.GetPropertyIndex( TEXTURE_RECT_UNIFORM_NAME ); + if( index == Property::INVALID_INDEX ) + { + index = mImpl->mRenderer.RegisterProperty( TEXTURE_RECT_UNIFORM_NAME, textureRect ); } + else + { + mImpl->mRenderer.SetProperty( index, textureRect ); + } + } +} + +void ImageRenderer::CleanCache(const std::string& url) +{ + Material material = mImpl->mRenderer.GetMaterial(); + mImpl->mRenderer.Reset(); + if( mFactoryCache.CleanRendererCache( url ) ) + { + mAtlasManager.Remove( material, mTextureRect ); } }