dali-toolkit/internal/visuals/image-visual-shader-factory.cpp

   1  /*
   2  * Copyright (c) 2018 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 // CLASS HEADER
  18 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  19
  20 // EXTERNAL INCLUDES
  21
  22 // INTERNAL INCLUDES
  23 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  24
  25 namespace Dali
  26 {
  27
  28 namespace Toolkit
  29 {
  30
  31 namespace Internal
  32 {
  33
  34 namespace
  35 {
  36
  37 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  38
  39 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  40   attribute mediump vec2 aPosition;\n
  41   uniform highp   mat4 uMvpMatrix;\n
  42   uniform mediump vec3 uSize;\n
  43   uniform mediump vec4 pixelArea;
  44   varying mediump vec2 vTexCoord;\n
  45   \n
  46   //Visual size and offset
  47   uniform mediump vec2 offset;\n
  48   uniform mediump vec2 size;\n
  49   uniform mediump vec4 offsetSizeMode;\n
  50   uniform mediump vec2 origin;\n
  51   uniform mediump vec2 anchorPoint;\n
  52 \n
  53   vec4 ComputeVertexPosition()\n
  54   {\n
  55     vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
  56     vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
  57     return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
  58   }\n
  59 \n
  60   void main()\n
  61   {\n
  62     gl_Position = uMvpMatrix * ComputeVertexPosition();\n
  63     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
  64   }\n
  65 );
  66
  67 const char* FRAGMENT_SHADER_NO_ATLAS = DALI_COMPOSE_SHADER(
  68   varying mediump vec2 vTexCoord;\n
  69   uniform sampler2D sTexture;\n
  70   uniform lowp vec4 uColor;\n
  71   uniform lowp vec3 mixColor;\n
  72   uniform lowp float preMultipliedAlpha;\n
  73   \n
  74   void main()\n
  75   {\n
  76       gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n
  77   }\n
  78 );
  79
  80 const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER(
  81     varying mediump vec2 vTexCoord;\n
  82     uniform sampler2D sTexture;\n
  83     uniform mediump vec4 uAtlasRect;\n
  84     uniform lowp vec4 uColor;\n
  85     uniform lowp vec3 mixColor;\n
  86     uniform lowp float preMultipliedAlpha;\n
  87     \n
  88     void main()\n
  89     {\n
  90         mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n
  91         gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n
  92      }\n
  93 );
  94
  95 const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER(
  96     varying mediump vec2 vTexCoord;\n
  97     uniform sampler2D sTexture;\n
  98     uniform mediump vec4 uAtlasRect;\n
  99     // WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
 100     uniform lowp vec2 wrapMode;\n
 101     uniform lowp vec4 uColor;\n
 102     uniform lowp vec3 mixColor;\n
 103     uniform lowp float preMultipliedAlpha;\n
 104     \n
 105     mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n
 106     {\n
 107       mediump float coord;\n
 108       if( wrap > 1.5 )\n // REFLECT
 109         coord = 1.0-abs(fract(coordinate*0.5)*2.0 - 1.0);\n
 110       else \n// warp == 0 or 1
 111         coord = mix(coordinate, fract( coordinate ), wrap);\n
 112       return clamp( mix(range.x, range.y, coord), range.x, range.y );
 113     }\n
 114     \n
 115     void main()\n
 116     {\n
 117         mediump vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ),
 118                                       wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );\n
 119         gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n
 120     }\n
 121 );
 122
 123 const char* VERTEX_SHADER_ROUNDED_CORNER = DALI_COMPOSE_SHADER(
 124   attribute mediump vec2 aPosition;\n
 125   uniform highp   mat4 uMvpMatrix;\n
 126   uniform mediump vec3 uSize;\n
 127   uniform mediump vec4 pixelArea;
 128   varying mediump vec2 vTexCoord;\n
 129   varying mediump vec2 vPosition;\n
 130   varying mediump vec2 vRectSize;\n
 131   \n
 132   //Visual size and offset
 133   uniform mediump vec2 offset;\n
 134   uniform mediump vec2 size;\n
 135   uniform mediump vec4 offsetSizeMode;\n
 136   uniform mediump vec2 origin;\n
 137   uniform mediump vec2 anchorPoint;\n
 138   uniform mediump float cornerRadius;\n
 139   \n
 140   vec4 ComputeVertexPosition()\n
 141   {\n
 142     vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
 143     vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
 144     vRectSize = visualSize / 2.0 - cornerRadius;\n
 145     vPosition = aPosition* visualSize;\n
 146     return vec4( vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
 147   }\n
 148 \n
 149   void main()\n
 150   {\n
 151     gl_Position = uMvpMatrix * ComputeVertexPosition();\n
 152     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
 153   }\n
 154 );
 155
 156 //float distance = length( max( abs( position - center ), size ) - size ) - radius;
 157 const char* FRAGMENT_SHADER_ROUNDED_CORNER = DALI_COMPOSE_SHADER(
 158   varying mediump vec2 vTexCoord;\n
 159   varying mediump vec2 vPosition;\n
 160   varying mediump vec2 vRectSize;\n
 161   uniform sampler2D sTexture;\n
 162   uniform lowp vec4 uColor;\n
 163   uniform lowp vec3 mixColor;\n
 164   uniform mediump float cornerRadius;\n
 165   \n
 166   void main()\n
 167   {\n
 168       mediump float dist = length( max( abs( vPosition ), vRectSize ) - vRectSize ) - cornerRadius;\n
 169       gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n
 170       gl_FragColor.a *= smoothstep( 1.0, -1.0, dist );\n
 171   }\n
 172 );
 173
 174 } // unnamed namespace
 175
 176 ImageVisualShaderFactory::ImageVisualShaderFactory()
 177 {
 178 }
 179
 180 ImageVisualShaderFactory::~ImageVisualShaderFactory()
 181 {
 182 }
 183
 184 Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping, bool roundedCorner )
 185 {
 186   Shader shader;
 187   if( atlasing )
 188   {
 189     if( defaultTextureWrapping )
 190     {
 191       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
 192       if( !shader )
 193       {
 194         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
 195         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 196         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
 197       }
 198     }
 199     else
 200     {
 201       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
 202       if( !shader )
 203       {
 204         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
 205         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 206         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
 207       }
 208     }
 209   }
 210   else
 211   {
 212     if( roundedCorner )
 213     {
 214       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER );
 215       if( !shader )
 216       {
 217         shader = Shader::New( VERTEX_SHADER_ROUNDED_CORNER, FRAGMENT_SHADER_ROUNDED_CORNER );
 218         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 219         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER, shader );
 220       }
 221     }
 222     else
 223     {
 224       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 225       if( !shader )
 226       {
 227         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
 228         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 229         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 230       }
 231     }
 232   }
 233
 234   return shader;
 235 }
 236
 237 const char* ImageVisualShaderFactory::GetVertexShaderSource()
 238 {
 239   return VERTEX_SHADER;
 240 }
 241
 242 const char* ImageVisualShaderFactory::GetFragmentShaderSource()
 243 {
 244   return FRAGMENT_SHADER_NO_ATLAS;
 245 }
 246
 247 } // namespace Internal
 248
 249 } // namespace Toolkit
 250
 251 } // namespace Dali