[Tizen] Change precision of corner radius relative shader codes as highp 00/306700/1
authorEunki, Hong <eunkiki.hong@samsung.com>
Mon, 26 Feb 2024 09:31:22 +0000 (18:31 +0900)
committerEunki, Hong <eunkiki.hong@samsung.com>
Mon, 26 Feb 2024 09:59:03 +0000 (18:59 +0900)
There was some visual defect when view size is near 20,000 in target.

Change-Id: Ia9440c98e20a873664d09493cc9d645f1f7a91b1
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>
dali-toolkit/internal/graphics/shaders/color-visual-shader.frag
dali-toolkit/internal/graphics/shaders/color-visual-shader.vert
dali-toolkit/internal/graphics/shaders/gradient-visual-shader.frag
dali-toolkit/internal/graphics/shaders/gradient-visual-shader.vert
dali-toolkit/internal/graphics/shaders/image-visual-shader.frag
dali-toolkit/internal/graphics/shaders/image-visual-shader.vert

index 662121e..5be7b02 100644 (file)
@@ -1,19 +1,19 @@
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
-INPUT mediump vec2 vPosition;
-INPUT mediump vec2 vRectSize;
-INPUT mediump vec2 vOptRectSize;
+INPUT highp vec2 vPosition;
+INPUT highp vec2 vRectSize;
+INPUT highp vec2 vOptRectSize;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-INPUT mediump vec4 vCornerRadius;
+INPUT highp vec4 vCornerRadius;
 #endif
 #endif
 
 uniform lowp vec4 uColor;
 uniform lowp vec3 mixColor;
 #ifdef IS_REQUIRED_BLUR
-uniform mediump float blurRadius;
+uniform highp float blurRadius;
 #elif defined(IS_REQUIRED_BORDERLINE)
-uniform mediump float borderlineWidth;
-uniform mediump float borderlineOffset;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
 uniform lowp vec4 borderlineColor;
 uniform lowp vec4 uActorColor;
 #endif
@@ -23,23 +23,23 @@ uniform lowp vec4 uActorColor;
 // Global values both rounded corner and borderline use
 
 // radius of rounded corner on this quadrant
-mediump float gRadius = 0.0;
+highp float gRadius = 0.0;
 
 // fragment coordinate. NOTE : vec2(0.0, 0.0) is vRectSize, the corner of visual
-mediump vec2 gFragmentPosition = vec2(0.0, 0.0);
+highp vec2 gFragmentPosition = vec2(0.0, 0.0);
 // center coordinate of rounded corner circle. vec2(gCenterPosition, gCenterPosition).
-mediump float gCenterPosition = 0.0;
+highp float gCenterPosition = 0.0;
 // relative coordinate of gFragmentPosition from gCenterPosition.
-mediump vec2 gDiff = vec2(0.0, 0.0);
+highp vec2 gDiff = vec2(0.0, 0.0);
 // potential value what our algorithm use.
-mediump float gPotential = 0.0;
+highp float gPotential = 0.0;
 
 // threshold of potential
