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   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 / 2.0 - 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   \n
 168   void main()\n
 169   {\n
 170       mediump float dist = length( max( abs( vPosition ), vRectSize ) - vRectSize ) - cornerRadius;\n
 171       gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n
 172       gl_FragColor.a *= smoothstep( 1.0, -1.0, dist );\n
 173   }\n
 174 );
 175
 176 } // unnamed namespace
 177
 178 ImageVisualShaderFactory::ImageVisualShaderFactory()
 179 {
 180 }
 181
 182 ImageVisualShaderFactory::~ImageVisualShaderFactory()
 183 {
 184 }
 185
 186 Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping, bool roundedCorner )
 187 {
 188   Shader shader;
 189   if( atlasing )
 190   {
 191     if( defaultTextureWrapping )
 192     {
 193       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
 194       if( !shader )
 195       {
 196         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
 197         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 198         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
 199       }
 200     }
 201     else
 202     {
 203       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
 204       if( !shader )
 205       {
 206         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
 207         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 208         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
 209       }
 210     }
 211   }
 212   else
 213   {
 214     if( roundedCorner )
 215     {
 216       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER );
 217       if( !shader )
 218       {
 219         shader = Shader::New( VERTEX_SHADER_ROUNDED_CORNER, FRAGMENT_SHADER_ROUNDED_CORNER );
 220         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 221         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER, shader );
 222       }
 223     }
 224     else
 225     {
 226       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 227       if( !shader )
 228       {
 229         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
 230         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 231         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 232       }
 233     }
 234   }
 235
 236   return shader;
 237 }
 238
 239 const char* ImageVisualShaderFactory::GetVertexShaderSource()
 240 {
 241   return VERTEX_SHADER;
 242 }
 243
 244 const char* ImageVisualShaderFactory::GetFragmentShaderSource()
 245 {
 246   return FRAGMENT_SHADER_NO_ATLAS;
 247 }
 248
 249 } // namespace Internal
 250
 251 } // namespace Toolkit
 252
 253 } // namespace Dali