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 mediump mat4 uModelMatrix;\n
  42   uniform mediump mat4 uViewMatrix;\n
  43   uniform mediump mat4 uProjection;\n
  44   uniform mediump vec3 uSize;\n
  45   uniform mediump vec4 pixelArea;
  46   varying mediump vec2 vTexCoord;\n
  47   uniform lowp float uPixelAligned;\n
  48   \n
  49   //Visual size and offset
  50   uniform mediump vec2 offset;\n
  51   uniform mediump vec2 size;\n
  52   uniform mediump vec4 offsetSizeMode;\n
  53   uniform mediump vec2 origin;\n
  54   uniform mediump vec2 anchorPoint;\n
  55 \n
  56   vec4 ComputeVertexPosition()\n
  57   {\n
  58     vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
  59     vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
  60     return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
  61   }\n
  62 \n
  63   void main()\n
  64   {\n
  65     mediump vec4 vertexPosition = uViewMatrix * uModelMatrix * ComputeVertexPosition();\n
  66     vec4 alignedVertexPosition = vertexPosition;\n
  67     alignedVertexPosition.xy = floor ( vertexPosition.xy );\n // Pixel alignment
  68     vertexPosition = uProjection * mix( vertexPosition, alignedVertexPosition, uPixelAligned );\n
  69     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
  70     gl_Position = vertexPosition;\n
  71   }\n
  72 );
  73
  74 const char* FRAGMENT_SHADER_NO_ATLAS = DALI_COMPOSE_SHADER(
  75   varying mediump vec2 vTexCoord;\n
  76   uniform sampler2D sTexture;\n
  77   uniform lowp vec4 uColor;\n
  78   uniform lowp vec3 mixColor;\n
  79   uniform lowp float preMultipliedAlpha;\n
  80   \n
  81   void main()\n
  82   {\n
  83       gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n
  84   }\n
  85 );
  86
  87 const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER(
  88     varying mediump vec2 vTexCoord;\n
  89     uniform sampler2D sTexture;\n
  90     uniform mediump vec4 uAtlasRect;\n
  91     uniform lowp vec4 uColor;\n
  92     uniform lowp vec3 mixColor;\n
  93     uniform lowp float preMultipliedAlpha;\n
  94     \n
  95     void main()\n
  96     {\n
  97         mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n
  98         gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n
  99      }\n
 100 );
 101
 102 const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER(
 103     varying mediump vec2 vTexCoord;\n
 104     uniform sampler2D sTexture;\n
 105     uniform mediump vec4 uAtlasRect;\n
 106     // WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
 107     uniform lowp vec2 wrapMode;\n
 108     uniform lowp vec4 uColor;\n
 109     uniform lowp vec3 mixColor;\n
 110     uniform lowp float preMultipliedAlpha;\n
 111     \n
 112     mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n
 113     {\n
 114       mediump float coord;\n
 115       if( wrap > 1.5 )\n // REFLECT
 116         coord = 1.0-abs(fract(coordinate*0.5)*2.0 - 1.0);\n
 117       else \n// warp == 0 or 1
 118         coord = mix(coordinate, fract( coordinate ), wrap);\n
 119       return clamp( mix(range.x, range.y, coord), range.x, range.y );
 120     }\n
 121     \n
 122     void main()\n
 123     {\n
 124         mediump vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ),
 125                                       wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );\n
 126         gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n
 127     }\n
 128 );
 129
 130 } // unnamed namespace
 131
 132 ImageVisualShaderFactory::ImageVisualShaderFactory()
 133 {
 134 }
 135
 136 ImageVisualShaderFactory::~ImageVisualShaderFactory()
 137 {
 138 }
 139
 140 Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping )
 141 {
 142   Shader shader;
 143   if( atlasing )
 144   {
 145     if( defaultTextureWrapping )
 146     {
 147       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
 148       if( !shader )
 149       {
 150         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
 151         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 152         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
 153       }
 154     }
 155     else
 156     {
 157       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
 158       if( !shader )
 159       {
 160         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
 161         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 162         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
 163       }
 164     }
 165   }
 166   else
 167   {
 168     shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 169     if( !shader )
 170     {
 171       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
 172       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 173       factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 174     }
 175   }
 176
 177   return shader;
 178 }
 179
 180 const char* ImageVisualShaderFactory::GetVertexShaderSource()
 181 {
 182   return VERTEX_SHADER;
 183 }
 184
 185 const char* ImageVisualShaderFactory::GetFragmentShaderSource()
 186 {
 187   return FRAGMENT_SHADER_NO_ATLAS;
 188 }
 189
 190 } // namespace Internal
 191
 192 } // namespace Toolkit
 193
 194 } // namespace Dali