dali-toolkit/internal/graphics/shaders/image-visual-shader.vert

   1 INPUT mediump vec2 aPosition;
   2 OUTPUT mediump vec2 vTexCoord;
   3 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
   4 OUTPUT mediump vec2 vPosition;
   5 OUTPUT mediump vec2 vRectSize;
   6 OUTPUT mediump vec2 vOptRectSize;
   7 OUTPUT mediump float vAliasMargin;
   8 #ifdef IS_REQUIRED_ROUNDED_CORNER
   9 OUTPUT mediump vec4 vCornerRadius;
  10 #endif
  11 #endif
  12
  13 uniform highp mat4 uMvpMatrix;
  14 uniform highp vec3 uSize;
  15 uniform mediump vec4 pixelArea;
  16
  17 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
  18 // Be used when we calculate anti-alias range near 1 pixel.
  19 uniform highp vec3 uScale;
  20 #endif
  21
  22 //Visual size and offset
  23 uniform mediump vec2 offset;
  24 uniform highp vec2 size;
  25 uniform mediump vec4 offsetSizeMode;
  26 uniform mediump vec2 origin;
  27 uniform mediump vec2 anchorPoint;
  28 #ifdef IS_REQUIRED_BORDERLINE
  29 uniform mediump float borderlineWidth;
  30 uniform mediump float borderlineOffset;
  31 #endif
  32 #ifdef IS_REQUIRED_ROUNDED_CORNER
  33 uniform highp vec4 cornerRadius;
  34 uniform mediump float cornerRadiusPolicy;
  35 #endif
  36 #ifdef IS_REQUIRED_ALPHA_MASKING
  37 OUTPUT  mediump vec2  vMaskTexCoord;
  38 uniform lowp    float cropToMask;
  39 uniform mediump vec2  maskTextureRatio;
  40 #endif
  41 uniform mediump vec2 extraSize;
  42
  43 vec4 ComputeVertexPosition()
  44 {
  45   vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw) + extraSize;
  46   vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
  47
  48 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
  49   vRectSize = visualSize * 0.5;
  50   vOptRectSize = vRectSize;
  51
  52   // Set soft anti-alias range at most 10% of visual size.
  53   // The range should be inverse proportion with scale of view.
  54   // To avoid divid-by-zero, let we allow minimum scale value is 0.001 (0.1%)
  55   vAliasMargin = min(1.0, max(visualSize.x, visualSize.y) * 0.1) / max(0.001, max(uScale.x, uScale.y));
  56
  57   mediump float vertexMargin = 0.0;
  58 #endif
  59
  60 #ifdef IS_REQUIRED_BORDERLINE
  61   // Extend size of visual by borderline.
  62   mediump float outerBorderlineSize = (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth;
  63 #endif
  64
  65 #ifdef IS_REQUIRED_ROUNDED_CORNER
  66 #ifdef IS_REQUIRED_BORDERLINE
  67   mediump float maxSize = max(visualSize.x, visualSize.y) + outerBorderlineSize;
  68   mediump float minSize = min(visualSize.x, visualSize.y) + outerBorderlineSize;
  69 #else
  70   mediump float maxSize = max(visualSize.x, visualSize.y);
  71   mediump float minSize = min(visualSize.x, visualSize.y);
  72 #endif
  73   vCornerRadius = mix(cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
  74   vCornerRadius = min(vCornerRadius, minSize * 0.5);
  75   // Optimize fragment shader. 0.2929 ~= 1.0 - sqrt(0.5)
  76   mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
  77   mediump float minRadius = min(min(vCornerRadius.x, vCornerRadius.y), min(vCornerRadius.z, vCornerRadius.w));
  78   vOptRectSize -= 0.2929 * maxRadius + 1.0;
  79
  80   // Set vertex margin as vAliasMargin if we need to make some more fragments for alias.
  81   // Do not increase margin if the minRadius is small enough rather than maxSize.
  82   // TODO : We should change the magic parameter, 0.49
  83   vertexMargin = 2.0 * vAliasMargin * smoothstep(maxSize * 0.49, maxSize * 0.5, minRadius);
  84 #endif
  85
  86 #ifdef IS_REQUIRED_BORDERLINE
  87   vPosition = aPosition * (visualSize + outerBorderlineSize + vertexMargin);
  88   vOptRectSize -= (borderlineWidth - outerBorderlineSize * 0.5) + 1.0;
  89 #elif defined(IS_REQUIRED_ROUNDED_CORNER)
  90   vPosition = aPosition * (visualSize + vertexMargin);
  91 #else
  92   mediump vec2 vPosition = aPosition * visualSize;
  93 #endif
  94
  95   vec4 finalPixelArea = pixelArea;
  96 #ifdef IS_REQUIRED_ALPHA_MASKING
  97   finalPixelArea = mix(pixelArea,
  98                        vec4(
  99                             vec2(0.5) + (pixelArea.xy - vec2(0.5)) * maskTextureRatio,
 100                             pixelArea.zw * maskTextureRatio
 101                        ),
 102                        cropToMask);
 103   vMaskTexCoord = pixelArea.xy + pixelArea.zw * (vec2(0.5) + aPosition.xy
 104 #ifdef IS_REQUIRED_BORDERLINE
 105                                                   * (1.0 + (outerBorderlineSize + vertexMargin) / visualSize)
 106 #elif defined(IS_REQUIRED_ROUNDED_CORNER)
 107                                                   * (1.0 + vertexMargin / visualSize)
 108 #endif
 109                                                 );
 110 #endif
 111   vTexCoord = finalPixelArea.xy + finalPixelArea.zw * (vec2(0.5) + aPosition.xy
 112 #ifdef IS_REQUIRED_BORDERLINE
 113                                                         * (1.0 + (outerBorderlineSize + vertexMargin) / visualSize)
 114 #elif defined(IS_REQUIRED_ROUNDED_CORNER)
 115                                                         * (1.0 + vertexMargin / visualSize)
 116 #endif
 117                                                       );
 118
 119   return vec4(vPosition + anchorPoint * visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0);
 120 }
 121
 122 void main()
 123 {
 124   gl_Position = uMvpMatrix * ComputeVertexPosition();
 125 }