Let we make texture coordinates and relative shader codes use highp instead of mediump.
It will reduce visual defect for high-resolution UI system
Change-Id: I2c326c90cf98ff0496aeb294825bf72c519821e2
Signed-off-by: Eunki Hong <eunkiki.hong@samsung.com>
// [4] \"An Inexpensive BRDF Model for Physically based Rendering\" by Christophe Schlick
// https://www.cs.virginia.edu/~jdl/bib/appearance/analytic%20models/schlick94b.pdf
-#ifdef HIGHP
precision highp float;
-#else
-precision mediump float;
-#endif
#ifdef GLTF_CHANNELS
#define METALLIC b
// For Light (Currently Directional Only)
#define MAX_LIGHTS 5
uniform mediump int uLightCount;
-uniform mediump vec3 uLightDirection[MAX_LIGHTS];
-uniform mediump vec3 uLightColor[MAX_LIGHTS];
+uniform highp vec3 uLightDirection[MAX_LIGHTS];
+uniform highp vec3 uLightColor[MAX_LIGHTS];
// For Shadow Map
uniform lowp int uIsShadowEnabled;
uniform lowp float uAlphaThreshold;
// TODO: Multiple texture coordinate will be supported.
-INPUT mediump vec2 vUV;
-INPUT lowp mat3 vTBN;
-INPUT lowp vec4 vColor;
+INPUT highp vec2 vUV;
+INPUT highp mat3 vTBN;
+INPUT highp vec4 vColor;
INPUT highp vec3 vPositionToCamera;
const float c_MinRoughness = 0.04;
#ifdef THREE_TEX
// The albedo may be defined from a base texture or a flat color
#ifdef BASECOLOR_TEX
- mediump vec2 baseColorTexCoords = mix(vUV, computeTextureTransform(vUV, uBaseColorTextureTransform), uBaseColorTextureTransformAvailable);
+ highp vec2 baseColorTexCoords = mix(vUV, computeTextureTransform(vUV, uBaseColorTextureTransform), uBaseColorTextureTransformAvailable);
lowp vec4 baseColor = TEXTURE(sAlbedoAlpha, baseColorTexCoords);
baseColor = vColor * vec4(linear(baseColor.rgb), baseColor.w) * uColorFactor;
#else // BASECOLOR_TEX
#endif // BASECOLOR_TEX
#ifdef METALLIC_ROUGHNESS_TEX
- mediump vec2 metalRoughnessTexCoords = mix(vUV, computeTextureTransform(vUV, uMetalRoughnessTextureTransform), uMetalRoughnessTextureTransformAvailable);
+ highp vec2 metalRoughnessTexCoords = mix(vUV, computeTextureTransform(vUV, uMetalRoughnessTextureTransform), uMetalRoughnessTextureTransformAvailable);
lowp vec4 metrou = TEXTURE(sMetalRoughness, metalRoughnessTexCoords);
metallic = metrou.METALLIC * metallic;
perceptualRoughness = metrou.ROUGHNESS * perceptualRoughness;
#endif // METALLIC_ROUGHNESS_TEX
#ifdef NORMAL_TEX
- mediump vec2 normalTexCoords = mix(vUV, computeTextureTransform(vUV, uNormalTextureTransform), uNormalTextureTransformAvailable);
+ highp vec2 normalTexCoords = mix(vUV, computeTextureTransform(vUV, uNormalTextureTransform), uNormalTextureTransformAvailable);
n = TEXTURE(sNormal, normalTexCoords).rgb;
n = normalize(vTBN * ((2.0 * n - 1.0) * vec3(uNormalScale, uNormalScale, 1.0)));
#endif // NORMAL_TEX
#else // THREE_TEX
- mediump vec2 baseColorTexCoords = mix(vUV, computeTextureTransform(vUV, uBaseColorTextureTransform), uBaseColorTextureTransformAvailable);
+ highp vec2 baseColorTexCoords = mix(vUV, computeTextureTransform(vUV, uBaseColorTextureTransform), uBaseColorTextureTransformAvailable);
vec4 albedoMetal = TEXTURE(sAlbedoMetal, baseColorTexCoords);
lowp vec4 baseColor = vec4(linear(albedoMetal.rgb), 1.0) * vColor * uColorFactor;
metallic = albedoMetal.METALLIC * metallic;
- mediump vec2 normalRoughnessTexCoords = mix(vUV, computeTextureTransform(vUV, uNormalRoughnessTextureTransform), uNormalRoughnessTextureTransformAvailable);
+ highp vec2 normalRoughnessTexCoords = mix(vUV, computeTextureTransform(vUV, uNormalRoughnessTextureTransform), uNormalRoughnessTextureTransformAvailable);
vec4 normalRoughness = TEXTURE(sNormalRoughness, normalRoughnessTexCoords);
perceptualRoughness = normalRoughness.ROUGHNESS * perceptualRoughness;
f0 = min(f0 * uSpecularColorFactor * materialSpecularTexture.rgb, vec3(1.0));
f0 = mix(f0, baseColor.rgb, metallic);
- mediump vec3 v = normalize(vPositionToCamera); // Vector from surface point to camera
- mediump float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
- mediump vec3 reflection = -normalize(reflect(v, n));
+ highp vec3 v = normalize(vPositionToCamera); // Vector from surface point to camera
+ highp float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+ highp vec3 reflection = -normalize(reflect(v, n));
lowp vec3 brdf = TEXTURE(sbrdfLUT, vec2(NdotV, 1.0 - perceptualRoughness)).rgb;
vec3 Fr = max(vec3(1.0 - perceptualRoughness), f0) - f0;
vec3 k_S = f0 + Fr * pow(1.0 - NdotV, 5.0);
if(float(uIsShadowReceiving) * float(uIsShadowEnabled) * uShadowIntensity > 0.0)
{
- mediump float exposureFactor = 0.0;
+ highp float exposureFactor = 0.0;
highp vec3 l = normalize(-uLightDirection[uShadowLightIndex]);
highp float NdotL = dot(n, l);
#else
ivec2 texSize = textureSize(sShadowMap, 0);
#endif
- mediump vec2 texelSize = vec2(1.0) / vec2(texSize.x, texSize.y);
- mediump vec2 pcfSample = vec2(1.0, 0.0);
+ highp vec2 texelSize = vec2(1.0) / vec2(texSize.x, texSize.y);
+ highp vec2 pcfSample = vec2(1.0, 0.0);
for (int i = 0; i < kPcfSampleCount; ++i)
{
pcfSample = vec2(kCosPcfTheta * pcfSample.x - kSinPcfTheta * pcfSample.y,
{
if(NdotL > 0.0)
{
- mediump float depthValue = TEXTURE(sShadowMap, positionFromLightView.xy).r;
+ highp float depthValue = TEXTURE(sShadowMap, positionFromLightView.xy).r;
exposureFactor = (depthValue < positionFromLightView.z - uShadowBias) ? 0.0 : 1.0;
}
}
}
#ifdef OCCLUSION
- mediump vec2 occlusionTexCoords = mix(vUV, computeTextureTransform(vUV, uOcclusionTextureTransform), uOcclusionTextureTransformAvailable);
+ highp vec2 occlusionTexCoords = mix(vUV, computeTextureTransform(vUV, uOcclusionTextureTransform), uOcclusionTextureTransformAvailable);
lowp float ao = TEXTURE(sOcclusion, occlusionTexCoords).r;
color = mix(color, color * ao, uOcclusionStrength);
#endif // OCCLUSION
#ifdef EMISSIVE_TEXTURE
- mediump vec2 emissiveTexCoords = mix(vUV, computeTextureTransform(vUV, uEmissiveTextureTransform), uEmissiveTextureTransformAvailable);
+ highp vec2 emissiveTexCoords = mix(vUV, computeTextureTransform(vUV, uEmissiveTextureTransform), uEmissiveTextureTransformAvailable);
lowp vec3 emissive = linear(TEXTURE(sEmissive, emissiveTexCoords).rgb) * uEmissiveFactor;
#else
lowp vec3 emissive = uEmissiveFactor;
#endif
#endif
-OUTPUT mediump vec2 vUV;
+OUTPUT highp vec2 vUV;
OUTPUT highp mat3 vTBN;
-OUTPUT lowp vec4 vColor;
+OUTPUT highp vec4 vColor;
OUTPUT highp vec3 vPositionToCamera;
uniform highp mat4 uViewMatrix;
-precision mediump float;
+precision highp float;
uniform lowp vec4 uColor;
FLAT INPUT float vColor;
-precision mediump float;
+precision highp float;
uniform mat4 uMvpMatrix;
INPUT vec3 aPosition;
INPUT float aColor;
uniform lowp float uMask;
uniform lowp float uAlphaThreshold;
-INPUT mediump vec2 vUV;
-INPUT lowp vec4 vColor;
+INPUT highp vec2 vUV;
+INPUT highp vec4 vColor;
//INPUT highp float depth;
//OUTPUT highp vec4 FragColor;
#endif
#endif
-OUTPUT mediump vec2 vUV;
-OUTPUT lowp vec4 vColor;
+OUTPUT highp vec2 vUV;
+OUTPUT highp vec4 vColor;
uniform highp mat4 uViewMatrix;
uniform highp mat4 uModelMatrix;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
-precision mediump float;
+precision highp float;
-uniform mediump vec4 start_color;
-uniform mediump vec4 end_color;
-uniform mediump float gradient_offset;
+uniform highp vec4 start_color;
+uniform highp vec4 end_color;
+uniform highp float gradient_offset;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vStart;
-varying mediump vec2 vEnd;
+varying highp vec2 vTexCoord;
+varying highp vec2 vStart;
+varying highp vec2 vEnd;
float get_position(vec2 x, vec2 s, vec2 e)
{
-attribute mediump vec2 aPosition;
+precision highp float;
+
+attribute highp vec2 aPosition;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
-uniform mediump vec2 start_point;
-uniform mediump vec2 end_point;
-uniform mediump vec2 rotate_center;
-uniform mediump float rotate_angle;
+uniform highp vec2 start_point;
+uniform highp vec2 end_point;
+uniform highp vec2 rotate_center;
+uniform highp float rotate_angle;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vStart;
-varying mediump vec2 vEnd;
+varying highp vec2 vTexCoord;
+varying highp vec2 vStart;
+varying highp vec2 vEnd;
vec2 rotate(vec2 x, vec2 c, float a)
{
}
//Visual size and offset
-uniform mediump vec2 offset;
+uniform highp vec2 offset;
uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
-INPUT mediump vec2 vPosition;
+precision highp float;
+
+INPUT highp vec2 vPosition;
uniform lowp vec4 uColor;
-uniform mediump float thickness;
-uniform mediump float radius;
-uniform mediump float startAngle;
-uniform mediump float sweepAngle;
+uniform highp float thickness;
+uniform highp float radius;
+uniform highp float startAngle;
+uniform highp float sweepAngle;
-const mediump float M_PI_OVER_2 = 1.57079632679;
-const mediump float M_PI = 3.14159265359;
-const mediump float M_PI_2 = 6.28318530718;
+const highp float M_PI_OVER_2 = 1.57079632679;
+const highp float M_PI = 3.14159265359;
+const highp float M_PI_2 = 6.28318530718;
mediump float GetOpacity()
{
- mediump float start = radians( mod( startAngle, 360.0 ) );
- mediump float angle = mod( atan( vPosition.y, vPosition.x ) + M_PI_OVER_2 - start, M_PI_2 );
- mediump float dist = length( vPosition );
+ highp float start = radians( mod( startAngle, 360.0 ) );
+ highp float angle = mod( atan( vPosition.y, vPosition.x ) + M_PI_OVER_2 - start, M_PI_2 );
+ highp float dist = length( vPosition );
if( angle <= radians( sweepAngle ) )
{
return smoothstep( -1.0, 1.0, thickness / 2.0 - ( abs( dist - radius ) ) );
}
- mediump float end = radians( mod( startAngle + sweepAngle, 360.0 ) );
- mediump vec2 q0 = vec2( dist * cos( start - M_PI_OVER_2 ), dist * sin( start - M_PI_OVER_2 ) );
- mediump vec2 q1 = vec2( dist * cos( end - M_PI_OVER_2 ), dist * sin( end - M_PI_OVER_2 ) );
+ highp float end = radians( mod( startAngle + sweepAngle, 360.0 ) );
+ highp vec2 q0 = vec2( dist * cos( start - M_PI_OVER_2 ), dist * sin( start - M_PI_OVER_2 ) );
+ highp vec2 q1 = vec2( dist * cos( end - M_PI_OVER_2 ), dist * sin( end - M_PI_OVER_2 ) );
+
mediump float opacity = 1.0 - smoothstep( 0.0, 2.0, min( length( vPosition - q0 ), length( vPosition - q1 ) ) );
opacity *= step( 0.0, thickness / 2.0 - abs( dist - radius ) );
return opacity;
-INPUT mediump vec2 vPosition;
+INPUT highp vec2 vPosition;
uniform lowp vec4 uColor;
-uniform mediump float thickness;
-uniform mediump float radius;
-uniform mediump float startAngle;
-uniform mediump float sweepAngle;
+uniform highp float thickness;
+uniform highp float radius;
+uniform highp float startAngle;
+uniform highp float sweepAngle;
-const mediump float M_PI_OVER_2 = 1.57079632679;
-const mediump float M_PI_2 = 6.28318530718;
+const highp float M_PI_OVER_2 = 1.57079632679;
+const highp float M_PI_2 = 6.28318530718;
mediump float GetOpacity()
{
- mediump float start = radians( mod( startAngle, 360.0 ) );
- mediump float angle = mod( atan( vPosition.y, vPosition.x ) + M_PI_OVER_2 - start, M_PI_2 );
- mediump float dist = length( vPosition );
+ highp float start = radians( mod( startAngle, 360.0 ) );
+ highp float angle = mod( atan( vPosition.y, vPosition.x ) + M_PI_OVER_2 - start, M_PI_2 );
+ highp float dist = length( vPosition );
if( angle <= radians( sweepAngle ) )
{
return smoothstep( -1.0, 1.0, thickness / 2.0 - ( abs( dist - radius ) ) );
}
- mediump float end = radians( mod( startAngle + sweepAngle, 360.0 ) );
- mediump vec2 q0 = vec2( radius * cos( start - M_PI_OVER_2 ), radius * sin( start - M_PI_OVER_2 ) );
- mediump vec2 q1 = vec2( radius * cos( end - M_PI_OVER_2 ), radius * sin( end - M_PI_OVER_2 ) );
+ highp float end = radians( mod( startAngle + sweepAngle, 360.0 ) );
+ highp vec2 q0 = vec2( radius * cos( start - M_PI_OVER_2 ), radius * sin( start - M_PI_OVER_2 ) );
+ highp vec2 q1 = vec2( radius * cos( end - M_PI_OVER_2 ), radius * sin( end - M_PI_OVER_2 ) );
return smoothstep( -1.0, 1.0, thickness / 2.0 - min( length( vPosition - q0 ), length( vPosition - q1 ) ) );
}
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vPosition;
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;
-precision mediump float;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform sampler2D sEffect;
uniform lowp vec4 uColor;
-uniform float uBloomIntensity;
-uniform float uImageIntensity;
-uniform float uBloomSaturation;
-uniform float uImageSaturation;
+uniform highp float uBloomIntensity;
+uniform highp float uImageIntensity;
+uniform highp float uBloomSaturation;
+uniform highp float uImageSaturation;
vec4 ChangeSaturation(vec4 col, float sat)
{
void main()
{
- mediump vec4 image;
- mediump vec4 bloom;
+ highp vec4 image;
+ highp vec4 bloom;
image = texture2D(sTexture, vTexCoord);
bloom = texture2D(sEffect, vTexCoord);
image = ChangeSaturation(image, uImageSaturation) * uImageIntensity;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
-uniform mediump float uBloomThreshold;
-uniform mediump float uRecipOneMinusBloomThreshold;
+uniform highp float uBloomThreshold;
+uniform highp float uRecipOneMinusBloomThreshold;
void main()
{
- mediump vec4 col;
+ highp vec4 col;
col = texture2D(sTexture, vTexCoord);
col = (col - uBloomThreshold) * uRecipOneMinusBloomThreshold; // remove intensities lower than the thresold and remap intensities above the threshold to [0..1]
gl_FragColor = clamp(col, 0.0, 1.0);
+precision highp float;
varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform highp vec2 uSampleOffsets[NUM_SAMPLES];
uniform float uBlurStrength;
uniform sampler2D sTexture;
uniform sampler2D sEffect;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
void main()
{
precision highp float;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform vec2 uSampleOffsets[NUM_SAMPLES];
uniform float uSampleWeights[NUM_SAMPLES];
-INPUT mediump float vAlpha;
+precision highp float;
+INPUT highp float vAlpha;
uniform lowp vec4 uColor;
uniform lowp vec4 borderColor;
-uniform mediump float borderSize;
+uniform highp float borderSize;
void main()
{
-INPUT mediump vec2 aPosition;
-INPUT mediump vec2 aDrift;
-OUTPUT mediump float vAlpha;
+precision highp float;
+INPUT highp vec2 aPosition;
+INPUT highp vec2 aDrift;
+OUTPUT highp float vAlpha;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
-uniform mediump float borderSize;
+uniform highp float borderSize;
void main()
{
- vec2 position = aPosition*(uSize.xy+vec2(0.75)) + aDrift*(borderSize+1.5);
+ highp vec2 position = aPosition*(uSize.xy+vec2(0.75)) + aDrift*(borderSize+1.5);
gl_Position = uMvpMatrix * vec4(position, 0.0, 1.0);
vAlpha = min( abs(aDrift.x), abs(aDrift.y) )*(borderSize+1.5);
}
\ No newline at end of file
+precision highp float;
uniform lowp vec4 uColor;
uniform lowp vec4 borderColor;
-INPUT mediump vec2 aPosition;
-INPUT mediump vec2 aDrift;
+precision highp float;
+INPUT highp vec2 aPosition;
+INPUT highp vec2 aDrift;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
-uniform mediump float borderSize;
+uniform highp float borderSize;
//Visual size and offset
-uniform mediump vec2 offset;
+uniform highp vec2 offset;
uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
vec2 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);
return (aPosition + anchorPoint)*visualSize + visualOffset + origin * uSize.xy;
}
void main()
{
- vec2 position = ComputeVertexPosition() + aDrift*borderSize;
+ highp vec2 position = ComputeVertexPosition() + aDrift*borderSize;
gl_Position = uMvpMatrix * vec4(position, 0.0, 1.0);
}
\ No newline at end of file
+precision highp float;
// Use the actor color to paint every layer
uniform lowp vec4 uColor;
+precision highp float;
// Modify the vertex position according to the bounce coefficient
-attribute mediump vec3 aPosition1;
-attribute mediump vec3 aPosition2;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump float uBounceCoefficient;
+attribute highp vec3 aPosition1;
+attribute highp vec3 aPosition2;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+uniform highp float uBounceCoefficient;
void main()
{
precision highp float;
uniform vec3 uHSVDelta;
uniform float uIgnoreAlpha;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
float rand(vec2 co)
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform lowp vec4 uColor;
uniform sampler2D sBackground;
uniform sampler2D sBubbleShape;
-varying mediump float vPercentage;
-varying mediump vec2 vEffectTexCoord;
+varying highp float vPercentage;
+varying highp vec2 vEffectTexCoord;
void main()
{
-attribute mediump float aIndex;
-attribute mediump vec2 aPosition;
+precision highp float;
+attribute highp float aIndex;
+attribute highp vec2 aPosition;
attribute highp vec2 aTexCoord;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
+varying highp vec2 vTexCoord;
+uniform highp mat4 uMvpMatrix;
// the gravity applied to the y direction
-uniform mediump float uGravity;
+uniform highp float uGravity;
// xy: the emit position of the bubble; zw: the destination of the bubble.
// The bubble is moving from (xy) to (zw plus the y drop influenced by gravity).
uniform vec4 uStartEndPosition[NUMBER_OF_BUBBLE];
precision highp float;
uniform vec3 uHSVDelta;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
float rand(vec2 co)
-attribute mediump vec2 aPosition;
-attribute mediump vec2 aTexCoord;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-varying mediump vec2 vTexCoord;
+precision highp float;
+attribute highp vec2 aPosition;
+attribute highp vec2 aTexCoord;
+uniform highp vec3 uSize;
+uniform highp mat4 uMvpMatrix;
+varying highp vec2 vTexCoord;
void main()
{
+precision highp float;
uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
void main()
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
+precision highp float;
+attribute highp vec2 aPosition;
+varying highp vec2 vTexCoord;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
+precision highp float;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
INPUT highp vec2 vPosition;
FLAT INPUT highp vec2 vRectSize;
borderlineOpacity *= min(1.0, borderlineWidth / gPotentialRange);
}
- lowp vec3 borderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
- lowp float borderlineColorAlpha = borderlineColor.a * uActorColor.a;
+ highp vec3 borderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
+ highp float borderlineColorAlpha = borderlineColor.a * uActorColor.a;
// NOTE : color-visual is always preMultiplied.
borderlineColorRGB *= borderlineColorAlpha;
else
{
// potential is in texture range.
- lowp float textureAlphaScale = mix(1.0, 0.0, smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
+ highp float textureAlphaScale = mix(1.0, 0.0, smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
textureColor.a *= textureAlphaScale;
textureColor.rgb *= textureAlphaScale;
}
// If premultipliedAlpha == 1.0, just return vec4(rgb*alpha, alpha)
// Else, return vec4((rgb*alpha) / alpha, alpha)
- lowp float finalAlpha = mix(textureColor.a, 1.0, borderlineColorAlpha);
- lowp vec3 finalMultipliedRGB = borderlineColorRGB + (1.0 - borderlineColorAlpha) * textureColor.rgb;
+ highp float finalAlpha = mix(textureColor.a, 1.0, borderlineColorAlpha);
+ highp vec3 finalMultipliedRGB = borderlineColorRGB + (1.0 - borderlineColorAlpha) * textureColor.rgb;
return vec4(finalMultipliedRGB, finalAlpha);
}
return mix(textureColor, vec4(borderlineColorRGB, borderlineColorAlpha), borderlineOpacity);
-INPUT mediump vec2 aPosition;
+precision highp float;
+INPUT highp vec2 aPosition;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
OUTPUT highp vec2 vPosition;
FLAT OUTPUT highp vec2 vRectSize;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
uniform lowp vec4 uSamplerRect;
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump vec4 uTextureRect;
+precision highp float;
+attribute highp vec2 aPosition;
+varying highp vec2 vTexCoord;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+uniform highp vec4 uTextureRect;
void main()
{
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ highp vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
vertexPosition.xyz *= uSize;
vertexPosition = uMvpMatrix * vertexPosition;
+precision highp float;
varying float vPercentage;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
-attribute mediump vec2 aPosition;
+precision highp float;
+attribute highp vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
+uniform highp mat4 uMvpMatrix;
uniform vec3 uSize;
uniform vec4 uTextureRect;
void main()
{
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ highp vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
vertexPosition.xyz *= uSize;
vertexPosition = uMvpMatrix * vertexPosition;
gl_Position = vertexPosition;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
-uniform mediump float uGlowBoundary;
-uniform mediump vec2 uOutlineParams;
+uniform highp float uGlowBoundary;
+uniform highp vec2 uOutlineParams;
uniform lowp vec4 uOutlineColor;
uniform lowp vec4 uShadowColor;
-uniform mediump vec2 uShadowOffset;
+uniform highp vec2 uShadowOffset;
uniform lowp vec4 uGlowColor;
uniform lowp float uDoOutline;
uniform lowp float uDoShadow;
void main()
{
// sample distance field
- mediump float smoothing = 0.5;
+ highp float smoothing = 0.5;
- mediump float distance = texture2D(sTexture, vTexCoord).a;
- mediump float smoothWidth = fwidth(distance);
- mediump float alphaFactor = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);
+ highp float distance = texture2D(sTexture, vTexCoord).a;
+ highp float smoothWidth = fwidth(distance);
+ highp float alphaFactor = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);
lowp vec4 color;
if (uDoShadow == 0.0)
{
- mediump float alpha = uColor.a * alphaFactor;
+ highp float alpha = uColor.a * alphaFactor;
lowp vec4 rgb = uColor;
if (uDoOutline > 0.0)
{
- mediump float outlineWidth = uOutlineParams[1] + smoothWidth;
- mediump float outlineBlend = smoothstep(uOutlineParams[0] - outlineWidth, uOutlineParams[0] + outlineWidth, distance);
+ highp float outlineWidth = uOutlineParams[1] + smoothWidth;
+ highp float outlineBlend = smoothstep(uOutlineParams[0] - outlineWidth, uOutlineParams[0] + outlineWidth, distance);
alpha = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);
rgb = mix(uOutlineColor, uColor, outlineBlend);
}
else // (uDoShadow > 0.0)
{
- mediump float shadowDistance = texture2D(sTexture, vTexCoord - uShadowOffset).a;
- mediump float inText = alphaFactor;
- mediump float inShadow = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, shadowDistance);
+ highp float shadowDistance = texture2D(sTexture, vTexCoord - uShadowOffset).a;
+ highp float inText = alphaFactor;
+ highp float inShadow = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, shadowDistance);
// inside object, outside shadow
if (inText == 1.0)
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 effectColor;
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump vec3 effectOffset;
+precision highp float;
+attribute highp vec2 aPosition;
+varying highp vec2 vTexCoord;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+uniform highp vec3 effectOffset;
void main()
{
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ highp vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
vertexPosition.xyz *= uSize;
vertexPosition.xyz += effectOffset;
vertexPosition = uMvpMatrix * vertexPosition;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uEffectColor;
precision highp float;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform vec2 uTexScale;
uniform vec3 uCoefficient;
+precision highp float;
varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform highp vec2 uSampleOffsets[NUM_SAMPLES];
+precision highp float;
uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform samplerExternalOES sTexture;
void main()
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-varying mediump vec2 vTexCoord;
+precision highp float;
+attribute highp vec2 aPosition;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+varying highp vec2 vTexCoord;
void main()
{
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+INPUT highp vec2 vTexCoord;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
INPUT highp vec2 vPosition;
FLAT INPUT highp vec2 vRectSize;
#endif
// scale factor to fit start and end position of gradient.
-uniform mediump float uTextureCoordinateScaleFactor;
+uniform highp float uTextureCoordinateScaleFactor;
uniform sampler2D sTexture; // sampler1D?
uniform lowp vec4 uColor;
borderlineOpacity *= min(1.0, borderlineWidth / gPotentialRange);
}
- lowp vec3 borderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
- lowp float borderlineColorAlpha = borderlineColor.a * uActorColor.a;
+ highp vec3 borderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
+ highp float borderlineColorAlpha = borderlineColor.a * uActorColor.a;
// NOTE : gradient-visual is always preMultiplied.
borderlineColorRGB *= borderlineColorAlpha;
else
{
// potential is in texture range.
- lowp float textureAlphaScale = mix(1.0, 0.0, smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
+ highp float textureAlphaScale = mix(1.0, 0.0, smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
textureColor.a *= textureAlphaScale;
textureColor.rgb *= textureAlphaScale;
}
// If premultipliedAlpha == 1.0, just return vec4(rgb*alpha, alpha)
// Else, return vec4((rgb*alpha) / alpha, alpha)
- lowp float finalAlpha = mix(textureColor.a, 1.0, borderlineColorAlpha);
- lowp vec3 finalMultipliedRGB = borderlineColorRGB + (1.0 - borderlineColorAlpha) * textureColor.rgb;
+ highp float finalAlpha = mix(textureColor.a, 1.0, borderlineColorAlpha);
+ highp vec3 finalMultipliedRGB = borderlineColorRGB + (1.0 - borderlineColorAlpha) * textureColor.rgb;
return vec4(finalMultipliedRGB, finalAlpha);
}
return mix(textureColor, vec4(borderlineColorRGB, borderlineColorAlpha), borderlineOpacity);
void main()
{
#ifdef RADIAL
- mediump float radialTexCoord = ((length(vTexCoord) - 0.5) * uTextureCoordinateScaleFactor) + 0.5;
+ highp float radialTexCoord = ((length(vTexCoord) - 0.5) * uTextureCoordinateScaleFactor) + 0.5;
lowp vec4 textureColor = TEXTURE(sTexture, vec2(radialTexCoord, 0.5)) * uColor;
#else
lowp vec4 textureColor = TEXTURE(sTexture, vec2(vTexCoord.y, 0.5)) * uColor;
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
OUTPUT highp vec2 vPosition;
FLAT OUTPUT highp vec2 vRectSize;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
-uniform mediump mat3 uAlignmentMatrix;
+uniform highp mat3 uAlignmentMatrix;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
// Be used when we calculate anti-alias range near 1 pixel.
-attribute mediump vec2 aPosition;
+precision highp float;
+attribute highp vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
+uniform highp mat4 uMvpMatrix;
uniform vec3 uSize;
uniform vec4 uTextureRect;
varying vec2 vTexCoord;
-uniform mediump vec2 uTopLeft;
-uniform mediump vec2 uBottomRight;
+uniform highp vec2 uTopLeft;
+uniform highp vec2 uBottomRight;
void main()
{
- mediump vec4 position = vec4(aPosition, 0.0, 1.0);
+ highp vec4 position = vec4(aPosition, 0.0, 1.0);
position.xyz *= uSize;
gl_Position = uMvpMatrix * position;
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+INPUT highp vec2 vTexCoord;
#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
INPUT highp vec2 vPosition;
FLAT INPUT highp vec2 vRectSize;
#ifdef IS_REQUIRED_ALPHA_MASKING
uniform sampler2D sMaskTexture;
uniform lowp float uYFlipMaskTexture;
-INPUT mediump vec2 vMaskTexCoord;
+INPUT highp vec2 vMaskTexCoord;
#endif
#ifdef ATLAS_DEFAULT_WARP
-uniform mediump vec4 uAtlasRect;
+uniform highp vec4 uAtlasRect;
#elif defined(ATLAS_CUSTOM_WARP)
// WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
uniform lowp vec2 wrapMode;
#endif
#ifdef ATLAS_CUSTOM_WARP
-mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )
+highp float wrapCoordinate( highp vec2 range, highp float coordinate, lowp float wrap )
{
- mediump float coord;
+ highp float coord;
if( wrap > 1.5 ) /* REFLECT */
coord = 1.0 - abs(fract(coordinate*0.5)*2.0 - 1.0);
else /* warp is 0 or 1 */
borderlineOpacity *= min(1.0, borderlineWidth / gPotentialRange);
}
- lowp vec3 borderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
- lowp float borderlineColorAlpha = borderlineColor.a * uActorColor.a;
+ highp vec3 borderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
+ highp float borderlineColorAlpha = borderlineColor.a * uActorColor.a;
borderlineColorRGB *= mix(1.0, borderlineColorAlpha, premultipliedAlpha);
// Calculate inside of borderline when alpha is between (0.0 1.0). So we need to apply texture color.
else
{
// potential is in texture range.
- lowp float textureAlphaScale = mix(1.0, 0.0, smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
+ highp float textureAlphaScale = mix(1.0, 0.0, smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
textureColor.a *= textureAlphaScale;
textureColor.rgb *= mix(textureColor.a, textureAlphaScale, premultipliedAlpha);
}
// If premultipliedAlpha == 1.0, just return vec4(rgb*alpha, alpha)
// Else, return vec4((rgb*alpha) / alpha, alpha)
- lowp float finalAlpha = mix(textureColor.a, 1.0, borderlineColorAlpha);
- lowp vec3 finalMultipliedRGB = borderlineColorRGB + (1.0 - borderlineColorAlpha) * textureColor.rgb;
+ highp float finalAlpha = mix(textureColor.a, 1.0, borderlineColorAlpha);
+ highp vec3 finalMultipliedRGB = borderlineColorRGB + (1.0 - borderlineColorAlpha) * textureColor.rgb;
// TODO : Need to find some way without division
return vec4(finalMultipliedRGB * mix(1.0 / finalAlpha, 1.0, premultipliedAlpha), finalAlpha);
}
#endif
#if defined(IS_REQUIRED_YUV_TO_RGB) || defined(IS_REQUIRED_UNIFIED_YUV_AND_RGB)
-lowp vec4 ConvertYuvToRgba(mediump vec2 texCoord)
+lowp vec4 ConvertYuvToRgba(highp vec2 texCoord)
{
#ifdef IS_REQUIRED_UNIFIED_YUV_AND_RGB
// Special case when shader use YUV but actual textures are not YUV format.
}
#endif
- lowp float y = TEXTURE(sTexture, texCoord).r;
- lowp float u = TEXTURE(sTextureU, texCoord).r - 0.5;
- lowp float v = TEXTURE(sTextureV, texCoord).r - 0.5;
- lowp vec4 rgba;
+ highp float y = TEXTURE(sTexture, texCoord).r;
+ highp float u = TEXTURE(sTextureU, texCoord).r - 0.5;
+ highp float v = TEXTURE(sTextureV, texCoord).r - 0.5;
+ highp vec4 rgba;
rgba.r = y + (1.403 * v);
rgba.g = y - (0.344 * u) - (0.714 * v);
rgba.b = y + (1.770 * u);
void main()
{
#ifdef ATLAS_DEFAULT_WARP
- mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );
+ highp vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );
#elif defined(ATLAS_CUSTOM_WARP)
- mediump vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ),
- wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );
+ highp vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ),
+ wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );
#else
- mediump vec2 texCoord = vTexCoord;
+ highp vec2 texCoord = vTexCoord;
#endif
#if defined(IS_REQUIRED_YUV_TO_RGB) || defined(IS_REQUIRED_UNIFIED_YUV_AND_RGB)
#endif
#ifdef IS_REQUIRED_ALPHA_MASKING
- mediump vec2 maskTexCoord = vMaskTexCoord;
+ highp vec2 maskTexCoord = vMaskTexCoord;
maskTexCoord.y = mix(maskTexCoord.y, 1.0-maskTexCoord.y, uYFlipMaskTexture);
mediump float maskAlpha = TEXTURE(sMaskTexture, maskTexCoord).a;
textureColor.a *= maskAlpha;
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
OUTPUT highp vec2 vPosition;
FLAT OUTPUT highp vec2 vRectSize;
uniform mediump float cornerRadiusPolicy;
#endif
#ifdef IS_REQUIRED_ALPHA_MASKING
-OUTPUT mediump vec2 vMaskTexCoord;
-uniform lowp float cropToMask;
-uniform mediump vec2 maskTextureRatio;
+OUTPUT highp vec2 vMaskTexCoord;
+uniform lowp float cropToMask;
+uniform highp vec2 maskTextureRatio;
#endif
uniform highp vec2 extraSize;
-precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
+precision highp float;
+varying highp vec2 vTexCoord;
+varying highp vec3 vLightDirection;
+varying highp vec3 vHalfVector;
uniform sampler2D sDiffuse;
uniform sampler2D sNormal;
uniform sampler2D sGloss;
+precision highp float;
attribute highp vec3 aPosition;
attribute highp vec2 aTexCoord;
attribute highp vec3 aNormal;
attribute highp vec3 aTangent;
attribute highp vec3 aBiNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+varying highp vec2 vTexCoord;
+varying highp vec3 vLightDirection;
+varying highp vec3 vHalfVector;
+uniform highp vec3 uSize;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelView;
+uniform highp mat4 uViewMatrix;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uObjectMatrix;
+uniform highp vec3 lightPosition;
+uniform highp vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
+uniform highp vec2 offset;
+uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
+precision highp float;
+varying highp vec2 vTexCoord;
+varying highp vec3 vIllumination;
+varying highp float vSpecular;
uniform sampler2D sDiffuse;
uniform lowp vec4 uColor;
+precision highp float;
attribute highp vec3 aPosition;
attribute highp vec2 aTexCoord;
attribute highp vec3 aNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+varying highp vec2 vTexCoord;
+varying highp vec3 vIllumination;
+varying highp float vSpecular;
+uniform highp vec3 uSize;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelView;
+uniform highp mat4 uViewMatrix;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uObjectMatrix;
+uniform highp vec3 lightPosition;
+uniform highp vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
+uniform highp vec2 offset;
+uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-precision mediump float;
-varying mediump vec3 vIllumination;
+precision highp float;
+varying highp vec3 vIllumination;
uniform lowp vec4 uColor;
void main()
+precision highp float;
attribute highp vec3 aPosition;
attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+varying highp vec3 vIllumination;
+uniform highp vec3 uSize;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelView;
+uniform highp mat4 uViewMatrix;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uObjectMatrix;
+uniform highp vec3 lightPosition;
+uniform highp vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
+uniform highp vec2 offset;
+uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
+precision highp float;
+varying highp vec2 vTexCoord;
+varying highp vec3 vLightDirection;
+varying highp vec3 vHalfVector;
uniform sampler2D sDiffuse;
uniform sampler2D sNormal;
uniform sampler2D sGloss;
+precision highp float;
attribute highp vec3 aPosition;
attribute highp vec2 aTexCoord;
attribute highp vec3 aNormal;
attribute highp vec3 aTangent;
attribute highp vec3 aBiNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+varying highp vec2 vTexCoord;
+varying highp vec3 vLightDirection;
+varying highp vec3 vHalfVector;
+uniform highp vec3 uSize;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelView;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uObjectMatrix;
+uniform highp vec3 uLightPosition;
void main()
{
-precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
+precision highp float;
+varying highp vec2 vTexCoord;
+varying highp vec3 vIllumination;
+varying highp float vSpecular;
uniform sampler2D sDiffuse;
uniform lowp vec4 uColor;
+precision highp float;
attribute highp vec3 aPosition;
attribute highp vec2 aTexCoord;
attribute highp vec3 aNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+varying highp vec2 vTexCoord;
+varying highp vec3 vIllumination;
+varying highp float vSpecular;
+uniform highp vec3 uSize;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelView;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uObjectMatrix;
+uniform highp vec3 uLightPosition;
void main()
{
-precision mediump float;
-varying mediump vec3 vIllumination;
+precision highp float;
+varying highp vec3 vIllumination;
uniform lowp vec4 uColor;
void main()
+precision highp float;
attribute highp vec3 aPosition;
attribute highp vec2 aTexCoord;
attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+varying highp vec3 vIllumination;
+uniform highp vec3 uSize;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelView;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uObjectMatrix;
+uniform highp vec3 uLightPosition;
void main()
{
-precision mediump float;
+precision highp float;
uniform sampler2D sTexture;
uniform vec4 uColor;
-precision mediump float;
+precision highp float;
attribute vec2 aPosition;
-precision mediump float;
+precision highp float;
uniform sampler2D sTexture;
uniform vec4 uColor;
-precision mediump float;
+precision highp float;
attribute vec2 aPosition;
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
+precision highp float;
+attribute highp vec2 aPosition;
+varying highp vec2 vTexCoord;
+varying highp vec2 vMaskTexCoord;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
+varying highp vec2 vMaskTexCoord;
uniform sampler2D sTexture;
uniform sampler2D sMask;
uniform lowp vec4 uColor;
mediump float maskAlpha = mask.a * auxiliaryImageAlpha;
- lowp vec3 preMultipliedMaskRGB = mask.rgb * mix(mask.a, 1.0, premultipliedAlpha) * auxiliaryImageAlpha;
- lowp vec3 preMultipliedTextureRGB = color.rgb * mix(color.a, 1.0, premultipliedAlpha);
+ highp vec3 preMultipliedMaskRGB = mask.rgb * mix(mask.a, 1.0, premultipliedAlpha) * auxiliaryImageAlpha;
+ highp vec3 preMultipliedTextureRGB = color.rgb * mix(color.a, 1.0, premultipliedAlpha);
// Manual blend operation with premultiplied colors.
// Final alpha = maskAlpha + (1.0 - maskAlpha) * color.a.
// If premultipliedAlpha == 1.0, just return vec4(rgb*alpha, alpha)
// Else, return vec4((rgb*alpha) / alpha, alpha)
- lowp float finalAlpha = mix(color.a, 1.0, maskAlpha);
- lowp vec3 finalMultipliedRGB = preMultipliedMaskRGB + (1.0 - maskAlpha) * preMultipliedTextureRGB;
+ highp float finalAlpha = mix(color.a, 1.0, maskAlpha);
+ highp vec3 finalMultipliedRGB = preMultipliedMaskRGB + (1.0 - maskAlpha) * preMultipliedTextureRGB;
// TODO : Need to find some way without division
lowp vec4 finalColor = vec4(finalMultipliedRGB * mix(1.0 / finalAlpha, 1.0, premultipliedAlpha), finalAlpha);
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
+precision highp float;
+attribute highp vec2 aPosition;
+varying highp vec2 vTexCoord;
+varying highp vec2 vMaskTexCoord;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
uniform highp vec2 uNinePatchFactorsX[FACTOR_SIZE_X];
-precision mediump float;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform vec3 uSize;
uniform vec2 uSpineShadowParameter;
uniform sampler2D sTexture;
-precision mediump float;
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
+precision highp float;
+attribute highp vec2 aPosition;
+uniform highp mat4 uMvpMatrix;
uniform vec3 uSize;
uniform float uTextureWidth;
varying vec2 vTexCoord;
void main()
{
- mediump vec4 vertexPosition = vec4(aPosition*uSize.xy, 0.0, 1.0);
+ highp vec4 vertexPosition = vec4(aPosition*uSize.xy, 0.0, 1.0);
gl_Position = uMvpMatrix * vertexPosition;
vTexCoord = aPosition + vec2(0.5);
vTexCoord.x /= uTextureWidth;
-precision mediump float;
+precision highp float;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
-uniform vec3 uSize;
-uniform vec2 uSpineShadowParameter;
-varying vec3 vNormal;
-varying vec4 vPosition;
+uniform highp vec3 uSize;
+uniform highp vec2 uSpineShadowParameter;
+varying highp vec3 vNormal;
+varying highp vec4 vPosition;
void main()
{
* ([3][3]) float currentLength: The length from the current center to the curveEnd.
*/
-precision mediump float;
+precision highp float;
-attribute mediump vec2 aPosition;
+attribute highp vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uModelView;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uModelView;
-uniform mat4 uCommonParameters;
+uniform highp mat4 uCommonParameters;
-uniform vec3 uSize;
+uniform highp vec3 uSize;
uniform float uIsTurningBack;
uniform float uTextureWidth;
-varying vec3 vNormal;
-varying vec4 vPosition;
-varying mediump vec2 vTexCoord;
+varying highp vec3 vNormal;
+varying highp vec4 vPosition;
+varying highp vec2 vTexCoord;
void main()
{
//Very simple fragment shader that merely applies the vertex shading to the color at each fragment.
-precision mediump float;
-varying mediump vec3 vIllumination;
+precision highp float;
+varying highp vec3 vIllumination;
uniform lowp vec4 uColor;
void main()
//A simple shader that applies diffuse lighting to a mono-coloured object.
+precision highp float;
attribute highp vec3 aPosition;
attribute highp vec2 aTexCoord;
attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump vec3 uObjectDimensions;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+varying highp vec3 vIllumination;
+uniform highp vec3 uSize;
+uniform highp vec3 uObjectDimensions;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelView;
+uniform highp mat4 uViewMatrix;
+uniform highp mat3 uNormalMatrix;
+uniform highp mat4 uObjectMatrix;
+uniform highp vec3 lightPosition;
+uniform highp vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
+uniform highp vec2 offset;
+uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform lowp vec4 uShadowColor;
uniform sampler2D sTexture;
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelMatrix;
-uniform vec3 uSize;
-varying vec2 vTexCoord;
+precision highp float;
+attribute highp vec2 aPosition;
+uniform highp mat4 uMvpMatrix;
+uniform highp mat4 uModelMatrix;
+uniform highp vec3 uSize;
+varying highp vec2 vTexCoord;
-uniform mediump mat4 uLightCameraProjectionMatrix;
-uniform mediump mat4 uLightCameraViewMatrix;
+uniform highp mat4 uLightCameraProjectionMatrix;
+uniform highp mat4 uLightCameraViewMatrix;
void main()
{
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ highp vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
vertexPosition.xyz *= uSize;
gl_Position = uMvpMatrix * vertexPosition;
vec4 textureCoords = uLightCameraProjectionMatrix * uLightCameraViewMatrix * uModelMatrix * vertexPosition;
precision highp float;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
-uniform int uSpread;
-uniform vec2 uTexScale;
+uniform highp int uSpread;
+uniform highp vec2 uTexScale;
void main()
{
-varying mediump vec2 vTexCoord;
+precision highp float;
+varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
uniform lowp float uAlpha;
-uniform lowp vec4 uColor;
-uniform lowp vec4 textColorAnimatable;
-uniform sampler2D sTexture;
-varying mediump vec2 vTexCoord;
-varying mediump vec4 vColor;
+precision highp float;
+uniform lowp vec4 uColor;
+uniform lowp vec4 textColorAnimatable;
+uniform sampler2D sTexture;
+varying highp vec2 vTexCoord;
+varying highp vec4 vColor;
void main()
{
-uniform lowp vec4 uColor;
-uniform lowp vec4 textColorAnimatable;
-uniform sampler2D sTexture;
-varying mediump vec2 vTexCoord;
+precision highp float;
+uniform lowp vec4 uColor;
+uniform lowp vec4 textColorAnimatable;
+uniform sampler2D sTexture;
+varying highp vec2 vTexCoord;
void main()
{
-attribute highp vec2 aPosition;
-attribute mediump vec2 aTexCoord;
-attribute mediump vec4 aColor;
-uniform mediump vec2 uOffset;
-uniform highp mat4 uMvpMatrix;
-varying mediump vec2 vTexCoord;
-varying mediump vec4 vColor;
+precision highp float;
+attribute highp vec2 aPosition;
+attribute highp vec2 aTexCoord;
+attribute highp vec4 aColor;
+uniform highp vec2 uOffset;
+uniform highp mat4 uMvpMatrix;
+varying highp vec2 vTexCoord;
+varying highp vec4 vColor;
void main()
{
-varying mediump vec4 vColor;
-uniform lowp vec4 uColor;
+precision highp float;
+varying highp vec4 vColor;
+uniform lowp vec4 uColor;
void main()
{
-attribute mediump vec2 aPosition;
-attribute mediump vec4 aColor;
-varying mediump vec4 vColor;
-uniform highp mat4 uMvpMatrix;
+precision highp float;
+attribute highp vec2 aPosition;
+attribute highp vec4 aColor;
+varying highp vec4 vColor;
+uniform highp mat4 uMvpMatrix;
void main()
{
- mediump vec4 position = vec4( aPosition, 0.0, 1.0 );
+ highp vec4 position = vec4( aPosition, 0.0, 1.0 );
gl_Position = uMvpMatrix * position;
vColor = aColor;
}
-uniform lowp vec4 uColor;
+precision highp float;
+uniform lowp vec4 uColor;
void main()
{
-attribute mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
+precision highp float;
+attribute highp vec2 aPosition;
+uniform highp mat4 uMvpMatrix;
void main()
{
- mediump vec4 position = vec4( aPosition, 0.0, 1.0 );
+ highp vec4 position = vec4( aPosition, 0.0, 1.0 );
gl_Position = uMvpMatrix * position;
}
+precision highp float;
varying highp vec2 vTexCoord;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
-attribute mediump vec2 aPosition;
+precision highp float;
+attribute highp vec2 aPosition;
varying highp vec2 vTexCoord;
uniform highp vec3 uSize;
uniform highp float uDelta;
-uniform mediump vec2 uTextureSize;
+uniform highp vec2 uTextureSize;
uniform highp float uGap;
-uniform mediump float uHorizontalAlign;
-uniform mediump float uVerticalAlign;
+uniform highp float uHorizontalAlign;
+uniform highp float uVerticalAlign;
uniform highp mat4 uMvpMatrix;
//Visual size and offset
-uniform mediump vec2 offset;
+uniform highp vec2 offset;
uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw);
highp vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
- vTexCoord.x = ( uDelta + uHorizontalAlign * ( uTextureSize.x - visualSize.x - uGap ) + aPosition.x * visualSize.x - uGap * 0.5 ) / uTextureSize.x + 0.5;
- vTexCoord.y = ( uVerticalAlign * ( uTextureSize.y - visualSize.y ) + aPosition.y * visualSize.y ) / ( uTextureSize.y ) + 0.5;
+ vTexCoord.x = ( uDelta + (aPosition.x - uHorizontalAlign) * visualSize.x - uGap * (0.5 + uHorizontalAlign) ) / uTextureSize.x + uHorizontalAlign + 0.5;
+ vTexCoord.y = ( (aPosition.y - uVerticalAlign) * visualSize.y ) / uTextureSize.y + uVerticalAlign + 0.5;
highp vec4 vertexPosition = vec4( ( aPosition + anchorPoint ) * visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0 );
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+INPUT highp vec2 vTexCoord;
uniform sampler2D sTexture;
#ifdef IS_REQUIRED_STYLE
uniform sampler2D sStyle;
-INPUT mediump vec2 aPosition;
+precision highp float;
+INPUT highp vec2 aPosition;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
-OUTPUT mediump vec2 vTexCoord;
+OUTPUT highp vec2 vTexCoord;
//Visual size and offset
-uniform mediump vec2 offset;
+uniform highp vec2 offset;
uniform highp vec2 size;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
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);
return vec4( (aPosition + anchorPoint) * visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0 );
}
+precision highp float;
uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
+varying highp vec2 vTexCoord;
uniform samplerExternalOES sTexture;
void main()
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
+precision highp float;
+attribute highp vec2 aPosition;
+varying highp vec2 vTexCoord;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
-varying mediump vec2 sTexCoordRect;
void main()
{
+precision highp float;
void main()
{
gl_FragColor = vec4(0.0);
-attribute mediump vec2 aPosition;
+precision highp float;
+attribute highp vec2 aPosition;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
void main()
{
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ highp vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
vertexPosition.xyz *= uSize;
gl_Position = uMvpMatrix * vertexPosition;
}
+precision highp float;
uniform lowp vec4 uColor;
void main()
-attribute mediump vec2 aPosition;
+precision highp float;
+attribute highp vec2 aPosition;
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;
projects / platform / core / uifw / dali-toolkit.git / commitdiff