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   \n
 133   //Visual size and offset
 134   uniform mediump vec2 offset;\n
 135   uniform mediump vec2 size;\n
 136   uniform mediump vec4 offsetSizeMode;\n
 137   uniform mediump vec2 origin;\n
 138   uniform mediump vec2 anchorPoint;\n
 139   uniform mediump float cornerRadius;\n
 140   uniform mediump vec2 extraSize;\n
 141   \n
 142   vec4 ComputeVertexPosition()\n
 143   {\n
 144     vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw ) + extraSize;\n
 145     vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
 146     vRectSize = visualSize * 0.5 - cornerRadius;\n
 147     vPosition = aPosition* visualSize;\n
 148     return vec4( vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
 149   }\n
 150 \n
 151   void main()\n
 152   {\n
 153     gl_Position = uMvpMatrix * ComputeVertexPosition();\n
 154     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
 155   }\n
 156 );
 157
 158 //float distance = length( max( abs( position - center ), size ) - size ) - radius;
 159 const char* FRAGMENT_SHADER_ROUNDED_CORNER = DALI_COMPOSE_SHADER(
 160   varying mediump vec2 vTexCoord;\n
 161   varying mediump vec2 vPosition;\n
 162   varying mediump vec2 vRectSize;\n
 163   uniform sampler2D sTexture;\n
 164   uniform lowp vec4 uColor;\n
 165   uniform lowp vec3 mixColor;\n
 166   uniform mediump float cornerRadius;\n
 167   uniform lowp float preMultipliedAlpha;\n
 168   \n
 169   void main()\n
 170   {\n
 171       mediump float dist = length( max( abs( vPosition ), vRectSize ) - vRectSize ) - cornerRadius;\n
 172       mediump float opacity = 1.0 - smoothstep( -1.0, 1.0, dist );\n
 173       gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n
 174       gl_FragColor.a *= opacity;\n
 175       gl_FragColor.rgb *= mix( 1.0, opacity, preMultipliedAlpha );\n
 176   }\n
 177 );
 178
 179 } // unnamed namespace
 180
 181 ImageVisualShaderFactory::ImageVisualShaderFactory()
 182 {
 183 }
 184
 185 ImageVisualShaderFactory::~ImageVisualShaderFactory()
 186 {
 187 }
 188
 189 Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping, bool roundedCorner )
 190 {
 191   Shader shader;
 192   if( atlasing )
 193   {
 194     if( defaultTextureWrapping )
 195     {
 196       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
 197       if( !shader )
 198       {
 199         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
 200         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 201         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
 202       }
 203     }
 204     else
 205     {
 206       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
 207       if( !shader )
 208       {
 209         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
 210         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 211         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
 212       }
 213     }
 214   }
 215   else
 216   {
 217     if( roundedCorner )
 218     {
 219       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER );
 220       if( !shader )
 221       {
 222         shader = Shader::New( VERTEX_SHADER_ROUNDED_CORNER, FRAGMENT_SHADER_ROUNDED_CORNER );
 223         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 224         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER, shader );
 225       }
 226     }
 227     else
 228     {
 229       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 230       if( !shader )
 231       {
 232         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
 233         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 234         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 235       }
 236     }
 237   }
 238
 239   return shader;
 240 }
 241
 242 const char* ImageVisualShaderFactory::GetVertexShaderSource()
 243 {
 244   return VERTEX_SHADER;
 245 }
 246
 247 const char* ImageVisualShaderFactory::GetFragmentShaderSource()
 248 {
 249   return FRAGMENT_SHADER_NO_ATLAS;
 250 }
 251
 252 } // namespace Internal
 253
 254 } // namespace Toolkit
 255
 256 } // namespace Dali