-mediump float gPotentialRange = 0.0;
-mediump float gMaxOutlinePotential = 0.0;
-mediump float gMinOutlinePotential = 0.0;
-mediump float gMaxInlinePotential = 0.0;
-mediump float gMinInlinePotential = 0.0;
+highp float gPotentialRange = 0.0;
+highp float gMaxOutlinePotential = 0.0;
+highp float gMinOutlinePotential = 0.0;
+highp float gMaxInlinePotential = 0.0;
+highp float gMinInlinePotential = 0.0;
 
 void calculateCornerRadius()
 {
@@ -107,7 +107,7 @@ void PreprocessPotential()
 #elif defined(IS_REQUIRED_BORDERLINE)
 lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
 {
-  mediump float potential = gPotential;
+  highp float potential = gPotential;
 
   // default opacity of borderline is 0.0
   mediump float borderlineOpacity = 0.0;
@@ -131,9 +131,9 @@ lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
   // But if borderlineOpacity > 0.0 and borderlineColor.a == 0.0, we need to apply tCornerRadius.
   if(borderlineOpacity > 0.0 && borderlineColor.a * borderlineOpacity < 1.0)
   {
-    mediump float tCornerRadius = -gCenterPosition + gPotentialRange;
-    mediump float MaxTexturelinePotential = tCornerRadius + gPotentialRange;
-    mediump float MinTexturelinePotential = tCornerRadius - gPotentialRange;
+    highp float tCornerRadius = -gCenterPosition + gPotentialRange;
+    highp float MaxTexturelinePotential = tCornerRadius + gPotentialRange;
+    highp float MinTexturelinePotential = tCornerRadius - gPotentialRange;
     if(potential > MaxTexturelinePotential)
     {
       // potential is out of texture range.
@@ -172,7 +172,7 @@ lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
 #elif defined(IS_REQUIRED_ROUNDED_CORNER)
 mediump float calculateCornerOpacity()
 {
-  mediump float potential = gPotential;
+  highp float potential = gPotential;
 
   // default opacity is 1.0
   mediump float opacity = 1.0;
@@ -195,9 +195,9 @@ mediump float calculateCornerOpacity()
 mediump float calculateBlurOpacity()
 {
 // Don't use borderline!
-  mediump vec2 v = gDiff;
-  mediump float cy = gRadius + blurRadius;
-  mediump float cr = gRadius + blurRadius;
+  highp vec2 v = gDiff;
+  highp float cy = gRadius + blurRadius;
+  highp float cr = gRadius + blurRadius;
 
 #ifdef IS_REQUIRED_ROUNDED_CORNER
   // This routine make perfect circle. If corner radius is not exist, we don't consider prefect circle.
@@ -206,17 +206,17 @@ mediump float calculateBlurOpacity()
   v = vec2(min(v.x, v.y), max(v.x, v.y));
   v = v + cy;
 
-  mediump float potential = 0.0;
-  mediump float alias = min(gRadius, 1.0);
-  mediump float potentialMin = cy + gRadius - blurRadius - alias;
-  mediump float potentialMax = cy + gRadius + blurRadius + alias;
+  highp float potential = 0.0;
+  highp float alias = min(gRadius, 1.0);
+  highp float potentialMin = cy + gRadius - blurRadius - alias;
+  highp float potentialMax = cy + gRadius + blurRadius + alias;
 
   // move center of circles for reduce defact
-  mediump float cyDiff = min(cy, 0.2 * blurRadius);
+  highp float cyDiff = min(cy, 0.2 * blurRadius);
   cy -= cyDiff;
   cr += cyDiff;
 
-  mediump float diffFromBaseline = cy * v.y - (cy + cr) * v.x;
+  highp float diffFromBaseline = cy * v.y - (cy + cr) * v.x;
 
   if(diffFromBaseline > 0.0)
   {
@@ -224,8 +224,8 @@ mediump float calculateBlurOpacity()
     potential = v.y;
 
     // for anti-alias when blurRaidus = 0.0
-    mediump float heuristicBaselineScale = max(1.0 , cr * (cr + cy));
-    mediump float potentialDiff = min(alias, diffFromBaseline / heuristicBaselineScale);
+    highp float heuristicBaselineScale = max(1.0 , cr * (cr + cy));
+    highp float potentialDiff = min(alias, diffFromBaseline / heuristicBaselineScale);
     potentialMin += potentialDiff;
     potentialMax -= potentialDiff;
   }
@@ -251,7 +251,7 @@ mediump float calculateBlurOpacity()
     //          ~= 10.0*(v.x+v.y) * (0.11803399 - 0.44721360x + 0.35777088x^2 - 0.14310x^3 + O(x^5)) (Taylor series)
     //          ~= -1.0557281 * (v.x + v.y) + 2.236068 * length(v) - ~~~ (here, x <= 0.5 * (1.0 - sqrt(0.5)) < 0.1464467)
     // Note : This simplify need cause we should use it on lowspec HW.
-    mediump float x = 0.5 * (1.0 - length(v) / (v.x + v.y));
+    highp float x = 0.5 * (1.0 - length(v) / (v.x + v.y));
     potential = -1.0557281 * (v.x + v.y) + 2.236068 * length(v) + 10.0 * (v.x + v.y) * (0.35777088 - 0.14310 * x) * x * x;
 #endif
   }
index 29ad984..884103c 100644 (file)
@@ -1,10 +1,10 @@
 INPUT mediump vec2 aPosition;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
-OUTPUT mediump vec2 vPosition;
-OUTPUT mediump vec2 vRectSize;
-OUTPUT mediump vec2 vOptRectSize;
+OUTPUT highp vec2 vPosition;
+OUTPUT highp vec2 vRectSize;
+OUTPUT highp vec2 vOptRectSize;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-OUTPUT mediump vec4 vCornerRadius;
+OUTPUT highp vec4 vCornerRadius;
 #endif
 #endif
 
@@ -12,27 +12,27 @@ uniform highp mat4 uMvpMatrix;
 uniform highp vec3 uSize;
 
 //Visual size and offset
-uniform mediump vec2 offset;
+uniform highp vec2 offset;
 uniform highp vec2 size;
 uniform mediump vec4 offsetSizeMode;
 uniform mediump vec2 origin;
 uniform mediump vec2 anchorPoint;
 #ifdef IS_REQUIRED_BLUR
-uniform mediump float blurRadius;
+uniform highp float blurRadius;
 #elif defined(IS_REQUIRED_BORDERLINE)
-uniform mediump float borderlineWidth;
-uniform mediump float borderlineOffset;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
 #endif
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 uniform highp vec4 cornerRadius;
 uniform mediump float cornerRadiusPolicy;
 #endif
-uniform mediump vec2 extraSize;
+uniform highp vec2 extraSize;
 
 vec4 ComputeVertexPosition()
 {
-  vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
-  vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
+  highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
+  highp vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
 
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
   vRectSize = visualSize * 0.5;
@@ -41,16 +41,16 @@ vec4 ComputeVertexPosition()
 
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 #ifdef IS_REQUIRED_BLUR
-  mediump float minSize = min(visualSize.x, visualSize.y);
+  highp float minSize = min(visualSize.x, visualSize.y);
 #elif defined(IS_REQUIRED_BORDERLINE)
-  mediump float minSize = min(visualSize.x, visualSize.y) + (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth;
+  highp float minSize = min(visualSize.x, visualSize.y) + (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth;
 #else
-  mediump float minSize = min(visualSize.x, visualSize.y);
+  highp float minSize = min(visualSize.x, visualSize.y);
 #endif
   vCornerRadius = mix(cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
   vCornerRadius = min(vCornerRadius, minSize * 0.5);
   // Optimize fragment shader. 0.2929 ~= 1.0 - sqrt(0.5)
-  mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+  highp float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
   vOptRectSize -= 0.2929 * maxRadius + 1.0;
 #endif
 
@@ -63,7 +63,7 @@ vec4 ComputeVertexPosition()
 #elif defined(IS_REQUIRED_ROUNDED_CORNER)
   vPosition = aPosition * visualSize;
 #else
-  mediump vec2 vPosition = aPosition * visualSize;
+  highp vec2 vPosition = aPosition * visualSize;
 #endif
   return vec4(vPosition + anchorPoint * visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0);
 }
index 5104f6b..edb8e5d 100644 (file)
@@ -1,10 +1,10 @@
 INPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-INPUT mediump vec2 vPosition;
-INPUT mediump vec2 vRectSize;
-INPUT mediump vec2 vOptRectSize;
+INPUT highp vec2 vPosition;
+INPUT highp vec2 vRectSize;
+INPUT highp vec2 vOptRectSize;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-INPUT mediump vec4 vCornerRadius;
+INPUT highp vec4 vCornerRadius;
 #endif
 #endif
 
@@ -15,8 +15,8 @@ uniform sampler2D sTexture; // sampler1D?
 uniform lowp vec4 uColor;
 uniform lowp vec3 mixColor;
 #ifdef IS_REQUIRED_BORDERLINE
-uniform mediump float borderlineWidth;
-uniform mediump float borderlineOffset;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
 uniform lowp vec4 borderlineColor;
 uniform lowp vec4 uActorColor;
 #endif
@@ -25,23 +25,23 @@ uniform lowp vec4 uActorColor;
 // Global values both rounded corner and borderline use
 
 // radius of rounded corner on this quadrant
-mediump float gRadius = 0.0;
+highp float gRadius = 0.0;
 
 // fragment coordinate. NOTE : vec2(0.0, 0.0) is vRectSize, the corner of visual
-mediump vec2 gFragmentPosition = vec2(0.0, 0.0);
+highp vec2 gFragmentPosition = vec2(0.0, 0.0);
 // center coordinate of rounded corner circle. vec2(gCenterPosition, gCenterPosition).
-mediump float gCenterPosition = 0.0;
+highp float gCenterPosition = 0.0;
 // relative coordinate of gFragmentPosition from gCenterPosition.
-mediump vec2 gDiff = vec2(0.0, 0.0);
+highp vec2 gDiff = vec2(0.0, 0.0);
 // potential value what our algorithm use.
-mediump float gPotential = 0.0;
+highp float gPotential = 0.0;
 
 // threshold of potential
-mediump float gPotentialRange = 0.0;
-mediump float gMaxOutlinePotential = 0.0;
-mediump float gMinOutlinePotential = 0.0;
-mediump float gMaxInlinePotential = 0.0;
-mediump float gMinInlinePotential = 0.0;
+highp float gPotentialRange = 0.0;
+highp float gMaxOutlinePotential = 0.0;
+highp float gMinOutlinePotential = 0.0;
+highp float gMaxInlinePotential = 0.0;
+highp float gMinInlinePotential = 0.0;
 
 void calculateCornerRadius()
 {
@@ -105,7 +105,7 @@ void PreprocessPotential()
 #ifdef IS_REQUIRED_BORDERLINE
 lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
 {
-  mediump float potential = gPotential;
+  highp float potential = gPotential;
 
   // default opacity of borderline is 0.0
   mediump float borderlineOpacity = 0.0;
@@ -130,9 +130,9 @@ lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
   // But if borderlineOpacity > 0.0 and borderlineColor.a == 0.0, we need to apply tCornerRadius.
   if(borderlineOpacity > 0.0 && borderlineColor.a * borderlineOpacity < 1.0)
   {
-    mediump float tCornerRadius = -gCenterPosition + gPotentialRange;
-    mediump float MaxTexturelinePotential = tCornerRadius + gPotentialRange;
-    mediump float MinTexturelinePotential = tCornerRadius - gPotentialRange;
+    highp float tCornerRadius = -gCenterPosition + gPotentialRange;
+    highp float MaxTexturelinePotential = tCornerRadius + gPotentialRange;
+    highp float MinTexturelinePotential = tCornerRadius - gPotentialRange;
     if(potential > MaxTexturelinePotential)
     {
       // potential is out of texture range.
@@ -169,7 +169,7 @@ lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 mediump float calculateCornerOpacity()
 {
-  mediump float potential = gPotential;
+  highp float potential = gPotential;
 
   // default opacity is 1.0
   mediump float opacity = 1.0;
index b2b0864..6e8fa26 100644 (file)
@@ -1,11 +1,11 @@
 INPUT mediump vec2 aPosition;
 OUTPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-OUTPUT mediump vec2 vPosition;
-OUTPUT mediump vec2 vRectSize;
-OUTPUT mediump vec2 vOptRectSize;
+OUTPUT highp vec2 vPosition;
+OUTPUT highp vec2 vRectSize;
+OUTPUT highp vec2 vOptRectSize;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-OUTPUT mediump vec4 vCornerRadius;
+OUTPUT highp vec4 vCornerRadius;
 #endif
 #endif
 
@@ -14,14 +14,14 @@ uniform highp vec3 uSize;
 uniform mediump mat3 uAlignmentMatrix;
 
 //Visual size and offset
-uniform mediump vec2 offset;
+uniform highp vec2 offset;
 uniform highp vec2 size;
 uniform mediump vec4 offsetSizeMode;
 uniform mediump vec2 origin;
 uniform mediump vec2 anchorPoint;
 #ifdef IS_REQUIRED_BORDERLINE
-uniform mediump float borderlineWidth;
-uniform mediump float borderlineOffset;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
 #endif
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 uniform highp vec4 cornerRadius;
@@ -30,8 +30,8 @@ uniform mediump float cornerRadiusPolicy;
 
 vec4 ComputeVertexPosition()
 {
-  vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
-  vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
+  highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+  highp vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
 
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
   vRectSize = visualSize * 0.5;
@@ -40,18 +40,18 @@ vec4 ComputeVertexPosition()
 
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 #ifdef IS_REQUIRED_BORDERLINE
-  mediump float minSize = min(visualSize.x, visualSize.y) + (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth;
+  highp float minSize = min(visualSize.x, visualSize.y) + (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth;
 #else
-  mediump float minSize = min(visualSize.x, visualSize.y);
+  highp float minSize = min(visualSize.x, visualSize.y);
 #endif
   vCornerRadius = mix(cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
   vCornerRadius = min(vCornerRadius, minSize * 0.5);
   // Optimize fragment shader. 0.2929 ~= 1.0 - sqrt(0.5)
-  mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+  highp float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
   vOptRectSize -= 0.2929 * maxRadius + 1.0;
 #endif
 
-  mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+  highp vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
 #ifdef IS_REQUIRED_BORDERLINE
   vPosition = aPosition * (visualSize + (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth);
   vertexPosition.xy *= (1.0 + (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth / visualSize);
@@ -59,7 +59,7 @@ vec4 ComputeVertexPosition()
 #elif defined(IS_REQUIRED_ROUNDED_CORNER)
   vPosition = aPosition * visualSize;
 #else
-  mediump vec2 vPosition = aPosition * visualSize;
+  highp vec2 vPosition = aPosition * visualSize;
 #endif
 
 #ifdef USER_SPACE
index cd5aefc..d8b47e6 100644 (file)
@@ -1,10 +1,10 @@
 INPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-INPUT mediump vec2 vPosition;
-INPUT mediump vec2 vRectSize;
-INPUT mediump vec2 vOptRectSize;
+INPUT highp vec2 vPosition;
+INPUT highp vec2 vRectSize;
+INPUT highp vec2 vOptRectSize;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-INPUT mediump vec4 vCornerRadius;
+INPUT highp vec4 vCornerRadius;
 #endif
 #endif
 
@@ -31,8 +31,8 @@ uniform lowp vec4 uColor;
 uniform lowp vec3 mixColor;
 uniform lowp float preMultipliedAlpha;
 #ifdef IS_REQUIRED_BORDERLINE
-uniform mediump float borderlineWidth;
-uniform mediump float borderlineOffset;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
 uniform lowp vec4 borderlineColor;
 uniform lowp vec4 uActorColor;
 #endif
@@ -53,23 +53,23 @@ mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp
 // Global values both rounded corner and borderline use
 
 // radius of rounded corner on this quadrant
-mediump float gRadius = 0.0;
+highp float gRadius = 0.0;
 
 // fragment coordinate. NOTE : vec2(0.0, 0.0) is vRectSize, the corner of visual
-mediump vec2 gFragmentPosition = vec2(0.0, 0.0);
+highp vec2 gFragmentPosition = vec2(0.0, 0.0);
 // center coordinate of rounded corner circle. vec2(gCenterPosition, gCenterPosition).
-mediump float gCenterPosition = 0.0;
+highp float gCenterPosition = 0.0;
 // relative coordinate of gFragmentPosition from gCenterPosition.
-mediump vec2 gDiff = vec2(0.0, 0.0);
+highp vec2 gDiff = vec2(0.0, 0.0);
 // potential value what our algorithm use.
-mediump float gPotential = 0.0;
+highp float gPotential = 0.0;
 
 // threshold of potential
-mediump float gPotentialRange = 0.0;
-mediump float gMaxOutlinePotential = 0.0;
-mediump float gMinOutlinePotential = 0.0;
-mediump float gMaxInlinePotential = 0.0;
-mediump float gMinInlinePotential = 0.0;
+highp float gPotentialRange = 0.0;
+highp float gMaxOutlinePotential = 0.0;
+highp float gMinOutlinePotential = 0.0;
+highp float gMaxInlinePotential = 0.0;
+highp float gMinInlinePotential = 0.0;
 
 void calculateCornerRadius()
 {
@@ -132,7 +132,7 @@ void PreprocessPotential()
 #ifdef IS_REQUIRED_BORDERLINE
 lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
 {
-  mediump float potential = gPotential;
+  highp float potential = gPotential;
 
   // default opacity of borderline is 0.0
   mediump float borderlineOpacity = 0.0;
@@ -156,9 +156,9 @@ lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
   // But if borderlineOpacity > 0.0 and borderlineColor.a == 0.0, we need to apply tCornerRadius.
   if(borderlineOpacity > 0.0 && borderlineColor.a * borderlineOpacity < 1.0)
   {
-    mediump float tCornerRadius = -gCenterPosition + gPotentialRange;
-    mediump float MaxTexturelinePotential = tCornerRadius + gPotentialRange;
-    mediump float MinTexturelinePotential = tCornerRadius - gPotentialRange;
+    highp float tCornerRadius = -gCenterPosition + gPotentialRange;
+    highp float MaxTexturelinePotential = tCornerRadius + gPotentialRange;
+    highp float MinTexturelinePotential = tCornerRadius - gPotentialRange;
     if(potential > MaxTexturelinePotential)
     {
       // potential is out of texture range.
@@ -195,7 +195,7 @@ lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 mediump float calculateCornerOpacity()
 {
-  mediump float potential = gPotential;
+  highp float potential = gPotential;
 
   // default opacity is 1.0
   mediump float opacity = 1.0;
index a1243ec..4548c06 100644 (file)
@@ -1,27 +1,27 @@
 INPUT mediump vec2 aPosition;
 OUTPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-OUTPUT mediump vec2 vPosition;
-OUTPUT mediump vec2 vRectSize;
-OUTPUT mediump vec2 vOptRectSize;
+OUTPUT highp vec2 vPosition;
+OUTPUT highp vec2 vRectSize;
+OUTPUT highp vec2 vOptRectSize;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-OUTPUT mediump vec4 vCornerRadius;
+OUTPUT highp vec4 vCornerRadius;
 #endif
 #endif
 
 uniform highp mat4 uMvpMatrix;
 uniform highp vec3 uSize;
-uniform mediump vec4 pixelArea;
+uniform highp vec4 pixelArea;
 
 //Visual size and offset
-uniform mediump vec2 offset;
+uniform highp vec2 offset;
 uniform highp vec2 size;
 uniform mediump vec4 offsetSizeMode;
 uniform mediump vec2 origin;
 uniform mediump vec2 anchorPoint;
 #ifdef IS_REQUIRED_BORDERLINE
-uniform mediump float borderlineWidth;
-uniform mediump float borderlineOffset;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
 #endif
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 uniform highp vec4 cornerRadius;
@@ -32,12 +32,12 @@ OUTPUT  mediump vec2  vMaskTexCoord;
 uniform lowp    float cropToMask;
 uniform mediump vec2  maskTextureRatio;
 #endif
-uniform mediump vec2 extraSize;
+uniform highp vec2 extraSize;
 
 vec4 ComputeVertexPosition()
 {
-  vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw) + extraSize;
-  vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
+  highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw) + extraSize;
+  highp vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
 
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
   vRectSize = visualSize * 0.5;
@@ -46,19 +46,19 @@ vec4 ComputeVertexPosition()
 
 #ifdef IS_REQUIRED_BORDERLINE
   // Extend size of visual by borderline.
-  mediump float outerBorderlineSize = (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth;
+  highp float outerBorderlineSize = (1.0 + clamp(borderlineOffset, -1.0, 1.0)) * borderlineWidth;
 #endif
 
 #ifdef IS_REQUIRED_ROUNDED_CORNER
 #ifdef IS_REQUIRED_BORDERLINE
-  mediump float minSize = min(visualSize.x, visualSize.y) + outerBorderlineSize;
+  highp float minSize = min(visualSize.x, visualSize.y) + outerBorderlineSize;
 #else
-  mediump float minSize = min(visualSize.x, visualSize.y);
+  highp float minSize = min(visualSize.x, visualSize.y);
 #endif
   vCornerRadius = mix(cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
   vCornerRadius = min(vCornerRadius, minSize * 0.5);
   // Optimize fragment shader. 0.2929 ~= 1.0 - sqrt(0.5)
-  mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+  highp float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
   vOptRectSize -= 0.2929 * maxRadius + 1.0;
 #endif
 
@@ -68,10 +68,10 @@ vec4 ComputeVertexPosition()
 #elif defined(IS_REQUIRED_ROUNDED_CORNER)
   vPosition = aPosition * visualSize;
 #else
-  mediump vec2 vPosition = aPosition * visualSize;
+  highp vec2 vPosition = aPosition * visualSize;
 #endif
 
-  vec4 finalPixelArea = pixelArea;
+  highp vec4 finalPixelArea = pixelArea;
 #ifdef IS_REQUIRED_ALPHA_MASKING
   finalPixelArea = mix(pixelArea,
                        vec4(