dali-toolkit/internal/controls/renderers/gradient/gradient-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 "gradient-renderer.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <typeinfo>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/public-api/common/dali-vector.h>
  25 #include <dali/public-api/images/buffer-image.h>
  26 #include <dali/public-api/object/property-array.h>
  27
  28 //INTERNAL INCLUDES
  29 #include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
  30 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  31 #include <dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h>
  32 #include <dali-toolkit/internal/controls/renderers/gradient/linear-gradient.h>
  33 #include <dali-toolkit/internal/controls/renderers/gradient/radial-gradient.h>
  34
  35 namespace Dali
  36 {
  37
  38 namespace Toolkit
  39 {
  40
  41 namespace Internal
  42 {
  43
  44 namespace
  45 {
  46 const char * const RENDERER_TYPE("renderer-type");
  47 const char * const RENDERER_TYPE_VALUE("gradient-renderer");
  48
  49 // properties: linear gradient
  50 const char * const GRADIENT_START_POSITION_NAME("gradient-start-position"); // Property::VECTOR2
  51 const char * const GRADIENT_END_POSITION_NAME("gradient-end-position"); // Property::VECTOR2
  52
  53 // properties: radial gradient
  54 const char * const GRADIENT_CENTER_NAME("gradient-center"); // Property::VECTOR2
  55 const char * const GRADIENT_RADIUS_NAME("gradient-radius"); // Property::FLOAT
  56
  57 // properties: linear&radial gradient
  58 const char * const GRADIENT_STOP_OFFSET_NAME("gradient-stop-offset"); // Property::Array FLOAT
  59 const char * const GRADIENT_STOP_COLOR_NAME("gradient-stop-color"); // Property::Array VECTOR4
  60 const char * const GRADIENT_UNITS_NAME("gradient-units"); // Property::String  "userSpaceOnUse | objectBoundingBox"
  61 const char * const GRADIENT_SPREAD_METHOD_NAME("gradient-spread-method"); // Property::String  "pad | reflect | repeat"
  62
  63 // string values
  64 const char * const UNIT_USER_SPACE("user-space");
  65 const char * const UNIT_BOUNDING_BOX("object-bounding-box");
  66 const char * const SPREAD_PAD("pad");
  67 const char * const SPREAD_REFLECT("reflect");
  68 const char * const SPREAD_REPEAT("repeat");
  69
  70 // uniform names
  71 const char * const UNIFORM_ALIGNMENT_MATRIX_NAME( "uAlignmentMatrix" );
  72 const char * const UNIFORM_TEXTULRE_NAME("sTexture");
  73
  74 RendererFactoryCache::ShaderType GetShaderType( GradientRenderer::Type type, Gradient::GradientUnits units)
  75 {
  76   if( type==GradientRenderer::LINEAR )
  77   {
  78    if( units == Gradient::USER_SPACE_ON_USE )
  79    {
  80      return RendererFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE;
  81    }
  82    return RendererFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX;
  83   }
  84   else if( units == Gradient::USER_SPACE_ON_USE )
  85   {
  86     return RendererFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE;
  87   }
  88
  89   return RendererFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX;
  90 }
  91
  92 const char* VERTEX_SHADER[] =
  93 {
  94 // vertex shader for gradient units as USER_SPACE_ON_USE
  95 DALI_COMPOSE_SHADER(
  96   attribute mediump vec2 aPosition;\n
  97   uniform mediump mat4 uMvpMatrix;\n
  98   uniform mediump vec3 uSize;\n
  99   uniform mediump mat3 uAlignmentMatrix;\n
 100   varying mediump vec2 vTexCoord;\n
 101   \n
 102   void main()\n
 103   {\n
 104     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
 105     vertexPosition.xyz *= uSize;\n
 106     gl_Position = uMvpMatrix * vertexPosition;\n
 107     \n
 108     vTexCoord = (uAlignmentMatrix*vertexPosition.xyw).xy;\n
 109   }\n
 110 ),
 111
 112 // vertex shader for gradient units as OBJECT_BOUNDING_BOX
 113  DALI_COMPOSE_SHADER(
 114   attribute mediump vec2 aPosition;\n
 115   uniform mediump mat4 uMvpMatrix;\n
 116   uniform mediump vec3 uSize;\n
 117   uniform mediump mat3 uAlignmentMatrix;\n
 118   varying mediump vec2 vTexCoord;\n
 119   \n
 120   void main()\n
 121   {\n
 122     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
 123     vTexCoord = (uAlignmentMatrix*vertexPosition.xyw).xy;\n
 124     \n
 125     vertexPosition.xyz *= uSize;\n
 126     gl_Position = uMvpMatrix * vertexPosition;\n
 127   }\n
 128 )
 129 };
 130
 131 const char* FRAGMENT_SHADER[] =
 132 {
 133 // fragment shader for linear gradient
 134 DALI_COMPOSE_SHADER(
 135   uniform sampler2D sTexture;\n // sampler1D?
 136   uniform lowp vec4 uColor;\n
 137   varying mediump vec2 vTexCoord;\n
 138   \n
 139   void main()\n
 140   {\n
 141     gl_FragColor = texture2D( sTexture, vec2( vTexCoord.y, 0.5 ) ) * uColor;\n
 142   }\n
 143 ),
 144
 145 // fragment shader for radial gradient
 146 DALI_COMPOSE_SHADER(
 147   uniform sampler2D sTexture;\n // sampler1D?
 148   uniform lowp vec4 uColor;\n
 149   varying mediump vec2 vTexCoord;\n
 150   \n
 151   void main()\n
 152   {\n
 153     gl_FragColor = texture2D( sTexture, vec2( length(vTexCoord), 0.5 ) ) * uColor;\n
 154   }\n
 155 )
 156 };
 157
 158 Sampler::WrapMode GetWrapMode( Gradient::SpreadMethod spread )
 159 {
 160   switch(spread)
 161   {
 162     case Gradient::REPEAT:
 163     {
 164       return Sampler::REPEAT;
 165     }
 166     case Gradient::REFLECT:
 167     {
 168       return Sampler::MIRRORED_REPEAT;
 169     }
 170     case Gradient::PAD:
 171     default:
 172     {
 173       return Sampler::CLAMP_TO_EDGE;
 174     }
 175   }
 176 }
 177
 178 }
 179
 180
 181 GradientRenderer::GradientRenderer()
 182 :mGradientTransformIndex( Property::INVALID_INDEX )
 183 {
 184 }
 185
 186 GradientRenderer::~GradientRenderer()
 187 {
 188 }
 189
 190 void GradientRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
 191 {
 192   mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
 193   if( !(mImpl->mGeometry) )
 194   {
 195     mImpl->mGeometry =  RendererFactoryCache::CreateQuadGeometry();
 196     factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry );
 197   }
 198
 199   Gradient::GradientUnits gradientUnits = Gradient::OBJECT_BOUNDING_BOX;
 200   Property::Value* unitsValue = propertyMap.Find( GRADIENT_UNITS_NAME );
 201   std::string units;
 202   // The default unit is OBJECT_BOUNDING_BOX.
 203   // Only need to set new units if 'user-space'
 204   if( unitsValue && unitsValue->Get( units ) && units == UNIT_USER_SPACE )
 205   {
 206     gradientUnits = Gradient::USER_SPACE_ON_USE;
 207   }
 208
 209   Type gradientType = LINEAR;
 210   if( propertyMap.Find( GRADIENT_RADIUS_NAME ))
 211   {
 212     gradientType = RADIAL;
 213   }
 214
 215   RendererFactoryCache::ShaderType shaderType = GetShaderType( gradientType, gradientUnits );
 216
 217   mImpl->mShader = factoryCache.GetShader( shaderType );
 218   if( !(mImpl->mShader) )
 219   {
 220     mImpl->mShader = Shader::New( VERTEX_SHADER[gradientUnits], FRAGMENT_SHADER[gradientType] );
 221     factoryCache.SaveShader( shaderType, mImpl->mShader );
 222   }
 223
 224   if( NewGradient(gradientType, propertyMap) )
 225   {
 226     mGradient->SetGradientUnits( gradientUnits );
 227     mGradientTransform = mGradient->GetAlignmentTransform();
 228   }
 229   else
 230   {
 231     DALI_LOG_ERROR( "Fail to provide valid properties to create a GradientRenderer object" );
 232   }
 233 }
 234
 235 void GradientRenderer::SetSize( const Vector2& size )
 236 {
 237   ControlRenderer::SetSize( size );
 238 }
 239
 240 void GradientRenderer::SetClipRect( const Rect<int>& clipRect )
 241 {
 242   ControlRenderer::SetClipRect( clipRect );
 243
 244   //ToDo: renderer responds to the clipRect change
 245 }
 246
 247 void GradientRenderer::SetOffset( const Vector2& offset )
 248 {
 249   //ToDo: renderer applies the offset
 250 }
 251
 252 void GradientRenderer::DoCreatePropertyMap( Property::Map& map ) const
 253 {
 254   map.Clear();
 255   map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
 256
 257   Gradient::GradientUnits units = mGradient->GetGradientUnits();
 258   if( units == Gradient::USER_SPACE_ON_USE )
 259   {
 260     map.Insert( GRADIENT_UNITS_NAME, UNIT_USER_SPACE );
 261   }
 262   else // if( units == Gradient::OBJECT_BOUNDING_BOX )
 263   {
 264     map.Insert( GRADIENT_UNITS_NAME, UNIT_BOUNDING_BOX );
 265   }
 266
 267   Gradient::SpreadMethod spread = mGradient->GetSpreadMethod();
 268   if( spread == Gradient::PAD )
 269   {
 270     map.Insert( GRADIENT_SPREAD_METHOD_NAME, SPREAD_PAD );
 271   }
 272   else if( spread == Gradient::REFLECT )
 273   {
 274     map.Insert( GRADIENT_SPREAD_METHOD_NAME, SPREAD_REFLECT );
 275   }
 276   else // if( units == Gradient::REPEAT )
 277   {
 278     map.Insert( GRADIENT_SPREAD_METHOD_NAME, SPREAD_REPEAT );
 279   }
 280
 281   const Vector<Gradient::GradientStop>& stops( mGradient->GetStops() );
 282   Property::Array offsets;
 283   Property::Array colors;
 284   for( unsigned int i=0; i<stops.Count(); i++ )
 285   {
 286     offsets.PushBack( stops[i].mOffset );
 287     colors.PushBack( stops[i].mStopColor );
 288   }
 289
 290   map.Insert( GRADIENT_STOP_OFFSET_NAME, offsets );
 291   map.Insert( GRADIENT_STOP_COLOR_NAME, colors );
 292
 293   if( &typeid( *mGradient ) == &typeid(LinearGradient) )
 294   {
 295     LinearGradient* gradient = static_cast<LinearGradient*>( mGradient.Get() );
 296     map.Insert( GRADIENT_START_POSITION_NAME, gradient->GetStartPosition() );
 297     map.Insert( GRADIENT_END_POSITION_NAME, gradient->GetEndPosition() );
 298   }
 299   else // if( &typeid( *mGradient ) == &typeid(RadialGradient) )
 300   {
 301     RadialGradient* gradient = static_cast<RadialGradient*>( mGradient.Get() );
 302     map.Insert( GRADIENT_CENTER_NAME, gradient->GetCenter() );
 303     map.Insert( GRADIENT_RADIUS_NAME, gradient->GetRadius() );
 304   }
 305 }
 306
 307 void GradientRenderer::DoSetOnStage( Actor& actor )
 308 {
 309   mGradientTransformIndex = (mImpl->mRenderer).RegisterProperty( UNIFORM_ALIGNMENT_MATRIX_NAME, mGradientTransform );
 310
 311   Dali::BufferImage lookupTexture = mGradient->GenerateLookupTexture();
 312   Sampler sampler = Sampler::New( lookupTexture, UNIFORM_TEXTULRE_NAME );
 313   Sampler::WrapMode wrap = GetWrapMode( mGradient->GetSpreadMethod() );
 314   sampler.SetWrapMode(  wrap, wrap  );
 315
 316   Material material = (mImpl->mRenderer).GetMaterial();
 317   if( material )
 318   {
 319     material.AddSampler( sampler );
 320   }
 321 }
 322
 323 bool GradientRenderer::NewGradient(Type gradientType, const Property::Map& propertyMap)
 324 {
 325   if( gradientType==LINEAR )
 326   {
 327     Property::Value* startPositionValue = propertyMap.Find( GRADIENT_START_POSITION_NAME );
 328     Property::Value* endPositionValue = propertyMap.Find( GRADIENT_END_POSITION_NAME );
 329     Vector2 startPosition;
 330     Vector2 endPosition;
 331
 332     if( startPositionValue && startPositionValue->Get(startPosition)
 333      && endPositionValue && endPositionValue->Get( endPosition ) )
 334     {
 335       mGradient = new LinearGradient( startPosition, endPosition );
 336     }
 337     else
 338     {
 339       return false;
 340     }
 341   }
 342   else // type==RADIAL
 343   {
 344     Property::Value* centerValue = propertyMap.Find( GRADIENT_CENTER_NAME );
 345     Property::Value* radiusValue = propertyMap.Find( GRADIENT_RADIUS_NAME );
 346     Vector2 center;
 347     float radius;
 348     if( centerValue && centerValue->Get(center)
 349         && radiusValue && radiusValue->Get(radius) )
 350     {
 351       mGradient = new RadialGradient( center, radius );
 352     }
 353     else
 354     {
 355       return false;
 356     }
 357   }
 358
 359   unsigned int numValidStop = 0u;
 360   Property::Value* stopOffsetValue = propertyMap.Find( GRADIENT_STOP_OFFSET_NAME );
 361   Property::Value* stopColorValue = propertyMap.Find( GRADIENT_STOP_COLOR_NAME );
 362   if( stopOffsetValue && stopColorValue )
 363   {
 364     Vector<float> offsetArray;
 365     Property::Array* colorArray = stopColorValue->GetArray();
 366     if( colorArray && GetStopOffsets( stopOffsetValue, offsetArray ))
 367     {
 368       unsigned int numStop = offsetArray.Count() < colorArray->Count() ?
 369                              offsetArray.Count() : colorArray->Count();
 370       Vector4 color;
 371       for( unsigned int i=0; i<numStop; i++ )
 372       {
 373         if( (colorArray->GetElementAt(i)).Get(color) )
 374         {
 375           mGradient->AddStop( offsetArray[i], color);
 376           numValidStop++;
 377         }
 378       }
 379     }
 380   }
 381
 382   if( numValidStop < 1u ) // no valid stop
 383   {
 384     return false;
 385   }
 386
 387   Property::Value* spread = propertyMap.Find( GRADIENT_SPREAD_METHOD_NAME );
 388   std::string stringValue ;
 389   // The default spread method is PAD.
 390   // Only need to set new spread if 'reflect' or 'repeat"
 391   if( spread && spread->Get( stringValue ))
 392   {
 393     if( stringValue == SPREAD_REFLECT )
 394     {
 395       mGradient->SetSpreadMethod( Gradient::REFLECT );
 396     }
 397     else if( stringValue == SPREAD_REPEAT )
 398     {
 399       mGradient->SetSpreadMethod( Gradient::REPEAT );
 400     }
 401   }
 402
 403   return true;
 404 }
 405
 406 bool GradientRenderer::GetStopOffsets(const Property::Value* value, Vector<float>& stopOffsets)
 407 {
 408   Vector2 offset2;
 409   if( value->Get( offset2 ) )
 410   {
 411     stopOffsets.PushBack( offset2.x );
 412     stopOffsets.PushBack( offset2.y );
 413     return true;
 414   }
 415
 416   Vector3 offset3;
 417   if( value->Get( offset3 ) )
 418   {
 419     stopOffsets.PushBack( offset3.x );
 420     stopOffsets.PushBack( offset3.y );
 421     stopOffsets.PushBack( offset3.z );
 422     return true;
 423   }
 424
 425   Vector4 offset4;
 426   if( value->Get( offset4 ) )
 427   {
 428     stopOffsets.PushBack( offset4.x );
 429     stopOffsets.PushBack( offset4.y );
 430     stopOffsets.PushBack( offset4.z );
 431     stopOffsets.PushBack( offset4.w );
 432     return true;
 433   }
 434
 435   Property::Array* offsetArray = value->GetArray();
 436   if( offsetArray )
 437   {
 438     unsigned int numStop = offsetArray->Count();
 439     float offset;
 440     for( unsigned int i=0; i<numStop; i++ )
 441     {
 442       if( offsetArray->GetElementAt(i).Get(offset) )
 443       {
 444         stopOffsets.PushBack( offset );
 445       }
 446     }
 447     return true;
 448   }
 449
 450   return false;
 451 }
 452
 453 } // namespace Internal
 454
 455 } // namespace Toolkit
 456
 457 } // namespace Dali