dali-toolkit/internal/controls/renderers/image/image-renderer.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "image-renderer.h"
  20
  21 #include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
  22 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  23 #include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
  24 #include <dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h>
  25 #include <dali/public-api/images/resource-image.h>
  26
  27 namespace Dali
  28 {
  29
  30 namespace Toolkit
  31 {
  32
  33 namespace Internal
  34 {
  35
  36 namespace
  37 {
  38 const char * const RENDERER_TYPE("renderer-type");
  39 const char * const RENDERER_TYPE_VALUE("image-renderer");
  40
  41 // property names
  42 const char * const IMAGE_URL_NAME("image-url");
  43 const char * const IMAGE_FITTING_MODE("image-fitting-mode");
  44 const char * const IMAGE_SAMPLING_MODE("image-sampling-mode");
  45 const char * const IMAGE_DESIRED_WIDTH("image-desired-width");
  46 const char * const IMAGE_DESIRED_HEIGHT("image-desired-height");
  47
  48 // fitting modes
  49 const char * const SHRINK_TO_FIT("shrink-to-fit");
  50 const char * const SCALE_TO_FILL("scale-to-fill");
  51 const char * const FIT_WIDTH("fit-width");
  52 const char * const FIT_HEIGHT("fit-height");
  53 const char * const DEFAULT("default");
  54
  55 // sampling modes
  56 const char * const BOX("box");
  57 const char * const NEAREST("nearest");
  58 const char * const LINEAR("linear");
  59 const char * const BOX_THEN_NEAREST("box-then-nearest");
  60 const char * const BOX_THEN_LINEAR("box-then-linear");
  61 const char * const NO_FILTER("no-filter");
  62 const char * const DONT_CARE("dont-care");
  63
  64 std::string TEXTURE_UNIFORM_NAME = "sTexture";
  65
  66 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  67   attribute mediump vec2 aPosition;\n
  68   varying mediump vec2 vTexCoord;\n
  69   uniform mediump mat4 uMvpMatrix;\n
  70   uniform mediump vec3 uSize;\n
  71   \n
  72   void main()\n
  73   {\n
  74     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
  75     vertexPosition.xyz *= uSize;\n
  76     vertexPosition = uMvpMatrix * vertexPosition;\n
  77     \n
  78     vTexCoord = aPosition + vec2(0.5);\n
  79     gl_Position = vertexPosition;\n
  80   }\n
  81 );
  82
  83 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
  84   varying mediump vec2 vTexCoord;\n
  85   uniform sampler2D sTexture;\n
  86   uniform lowp vec4 uColor;\n
  87   \n
  88   void main()\n
  89   {\n
  90     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
  91   }\n
  92 );
  93
  94 } //unnamed namespace
  95
  96 ImageRenderer::ImageRenderer()
  97 : ControlRenderer(),
  98   mDesiredSize(),
  99   mFittingMode( FittingMode::DEFAULT ),
 100   mSamplingMode( SamplingMode::DEFAULT )
 101 {
 102 }
 103
 104 ImageRenderer::~ImageRenderer()
 105 {
 106 }
 107
 108 void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
 109 {
 110   Initialize(factoryCache);
 111
 112   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
 113   if( imageURLValue )
 114   {
 115     imageURLValue->Get( mImageUrl );
 116
 117     Property::Value* fittingValue = propertyMap.Find( IMAGE_FITTING_MODE );
 118     if( fittingValue )
 119     {
 120       std::string fitting;
 121       fittingValue->Get( fitting );
 122
 123       mFittingMode = FittingMode::DEFAULT;
 124       if( fitting == SHRINK_TO_FIT )
 125       {
 126         mFittingMode = FittingMode::SHRINK_TO_FIT;
 127       }
 128       else if( fitting == SCALE_TO_FILL )
 129       {
 130         mFittingMode = FittingMode::SCALE_TO_FILL;
 131       }
 132       else if( fitting == FIT_WIDTH )
 133       {
 134         mFittingMode = FittingMode::FIT_WIDTH;
 135       }
 136       else if( fitting == FIT_HEIGHT )
 137       {
 138         mFittingMode = FittingMode::FIT_HEIGHT;
 139       }
 140       else if( fitting == DEFAULT )
 141       {
 142         mFittingMode = FittingMode::DEFAULT;
 143       }
 144       else
 145       {
 146         DALI_ASSERT_ALWAYS("Unknown fitting mode");
 147       }
 148     }
 149
 150     Property::Value* samplingValue = propertyMap.Find( IMAGE_SAMPLING_MODE );
 151     if( samplingValue )
 152     {
 153       std::string sampling;
 154       samplingValue->Get( sampling );
 155
 156       mSamplingMode = SamplingMode::DEFAULT;
 157       if( sampling == BOX )
 158       {
 159         mSamplingMode = SamplingMode::BOX;
 160       }
 161       else if( sampling == NEAREST )
 162       {
 163         mSamplingMode = SamplingMode::NEAREST;
 164       }
 165       else if( sampling == LINEAR )
 166       {
 167         mSamplingMode = SamplingMode::LINEAR;
 168       }
 169       else if( sampling == BOX_THEN_NEAREST )
 170       {
 171         mSamplingMode = SamplingMode::BOX_THEN_NEAREST;
 172       }
 173       else if( sampling == BOX_THEN_LINEAR )
 174       {
 175         mSamplingMode = SamplingMode::BOX_THEN_LINEAR;
 176       }
 177       else if( sampling == NO_FILTER )
 178       {
 179         mSamplingMode = SamplingMode::NO_FILTER;
 180       }
 181       else if( sampling == DONT_CARE )
 182       {
 183         mSamplingMode = SamplingMode::DONT_CARE;
 184       }
 185       else if( sampling == DEFAULT )
 186       {
 187         mSamplingMode = SamplingMode::DEFAULT;
 188       }
 189       else
 190       {
 191         DALI_ASSERT_ALWAYS("Unknown sampling mode");
 192       }
 193     }
 194
 195     int desiredWidth = 0;
 196     Property::Value* desiredWidthValue = propertyMap.Find( IMAGE_DESIRED_WIDTH );
 197     if( desiredWidthValue )
 198     {
 199       desiredWidthValue->Get( desiredWidth );
 200     }
 201
 202     int desiredHeight = 0;
 203     Property::Value* desiredHeightValue = propertyMap.Find( IMAGE_DESIRED_HEIGHT );
 204     if( desiredHeightValue )
 205     {
 206       desiredHeightValue->Get( desiredHeight );
 207     }
 208
 209     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
 210   }
 211
 212   mImage.Reset();
 213 }
 214
 215 void ImageRenderer::SetSize( const Vector2& size )
 216 {
 217   ControlRenderer::SetSize( size );
 218   // ToDo: renderer responds to the size change
 219 }
 220
 221 void ImageRenderer::SetClipRect( const Rect<int>& clipRect )
 222 {
 223   ControlRenderer::SetClipRect( clipRect );
 224   //ToDo: renderer responds to the clipRect change
 225 }
 226
 227 void ImageRenderer::SetOffset( const Vector2& offset )
 228 {
 229   //ToDo: renderer applies the offset
 230 }
 231
 232 void ImageRenderer::DoSetOnStage( Actor& actor )
 233 {
 234   if( !mImageUrl.empty() && !mImage )
 235   {
 236     mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
 237   }
 238
 239   ApplyImageToSampler();
 240 }
 241
 242 void ImageRenderer::DoSetOffStage( Actor& actor )
 243 {
 244   //If we own the image then make sure we release it when we go off stage
 245   if( !mImageUrl.empty() )
 246   {
 247     mImage.Reset();
 248   }
 249 }
 250
 251 void ImageRenderer::CreatePropertyMap( Property::Map& map ) const
 252 {
 253   map.Clear();
 254   map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
 255   if( !mImageUrl.empty() )
 256   {
 257     map.Insert( IMAGE_URL_NAME, mImageUrl );
 258     map.Insert( IMAGE_DESIRED_WIDTH, mDesiredSize.GetWidth() );
 259     map.Insert( IMAGE_DESIRED_HEIGHT, mDesiredSize.GetHeight() );
 260   }
 261   else if( mImage )
 262   {
 263     map.Insert( IMAGE_DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
 264     map.Insert( IMAGE_DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
 265
 266     ResourceImage resourceImage = ResourceImage::DownCast(mImage);
 267     if( resourceImage )
 268     {
 269       map.Insert( IMAGE_URL_NAME, resourceImage.GetUrl() );
 270     }
 271   }
 272
 273   switch( mFittingMode )
 274   {
 275     case Dali::FittingMode::FIT_HEIGHT:
 276     {
 277       map.Insert( IMAGE_FITTING_MODE, FIT_HEIGHT );
 278       break;
 279     }
 280     case Dali::FittingMode::FIT_WIDTH:
 281     {
 282       map.Insert( IMAGE_FITTING_MODE, FIT_WIDTH );
 283       break;
 284     }
 285     case Dali::FittingMode::SCALE_TO_FILL:
 286     {
 287       map.Insert( IMAGE_FITTING_MODE, SCALE_TO_FILL );
 288       break;
 289     }
 290     case Dali::FittingMode::SHRINK_TO_FIT:
 291     {
 292       map.Insert( IMAGE_FITTING_MODE, SHRINK_TO_FIT );
 293       break;
 294     }
 295     default:
 296     {
 297       map.Insert( IMAGE_FITTING_MODE, DEFAULT );
 298       break;
 299     }
 300   }
 301
 302   switch( mSamplingMode )
 303   {
 304     case Dali::SamplingMode::BOX:
 305     {
 306       map.Insert( IMAGE_SAMPLING_MODE, BOX );
 307       break;
 308     }
 309     case Dali::SamplingMode::NEAREST:
 310     {
 311       map.Insert( IMAGE_SAMPLING_MODE, NEAREST );
 312       break;
 313     }
 314     case Dali::SamplingMode::LINEAR:
 315     {
 316       map.Insert( IMAGE_SAMPLING_MODE, LINEAR );
 317       break;
 318     }
 319     case Dali::SamplingMode::BOX_THEN_LINEAR:
 320     {
 321       map.Insert( IMAGE_SAMPLING_MODE, BOX_THEN_LINEAR );
 322       break;
 323     }
 324     case Dali::SamplingMode::BOX_THEN_NEAREST:
 325     {
 326       map.Insert( IMAGE_SAMPLING_MODE, BOX_THEN_NEAREST );
 327       break;
 328     }
 329     case Dali::SamplingMode::NO_FILTER:
 330     {
 331       map.Insert( IMAGE_SAMPLING_MODE, NO_FILTER );
 332       break;
 333     }
 334     case Dali::SamplingMode::DONT_CARE:
 335     {
 336       map.Insert( IMAGE_SAMPLING_MODE, DONT_CARE );
 337       break;
 338     }
 339     default:
 340     {
 341       map.Insert( IMAGE_SAMPLING_MODE, DEFAULT );
 342       break;
 343     }
 344   }
 345 }
 346
 347 void ImageRenderer::Initialize( RendererFactoryCache& factoryCache )
 348 {
 349   mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
 350   if( !(mImpl->mGeometry) )
 351   {
 352     mImpl->mGeometry =  factoryCache.CreateQuadGeometry();
 353     factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry );
 354   }
 355
 356   mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
 357   if( !mImpl->mShader )
 358   {
 359     mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
 360     factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader );
 361   }
 362
 363   mDesiredSize = ImageDimensions();
 364   mFittingMode = FittingMode::DEFAULT;
 365   mSamplingMode = SamplingMode::DEFAULT;
 366   mImageUrl.clear();
 367 }
 368
 369 void ImageRenderer::SetImage( const std::string& imageUrl )
 370 {
 371   SetImage( imageUrl, 0, 0, Dali::FittingMode::DEFAULT, Dali::SamplingMode::DEFAULT );
 372 }
 373
 374 void ImageRenderer::SetImage( const std::string& imageUrl, int desiredWidth, int desiredHeight, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
 375 {
 376   if( mImageUrl != imageUrl )
 377   {
 378     mImageUrl = imageUrl;
 379     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
 380     mFittingMode = fittingMode;
 381     mSamplingMode = samplingMode;
 382
 383     if( !mImageUrl.empty() && mImpl->mIsOnStage )
 384     {
 385       mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
 386       ApplyImageToSampler();
 387     }
 388     else
 389     {
 390       mImage.Reset();
 391     }
 392   }
 393 }
 394
 395 void ImageRenderer::SetImage( Image image )
 396 {
 397   if( mImage != image )
 398   {
 399     mImageUrl.clear();
 400     mDesiredSize = ImageDimensions();
 401     mFittingMode = FittingMode::DEFAULT;
 402     mSamplingMode = SamplingMode::DEFAULT;
 403     mImage = image;
 404
 405     if( mImage && mImpl->mIsOnStage )
 406     {
 407       ApplyImageToSampler();
 408     }
 409   }
 410 }
 411
 412 Image ImageRenderer::GetImage() const
 413 {
 414   return mImage;
 415 }
 416
 417 void ImageRenderer::ApplyImageToSampler()
 418 {
 419   if( mImage )
 420   {
 421     Material material = mImpl->mRenderer.GetMaterial();
 422     if( material )
 423     {
 424       for( std::size_t i = 0; i < material.GetNumberOfSamplers(); ++i )
 425       {
 426         Sampler sampler = material.GetSamplerAt( i );
 427         if( sampler.GetUniformName() == TEXTURE_UNIFORM_NAME )
 428         {
 429           sampler.SetImage( mImage );
 430           return;
 431         }
 432       }
 433
 434       Sampler sampler = Sampler::New( mImage, TEXTURE_UNIFORM_NAME );
 435       material.AddSampler( sampler );
 436     }
 437   }
 438 }
 439
 440 } // namespace Internal
 441
 442 } // namespace Toolkit
 443
 444 } // namespace Dali