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

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