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 } // unnamed namespace
 124
 125 ImageVisualShaderFactory::ImageVisualShaderFactory()
 126 {
 127 }
 128
 129 ImageVisualShaderFactory::~ImageVisualShaderFactory()
 130 {
 131 }
 132
 133 Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping )
 134 {
 135   Shader shader;
 136   if( atlasing )
 137   {
 138     if( defaultTextureWrapping )
 139     {
 140       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
 141       if( !shader )
 142       {
 143         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
 144         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 145         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
 146       }
 147     }
 148     else
 149     {
 150       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
 151       if( !shader )
 152       {
 153         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
 154         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 155         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
 156       }
 157     }
 158   }
 159   else
 160   {
 161     shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 162     if( !shader )
 163     {
 164       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
 165       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 166       factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 167     }
 168   }
 169
 170   return shader;
 171 }
 172
 173 const char* ImageVisualShaderFactory::GetVertexShaderSource()
 174 {
 175   return VERTEX_SHADER;
 176 }
 177
 178 const char* ImageVisualShaderFactory::GetFragmentShaderSource()
 179 {
 180   return FRAGMENT_SHADER_NO_ATLAS;
 181 }
 182
 183 } // namespace Internal
 184
 185 } // namespace Toolkit
 186
 187 } // namespace Dali