+//@name default-physically-based-shader.frag
+
//@version 100
+precision highp float;
+
// Original Code
// https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-frag.glsl
// Commit dc84b5e374fb3d23153d2248a338ef88173f9eb6
// [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
#define ROUGHNESS g
{
UNIFORM mediump int uShadowLightIndex;
UNIFORM lowp int uEnableShadowSoftFiltering;
- UNIFORM mediump float uShadowIntensity;
+ UNIFORM highp float uShadowIntensity;
UNIFORM highp float uShadowBias;
};
// TODO: Multiple texture coordinate will be supported.
-INPUT mediump vec2 vUV;
+INPUT highp vec2 vUV;
INPUT highp mat3 vTBN;
-INPUT lowp vec4 vColor;
+INPUT highp vec4 vColor;
INPUT highp vec3 vPositionToCamera;
INPUT highp vec3 positionFromLightView;
-const lowp float c_MinRoughness = 0.04;
+const highp float c_MinRoughness = 0.04;
const highp float M_PI = 3.141592653589793;
// These properties can be used for circular sampling for PCF
+//@name default-physically-based-shader.vert
+
//@version 100
+precision highp float;
+
// Original Code
// https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-vert.glsl
// Commit dc84b5e374fb3d23153d2248a338ef88173f9eb6
#define ADD_EXTRA_SKINNING_ATTRIBUTES
#define ADD_EXTRA_WEIGHTS
-precision highp float;
-
INPUT vec3 aPosition;
INPUT vec2 aTexCoord;
INPUT vec3 aNormal;
{
#ifdef MORPH
#ifdef SL_VERSION_LOW
- UNIFORM int uBlendShapeGeometryWidth;
- UNIFORM int uBlendShapeGeometryHeight;
+ UNIFORM highp int uBlendShapeGeometryWidth;
+ UNIFORM highp int uBlendShapeGeometryHeight;
#endif
#endif
#ifdef MORPH
#define MAX_BLEND_SHAPE_NUMBER 256
- UNIFORM int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
+ UNIFORM highp int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
UNIFORM highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];///< The weight of each blend shape.
#ifdef MORPH_VERSION_2_0
UNIFORM highp float uBlendShapeUnnormalizeFactor;///< Factor used to unnormalize the geometry of the blend shape.
#define MAX_BONES 256
UNIFORM_BLOCK Bones
{
- UNIFORM mat4 uBone[MAX_BONES];
+ UNIFORM highp mat4 uBone[MAX_BONES];
};
#endif
#endif
OUTPUT highp vec3 positionFromLightView;
-OUTPUT mediump vec2 vUV;
+OUTPUT highp vec2 vUV;
OUTPUT highp mat3 vTBN;
-OUTPUT lowp vec4 vColor;
+OUTPUT highp vec4 vColor;
OUTPUT highp vec3 vPositionToCamera;
void main()
#ifdef MORPH
#ifdef SL_VERSION_LOW
- int width = uBlendShapeGeometryWidth;
+ highp int width = uBlendShapeGeometryWidth;
#else
- int width = textureSize( sBlendShapeGeometry, 0 ).x;
+ highp int width = textureSize( sBlendShapeGeometry, 0 ).x;
#endif
highp int blendShapeBufferOffset = 0;
highp float invertBlendShapeHeight = 1.0 / blendShapeHeight;
#endif
- for( int index = 0; index < uNumberOfBlendShapes; ++index )
+ for( highp int index = 0; index < uNumberOfBlendShapes; ++index )
{
highp vec3 diff = vec3(0.0);
highp int vertexId = 0;
+//@name scene3d-joint-debug.frag
+
//@version 100
-precision mediump float;
+precision highp float;
+
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
+//@name scene3d-joint-debug.vert
+
//@version 100
-precision mediump float;
+precision highp float;
+
UNIFORM_BLOCK VertBlock
{
UNIFORM mat4 uMvpMatrix;
+//@name shadow-map-shader.frag
+
//@version 100
UNIFORM_BLOCK FragBlock
UNIFORM int uIsShadowCasting;
};
-INPUT mediump vec2 vUV;
-INPUT lowp vec4 vColor;
+INPUT highp vec2 vUV;
+INPUT highp vec4 vColor;
#ifdef THREE_TEX
#ifdef BASECOLOR_TEX
+//@name shadow-map-shader.vert
+
//@version 100
#define MORPH defined(MORPH_POSITION) || defined(MORPH_NORMAL) || defined(MORPH_TANGENT)
#endif
#endif
-OUTPUT mediump vec2 vUV;
-OUTPUT lowp vec4 vColor;
+OUTPUT highp vec2 vUV;
+OUTPUT highp vec4 vColor;
UNIFORM_BLOCK VertBlock
{
#ifdef MORPH
#ifdef SL_VERSION_LOW
- UNIFORM int uBlendShapeGeometryWidth;
- UNIFORM int uBlendShapeGeometryHeight;
+ UNIFORM highp int uBlendShapeGeometryWidth;
+ UNIFORM highp int uBlendShapeGeometryHeight;
#endif
#endif
#ifdef MORPH
#define MAX_BLEND_SHAPE_NUMBER 256
- UNIFORM int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
+ UNIFORM highp int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
UNIFORM highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];///< The weight of each blend shape.
#ifdef MORPH_VERSION_2_0
UNIFORM highp float uBlendShapeUnnormalizeFactor;///< Factor used to unnormalize the geometry of the blend shape.
#ifdef MORPH
#ifdef SL_VERSION_LOW
- int width = uBlendShapeGeometryWidth;
+ highp int width = uBlendShapeGeometryWidth;
#else
- int width = textureSize( sBlendShapeGeometry, 0 ).x;
+ highp int width = textureSize( sBlendShapeGeometry, 0 ).x;
#endif
highp int blendShapeBufferOffset = 0;
highp float invertBlendShapeHeight = 1.0 / blendShapeHeight;
#endif
- for( int index = 0; index < uNumberOfBlendShapes; ++index )
+ for( highp int index = 0; index < uNumberOfBlendShapes; ++index )
{
highp vec3 diff = vec3(0.0);
highp int vertexId = 0;
+//@name skybox-equirectangular-shader.frag
+
+//@version 100
+
+precision highp float;
+
// Fragment shader for a skybox in equirectangular projection
-precision mediump float;
UNIFORM sampler2D uSkyBoxEquirectangularTexture;
UNIFORM_BLOCK FragBlock
{
- UNIFORM vec4 uColor;
- UNIFORM float uIntensity;
+ UNIFORM lowp vec4 uColor;
+ UNIFORM highp float uIntensity;
};
-INPUT vec3 vTexCoord;
+INPUT highp vec3 vTexCoord;
// Take the sample direction as interpolated from the cube's local position,
// and use this direction vector and the spherical to cartesian coordinate
+//@name skybox-shader.frag
+
//@version 100
+precision highp float;
+
UNIFORM samplerCube uSkyBoxTexture;
UNIFORM_BLOCK FragBlock
{
- UNIFORM lowp vec4 uColor;
- UNIFORM mediump float uIntensity;
+ UNIFORM lowp vec4 uColor;
+ UNIFORM highp float uIntensity;
};
-INPUT mediump vec3 vTexCoord;
+INPUT highp vec3 vTexCoord;
void main()
{
+//@name skybox-shader.vert
+
//@version 100
-INPUT mediump vec3 aPosition;
+precision highp float;
+
+INPUT highp vec3 aPosition;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uModelView;
- UNIFORM mediump mat4 uModelMatrix;
- UNIFORM mediump mat4 uViewMatrix;
- UNIFORM mediump mat4 uProjection;
- UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM highp mat4 uModelView;
+ UNIFORM highp mat4 uModelMatrix;
+ UNIFORM highp mat4 uViewMatrix;
+ UNIFORM highp mat4 uProjection;
+ UNIFORM highp mat4 uMvpMatrix;
};
-OUTPUT mediump vec3 vTexCoord;
+OUTPUT highp vec3 vTexCoord;
void main()
{
vTexCoord.y = -aPosition.y; // convert to GL coords
vTexCoord.z = aPosition.z;
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);
- vec4 clipSpacePosition = uProjection * mat4(mat3(uModelView)) * vertexPosition;
+ highp vec4 vertexPosition = vec4(aPosition, 1.0);
+ highp vec4 clipSpacePosition = uProjection * mat4(mat3(uModelView)) * vertexPosition;
// Writes 1.0, the maximum depth value, into the depth buffer.
// This is an optimization to avoid running the fragment shader
// for the pixels hidden by the scene's objects.
+//@name alpha-discard-effect.frag
+
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
-UNIFORM lowp vec4 uColor;
+ UNIFORM lowp vec4 uColor;
};
//@version 100
-precision mediump float;
+precision highp float;
UNIFORM_BLOCK FragBlock
{
- 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;
};
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec2 vStart;
-INPUT mediump vec2 vEnd;
+INPUT highp vec2 vTexCoord;
+INPUT highp vec2 vStart;
+INPUT highp vec2 vEnd;
float get_position(vec2 x, vec2 s, vec2 e)
{
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
UNIFORM_BLOCK VertBlock
{
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;
};
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec2 vStart;
-OUTPUT mediump vec2 vEnd;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec2 vStart;
+OUTPUT highp vec2 vEnd;
vec2 rotate(vec2 x, vec2 c, float a)
{
/* UnitType::USER_SPACE*/
}
-//Visual size and offset
-UNIFORM_BLOCK VisualBlock
+UNIFORM_BLOCK VisualVertBlock
{
- UNIFORM mediump vec2 offset;
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy );
return vec4( (aPosition + anchorPoint)*visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0 );
}
//@version 100
-INPUT mediump vec2 vPosition;
+precision highp float;
+
+INPUT highp vec2 vPosition;
UNIFORM_BLOCK VertBlock
{
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 ) );
- mediump float opacity = 1.0 - smoothstep( 0.0, 2.0, min( length( vPosition - q0 ), length( vPosition - q1 ) ) );
+ 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 ) );
+ highp 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;
}
//@version 100
-INPUT mediump vec2 vPosition;
+precision highp float;
+
+INPUT highp vec2 vPosition;
UNIFORM_BLOCK FragBlock
{
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 ) ) );
}
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vPosition;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp mat4 uMvpMatrix;
UNIFORM highp vec3 uSize;
+};
-//Visual size and offset
- UNIFORM mediump vec2 offset;
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
vPosition = aPosition* visualSize;
return vec4( vPosition + anchorPoint*visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0 );
//@version 100
-precision mediump float;
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM sampler2D sEffect;
void main()
{
- mediump vec4 image;
- mediump vec4 bloom;
+ highp vec4 image;
+ highp vec4 bloom;
image = TEXTURE(sTexture, vTexCoord);
bloom = TEXTURE(sEffect, vTexCoord);
image = ChangeSaturation(image, uImageSaturation) * uImageIntensity;
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
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 = TEXTURE(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);
//@version 100
+precision highp float;
+
INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
UNIFORM_BLOCK FragBlock
{
- UNIFORM float uBlurStrength;
+ UNIFORM float uBlurStrength;
};
UNIFORM sampler2D sTexture;
UNIFORM sampler2D sEffect;
-INPUT mediump vec2 vTexCoord;
+INPUT highp vec2 vTexCoord;
void main()
{
//@version 100
precision highp float;
-INPUT mediump vec2 vTexCoord;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
//@version 100
-INPUT mediump float vAlpha;
+precision highp float;
+
+INPUT highp float vAlpha;
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
UNIFORM lowp vec4 borderColor;
- UNIFORM mediump float borderSize;
+ UNIFORM highp float borderSize;
};
void main()
//@version 100
-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_BLOCK VertBlock
{
{
UNIFORM lowp vec4 uColor;
UNIFORM lowp vec4 borderColor;
- UNIFORM mediump float borderSize;
+ UNIFORM highp float borderSize;
+};
+
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
};
+vec2 ComputeVertexPosition()
+{
+ vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize + vec2(0.75, 0.75);
+ vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
+ return (aPosition + anchorPoint)*visualSize + visualOffset + origin * uSize.xy;
+}
+
void main()
{
- vec2 position = aPosition*(uSize.xy+vec2(0.75)) + aDrift*(borderSize+1.5);
+ vec2 position = ComputeVertexPosition() + 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
//@version 100
+precision highp float;
+
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
//@version 100
-INPUT mediump vec2 aPosition;
-INPUT mediump vec2 aDrift;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+INPUT highp vec2 aDrift;
UNIFORM_BLOCK VertBlock
{
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_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec2 ComputeVertexPosition()
{
- vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
return (aPosition + anchorPoint)*visualSize + visualOffset + origin * uSize.xy;
}
//@version 100
+precision highp float;
+
// Use the actor color to paint every layer
UNIFORM_BLOCK FragBlock
{
//@version 100
+precision highp float;
+
// Modify the vertex position according to the bounce coefficient
-INPUT mediump vec3 aPosition1;
-INPUT mediump vec3 aPosition2;
+INPUT highp vec3 aPosition1;
+INPUT highp vec3 aPosition2;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump float uBounceCoefficient;
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM highp float uBounceCoefficient;
};
void main()
UNIFORM float uIgnoreAlpha;
};
-INPUT mediump vec2 vTexCoord;
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
float rand(vec2 co)
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sBackground;
UNIFORM sampler2D sBubbleShape;
-INPUT mediump float vPercentage;
-INPUT mediump vec2 vEffectTexCoord;
+INPUT highp float vPercentage;
+INPUT highp vec2 vEffectTexCoord;
UNIFORM_BLOCK FragBlock
{
//@version 100
-INPUT mediump float aIndex;
-INPUT mediump vec2 aPosition;
-INPUT highp vec2 aTexCoord;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp float aIndex;
+INPUT highp vec2 aPosition;
+INPUT highp vec2 aTexCoord;
+OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM highp mat4 uMvpMatrix;
// the gravity applied to the y direction
UNIFORM mediump float uGravity;
// xy: the emit position of the bubble; zw: the destination of the bubble.
// This UNIFORM is used to change the bubble size during running time
UNIFORM float uDynamicScale;
};
-OUTPUT float vPercentage;
-OUTPUT vec2 vEffectTexCoord;
+OUTPUT highp float vPercentage;
+OUTPUT highp vec2 vEffectTexCoord;
void main()
{
UNIFORM vec3 uHSVDelta;
};
-INPUT mediump vec2 vTexCoord;
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
float rand(vec2 co)
//@version 100
-INPUT mediump vec2 aPosition;
-INPUT mediump vec2 aTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+INPUT highp vec2 aTexCoord;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM highp mat4 uMvpMatrix;
};
-OUTPUT mediump vec2 vTexCoord;
+OUTPUT highp vec2 vTexCoord;
void main()
{
//@version 100
+precision highp float;
+
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
};
-INPUT mediump vec2 vTexCoord;
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
void main()
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp mat4 uMvpMatrix;
//@version 100
+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;
UNIFORM lowp int uCutoutOutside;
#endif
+#ifdef IS_REQUIRED_BORDERLINE
+ UNIFORM lowp vec4 borderlineColor;
+#endif
+
#ifdef IS_REQUIRED_SQUIRCLE_CORNER
UNIFORM highp vec4 cornerSquareness;
#endif
#ifdef IS_REQUIRED_BORDERLINE
UNIFORM highp float borderlineWidth;
UNIFORM highp float borderlineOffset;
- UNIFORM lowp vec4 borderlineColor;
#endif
};
blurRadius = max(blurRadius, 0.0) + vAliasMargin;
- 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;
- mediump float borderlineOpacity = 0.0;
- mediump float textureOpacity = 0.0;
+ highp float borderlineOpacity = 0.0;
+ highp float textureOpacity = 0.0;
highp float outsideThreshold = gRadius;
highp float insideThreshold = gRadius - currentBorderlineWidth;
// 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);
}
#else
highp float potential = gPotential;
// default opacity of borderline is 0.0
- mediump float borderlineOpacity = 0.0;
+ highp float borderlineOpacity = 0.0;
// calculate borderline opacity by potential
if(potential > gMinInlinePotential)
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);
//@version 100
-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;
{
UNIFORM highp mat4 uMvpMatrix;
- #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
+#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
// Be used when we calculate anti-alias range near 1 pixel.
UNIFORM highp vec3 uScale;
- #endif
+#endif
+
+#ifdef IS_REQUIRED_ROUNDED_CORNER
+ UNIFORM highp vec4 cornerRadius;
+ UNIFORM mediump float cornerRadiusPolicy;
+#endif
+};
+UNIFORM_BLOCK VisualVertBlock
+{
//Visual size and offset
UNIFORM highp vec2 offset;
UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
-
-#ifdef IS_REQUIRED_ROUNDED_CORNER
- UNIFORM highp vec4 cornerRadius;
- UNIFORM mediump float cornerRadiusPolicy;
-#endif
- UNIFORM highp vec2 extraSize;
};
UNIFORM_BLOCK SharedBlock
{
- UNIFORM highp vec3 uSize;
+ UNIFORM highp vec3 uSize;
#ifdef IS_REQUIRED_BLUR
- UNIFORM highp float blurRadius;
+ UNIFORM highp float blurRadius;
#endif
#ifdef IS_REQUIRED_BORDERLINE
- UNIFORM highp float borderlineWidth;
- UNIFORM highp float borderlineOffset;
- UNIFORM lowp vec4 borderlineColor;
+ UNIFORM highp float borderlineWidth;
+ UNIFORM highp float borderlineOffset;
#endif
};
//@version 100
precision highp float;
+
INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragColor
//@version 100
precision highp float;
+
INPUT highp vec2 aPosition;
OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
- UNIFORM lowp vec4 uSamplerRect;
};
void main()
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump vec4 uTextureRect;
+ 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;
//@version 100
-INPUT float vPercentage;
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp float vPercentage;
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM vec3 uSize;
-
- UNIFORM float uPercentage;
- UNIFORM vec3 uSaddleParam;
- UNIFORM vec2 uTranslation;
- UNIFORM vec2 uRotation;
- UNIFORM float uToNext;
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+
+ UNIFORM highp float uPercentage;
+ UNIFORM highp vec3 uSaddleParam;
+ UNIFORM highp vec2 uTranslation;
+ UNIFORM highp vec2 uRotation;
+ UNIFORM highp float uToNext;
};
-OUTPUT float vPercentage;
-OUTPUT vec2 vTexCoord;
+OUTPUT highp float vPercentage;
+OUTPUT highp vec2 vTexCoord;
void main()
{
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM_BLOCK FragBlock
{
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump vec3 effectOffset;
+ 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;
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
//@version 100
precision highp float;
-INPUT mediump vec2 vTexCoord;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
//@version 100
+precision highp float;
+
INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
UNIFORM_BLOCK FragBlockBaseColor
{
- UNIFORM int uBaseColorTexCoordIndex;
+ UNIFORM highp int uBaseColorTexCoordIndex;
};
UNIFORM sampler2D uEmissiveSampler;
UNIFORM_BLOCK FragBlockEmissive
{
- UNIFORM int uEmissiveTexCoordIndex;
- UNIFORM vec3 uEmissiveFactor;
+ UNIFORM highp int uEmissiveTexCoordIndex;
+ UNIFORM highp vec3 uEmissiveFactor;
};
UNIFORM_BLOCK FragBlockIBL
{
- UNIFORM vec4 uScaleIBLAmbient;
+ UNIFORM highp vec4 uScaleIBLAmbient;
UNIFORM highp float uMipmapLevel;
};
UNIFORM_BLOCK FragBlockMetRough
{
- UNIFORM int uMetallicRoughnessTexCoordIndex;
+ UNIFORM highp int uMetallicRoughnessTexCoordIndex;
};
UNIFORM sampler2D uNormalSampler;
UNIFORM_BLOCK FragBlockNormal
{
- UNIFORM float uNormalScale;
- UNIFORM int uNormalTexCoordIndex;
+ UNIFORM highp float uNormalScale;
+ UNIFORM highp int uNormalTexCoordIndex;
};
UNIFORM sampler2D uOcclusionSampler;
UNIFORM_BLOCK FragBlockOcclusion
{
- UNIFORM int uOcclusionTexCoordIndex;
- UNIFORM float uOcclusionStrength;
+ UNIFORM highp int uOcclusionTexCoordIndex;
+ UNIFORM highp float uOcclusionStrength;
};
UNIFORM lowp float uHasLightSource;
};
-INPUT lowp vec2 vUV[2];
-INPUT lowp mat3 vTBN;
-INPUT lowp vec4 vColor;
+INPUT highp vec2 vUV[2];
+INPUT highp mat3 vTBN;
+INPUT highp vec4 vColor;
INPUT highp vec3 vLightDirection;
INPUT highp vec3 vPositionToCamera;
//@version 100
INPUT highp vec3 aPosition;
-INPUT mediump vec2 aTexCoord0;
-INPUT mediump vec2 aTexCoord1;
-INPUT lowp vec3 aNormal;
-INPUT lowp vec4 aTangent;
-INPUT lowp vec4 aVertexColor;
+INPUT highp vec2 aTexCoord0;
+INPUT highp vec2 aTexCoord1;
+INPUT highp vec3 aNormal;
+INPUT highp vec4 aTangent;
+INPUT highp vec4 aVertexColor;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump mat4 uModelMatrix;
- UNIFORM mediump mat4 uViewMatrix;
- UNIFORM mediump mat4 uProjection;
- UNIFORM mediump vec3 uLightVector;
+ UNIFORM highp vec3 uSize;
+ UNIFORM highp mat4 uModelMatrix;
+ UNIFORM highp mat4 uViewMatrix;
+ UNIFORM highp mat4 uProjection;
+ UNIFORM highp vec3 uLightVector;
UNIFORM lowp float uIsPointLight;
UNIFORM lowp float uHasVertexColor;
};
-OUTPUT lowp vec2 vUV[2];
-OUTPUT lowp mat3 vTBN;
-OUTPUT lowp vec4 vColor;
+OUTPUT highp vec2 vUV[2];
+OUTPUT highp mat3 vTBN;
+OUTPUT highp vec4 vColor;
OUTPUT highp vec3 vLightDirection;
OUTPUT highp vec3 vPositionToCamera;
//@version 100
-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;
UNIFORM_BLOCK FragBlock
{
// scale factor to fit start and end position of gradient.
- UNIFORM mediump float uTextureCoordinateScaleFactor;
+ UNIFORM highp float uTextureCoordinateScaleFactor;
UNIFORM lowp vec4 uColor;
+
+#ifdef IS_REQUIRED_BORDERLINE
+ UNIFORM lowp vec4 borderlineColor;
+ UNIFORM lowp vec4 uActorColor;
+#endif
+
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+ UNIFORM highp vec4 cornerSquareness;
+#endif
};
#ifdef IS_REQUIRED_BORDERLINE
-UNIFORM_BLOCK SharedBlock
+UNIFORM_BLOCK Borderline
{
UNIFORM highp float borderlineWidth;
UNIFORM highp float borderlineOffset;
- UNIFORM lowp vec4 borderlineColor;
- UNIFORM lowp vec4 uActorColor;
};
#endif
-#ifdef IS_REQUIRED_SQUIRCLE_CORNER
-uniform highp vec4 cornerSquareness;
-#endif
-
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
// Global values both rounded corner and borderline use
highp float potential = gPotential;
// default opacity of borderline is 0.0
- mediump float borderlineOpacity = 0.0;
+ highp float borderlineOpacity = 0.0;
// calculate borderline opacity by potential
if(potential > gMinInlinePotential)
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);
//@version 100
-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.
UNIFORM highp vec3 uScale;
#endif
- // Visual size and offset
- UNIFORM highp vec2 offset;
- UNIFORM highp vec2 size;
- UNIFORM mediump vec4 offsetSizeMode;
- UNIFORM mediump vec2 origin;
- UNIFORM mediump vec2 anchorPoint;
#ifdef IS_REQUIRED_ROUNDED_CORNER
UNIFORM highp vec4 cornerRadius;
UNIFORM mediump float cornerRadiusPolicy;
#endif
};
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
+
#ifdef IS_REQUIRED_BORDERLINE
-UNIFORM_BLOCK SharedBlock
+UNIFORM_BLOCK Borderline
{
UNIFORM highp float borderlineWidth;
UNIFORM highp float borderlineOffset;
- UNIFORM lowp vec4 borderlineColor;
- UNIFORM lowp vec4 uActorColor;
};
#endif
vec4 ComputeVertexPosition()
{
- highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+ 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)
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
OUTPUT vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump vec2 uTopLeft;
- UNIFORM mediump vec2 uBottomRight;
- UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM highp vec2 uTopLeft;
+ UNIFORM highp vec2 uBottomRight;
+ UNIFORM highp mat4 uMvpMatrix;
UNIFORM vec3 uSize;
UNIFORM vec4 uTextureRect;
};
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;
//@version 100
-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;
-INPUT mediump vec2 vMaskTexCoord;
+INPUT highp vec2 vMaskTexCoord;
#endif
UNIFORM_BLOCK FragBlock
#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
-#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER)
- UNIFORM highp vec3 uScale;
-#endif
-
UNIFORM lowp vec4 uColor;
UNIFORM lowp float premultipliedAlpha;
#endif
};
+#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER)
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM highp vec3 uScale;
+};
+#endif
+
#ifdef IS_REQUIRED_BORDERLINE
UNIFORM_BLOCK Borderline
{
#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 */
highp float potential = gPotential;
// default opacity of borderline is 0.0
- mediump float borderlineOpacity = 0.0;
+ highp float borderlineOpacity = 0.0;
// calculate borderline opacity by potential
if(potential > gMinInlinePotential)
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
- 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 ),
+ 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;
//@version 100
-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;
#endif
#ifdef IS_REQUIRED_ALPHA_MASKING
-OUTPUT mediump vec2 vMaskTexCoord;
+OUTPUT highp vec2 vMaskTexCoord;
#endif
#ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
UNIFORM highp vec3 uSize;
UNIFORM highp vec4 pixelArea;
+#ifdef IS_REQUIRED_ROUNDED_CORNER
+ UNIFORM highp vec4 cornerRadius;
+ UNIFORM mediump float cornerRadiusPolicy;
+#endif
+#ifdef IS_REQUIRED_ALPHA_MASKING
+ UNIFORM lowp float cropToMask;
+ UNIFORM highp vec2 maskTextureRatio;
+#endif
+};
+
#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
+UNIFORM_BLOCK SharedBlock
+{
// Be used when we calculate anti-alias range near 1 pixel.
UNIFORM highp vec3 uScale;
+};
#endif
- // Visual size and offset
- UNIFORM highp vec2 offset;
- UNIFORM highp vec2 size;
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
-
-#ifdef IS_REQUIRED_ROUNDED_CORNER
- UNIFORM highp vec4 cornerRadius;
- UNIFORM mediump float cornerRadiusPolicy;
-#endif
-#ifdef IS_REQUIRED_ALPHA_MASKING
- UNIFORM lowp float cropToMask;
- UNIFORM mediump vec2 maskTextureRatio;
-#endif
- UNIFORM highp vec2 extraSize;
};
#ifdef IS_REQUIRED_BORDERLINE
//@version 100
-precision mediump float;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vLightDirection;
-INPUT mediump vec3 vHalfVector;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
+INPUT highp vec3 vLightDirection;
+INPUT highp vec3 vHalfVector;
UNIFORM sampler2D sDiffuse;
UNIFORM sampler2D sNormal;
UNIFORM sampler2D sGloss;
//@version 100
+precision highp float;
+
INPUT highp vec3 aPosition;
INPUT highp vec2 aTexCoord;
INPUT highp vec3 aNormal;
INPUT highp vec3 aTangent;
INPUT highp vec3 aBiNormal;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec3 vLightDirection;
-OUTPUT mediump vec3 vHalfVector;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec3 vLightDirection;
+OUTPUT highp vec3 vHalfVector;
UNIFORM_BLOCK VertBlock
{
- 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;
+ 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_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
float scaleFactor = min( visualSize.x, visualSize.y );
vec3 originFlipY =vec3(origin.x, -origin.y, 0.0);
vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
//@version 100
-precision mediump float;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vIllumination;
-INPUT mediump float vSpecular;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
+INPUT highp vec3 vIllumination;
+INPUT highp float vSpecular;
UNIFORM sampler2D sDiffuse;
UNIFORM_BLOCK FragBlock
{
//@version 100
+precision highp float;
+
INPUT highp vec3 aPosition;
INPUT highp vec2 aTexCoord;
INPUT highp vec3 aNormal;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec3 vIllumination;
-OUTPUT mediump float vSpecular;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec3 vIllumination;
+OUTPUT highp float vSpecular;
UNIFORM_BLOCK VertBlock
{
- 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;
+ 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_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw ) + extraSize;
float scaleFactor = min( visualSize.x, visualSize.y );
vec3 originFlipY =vec3(origin.x, -origin.y, 0.0);
vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
//@version 100
-precision mediump float;
-INPUT mediump vec3 vIllumination;
+precision highp float;
+
+INPUT highp vec3 vIllumination;
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
//@version 100
+precision highp float;
+
INPUT highp vec3 aPosition;
INPUT highp vec3 aNormal;
-OUTPUT mediump vec3 vIllumination;
+OUTPUT highp vec3 vIllumination;
UNIFORM_BLOCK VertBlock
{
- 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;
-
-//Visual size and offset
- UNIFORM mediump vec2 offset;
- UNIFORM mediump vec2 size;
+ 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;
+};
+
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw ) + extraSize;
float scaleFactor = min( visualSize.x, visualSize.y );
vec3 originFlipY =vec3(origin.x, -origin.y, 0.0);
vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
//@version 100
-precision mediump float;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vLightDirection;
-INPUT mediump vec3 vHalfVector;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
+INPUT highp vec3 vLightDirection;
+INPUT highp vec3 vHalfVector;
UNIFORM sampler2D sDiffuse;
UNIFORM sampler2D sNormal;
UNIFORM sampler2D sGloss;
//@version 100
+precision highp float;
+
INPUT highp vec3 aPosition;
INPUT highp vec2 aTexCoord;
INPUT highp vec3 aNormal;
INPUT highp vec3 aTangent;
INPUT highp vec3 aBiNormal;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec3 vLightDirection;
-OUTPUT mediump vec3 vHalfVector;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec3 vLightDirection;
+OUTPUT highp vec3 vHalfVector;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump mat4 uModelView;
- UNIFORM mediump mat3 uNormalMatrix;
- UNIFORM mediump mat4 uObjectMatrix;
- UNIFORM mediump vec3 uLightPosition;
+ 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()
//@version 100
-precision mediump float;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vIllumination;
-INPUT mediump float vSpecular;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
+INPUT highp vec3 vIllumination;
+INPUT highp float vSpecular;
UNIFORM sampler2D sDiffuse;
UNIFORM_BLOCK FragBlock
{
//@version 100
+precision highp float;
+
INPUT highp vec3 aPosition;
INPUT highp vec2 aTexCoord;
INPUT highp vec3 aNormal;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec3 vIllumination;
-OUTPUT mediump float vSpecular;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec3 vIllumination;
+OUTPUT highp float vSpecular;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump mat4 uModelView;
- UNIFORM mediump mat3 uNormalMatrix;
- UNIFORM mediump mat4 uObjectMatrix;
- UNIFORM mediump vec3 uLightPosition;
+ 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()
//@version 100
-precision mediump float;
-INPUT mediump vec3 vIllumination;
+precision highp float;
+
+INPUT highp vec3 vIllumination;
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
//@version 100
+precision highp float;
+
INPUT highp vec3 aPosition;
INPUT highp vec2 aTexCoord;
INPUT highp vec3 aNormal;
-OUTPUT mediump vec3 vIllumination;
+OUTPUT highp vec3 vIllumination;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump mat4 uModelView;
- UNIFORM mediump mat3 uNormalMatrix;
- UNIFORM mediump mat4 uObjectMatrix;
- UNIFORM mediump vec3 uLightPosition;
+ 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()
//@version 100
-precision mediump float;
+precision highp float;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
//@version 100
-precision mediump float;
+precision highp float;
INPUT vec2 aPosition;
//@version 100
-precision mediump float;
+precision highp float;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
//@version 100
-precision mediump float;
+precision highp float;
INPUT vec2 aPosition; // Use position to calculate uvs
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec2 vMaskTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec2 vMaskTexCoord;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp vec3 uSize;
UNIFORM highp vec2 uFixed[3];
UNIFORM highp vec2 uStretchTotal;
+};
+
+UNIFORM_BLOCK VisualVertBlock
+{
//Visual size and offset
- UNIFORM highp vec2 offset;
- UNIFORM highp vec2 size;
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
- UNIFORM highp vec2 extraSize;
};
void main()
//@version 100
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec2 vMaskTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
+INPUT highp vec2 vMaskTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM sampler2D sMask;
UNIFORM_BLOCK FragBlock
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);
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec2 vMaskTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec2 vMaskTexCoord;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp vec3 uSize;
UNIFORM highp vec2 uNinePatchFactorsX[FACTOR_SIZE_X];
UNIFORM highp vec2 uNinePatchFactorsY[FACTOR_SIZE_Y];
- // Visual size and offset
+};
+
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
UNIFORM highp vec2 offset;
UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
- UNIFORM highp vec2 extraSize;
};
void main()
//@version 100
-precision mediump float;
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
//@version 100
-precision mediump float;
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM highp mat4 uMvpMatrix;
UNIFORM float uTextureWidth;
};
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;
//@version 100
-precision mediump float;
+precision highp float;
-INPUT mediump vec2 vTexCoord;
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
UNIFORM vec3 uSize;
};
-INPUT vec3 vNormal;
-INPUT vec4 vPosition;
+INPUT highp vec3 vNormal;
+INPUT highp vec4 vPosition;
void main()
{
* ([3][3]) float currentLength: The length from the current center to the curveEnd.
*/
-precision mediump float;
+precision highp float;
-INPUT mediump vec2 aPosition;
+INPUT highp vec2 aPosition;
UNIFORM_BLOCK VertBlock
{
- 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 float uIsTurningBack;
- UNIFORM float uTextureWidth;
+ UNIFORM highp float uTextureWidth;
};
UNIFORM_BLOCK SharedBlock
{
- UNIFORM vec3 uSize;
+ UNIFORM highp vec3 uSize;
};
-OUTPUT vec3 vNormal;
-OUTPUT vec4 vPosition;
-OUTPUT mediump vec2 vTexCoord;
+OUTPUT highp vec3 vNormal;
+OUTPUT highp vec4 vPosition;
+OUTPUT highp vec2 vTexCoord;
void main()
{
//Very simple fragment shader that merely applies the vertex shading to the color at each fragment.
-precision mediump float;
-INPUT mediump vec3 vIllumination;
+precision highp float;
+
+INPUT highp vec3 vIllumination;
UNIFORM_BLOCK FragBlock
{
//A simple shader that applies diffuse lighting to a mono-coloured object.
+precision highp float;
+
INPUT highp vec3 aPosition;
INPUT highp vec2 aTexCoord;
INPUT highp vec3 aNormal;
-OUTPUT mediump vec3 vIllumination;
+OUTPUT highp vec3 vIllumination;
UNIFORM_BLOCK VertBlock
{
- 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;
-
-//Visual size and offset
- UNIFORM mediump vec2 offset;
- UNIFORM mediump vec2 size;
+ 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;
+};
+
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw ) + extraSize;
float scaleFactor = min( visualSize.x / uObjectDimensions.x, visualSize.y / uObjectDimensions.y );
vec3 originFlipY =vec3(origin.x, -origin.y, 0.0);
vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
//@version 100
precision highp float;
+
INPUT highp vec2 vTexCoord;
INPUT highp vec2 vOptRectSize;
INPUT highp vec4 vCornerRadius;
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uShadowColor;
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
OUTPUT vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump mat4 uModelMatrix;
- UNIFORM vec3 uSize;
- UNIFORM mediump mat4 uLightCameraProjectionMatrix;
- UNIFORM mediump mat4 uLightCameraViewMatrix;
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp mat4 uModelMatrix;
+ UNIFORM highp vec3 uSize;
+ 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;
//@version 100
precision highp float;
-INPUT mediump vec2 vTexCoord;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
UNIFORM_BLOCK FragBlock
{
//@version 100
+precision highp float;
+
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
UNIFORM lowp vec4 textColorAnimatable;
};
UNIFORM sampler2D sTexture;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec4 vColor;
+INPUT highp vec2 vTexCoord;
+INPUT highp vec4 vColor;
void main()
{
//@version 100
+precision highp float;
+
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
UNIFORM lowp vec4 textColorAnimatable;
};
UNIFORM sampler2D sTexture;
-INPUT mediump vec2 vTexCoord;
+INPUT highp vec2 vTexCoord;
void main()
{
//@version 100
+precision highp float;
+
INPUT highp vec2 aPosition;
-INPUT mediump vec2 aTexCoord;
-INPUT mediump vec4 aColor;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec4 aColor;
UNIFORM_BLOCK VertBlock
{
- UNIFORM mediump vec2 uOffset;
+ UNIFORM highp vec2 uOffset;
UNIFORM highp mat4 uMvpMatrix;
};
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec4 vColor;
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec4 vColor;
void main()
{
//@version 100
-INPUT mediump vec4 vColor;
+precision highp float;
+
+INPUT highp vec4 vColor;
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
//@version 100
-INPUT mediump vec2 aPosition;
-INPUT mediump vec4 aColor;
-OUTPUT mediump vec4 vColor;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+INPUT highp vec4 aColor;
+OUTPUT highp vec4 vColor;
UNIFORM_BLOCK VertBlock
{
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;
}
//@version 100
+precision highp float;
+
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
UNIFORM_BLOCK VertBlock
{
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;
}
//@version 100
+precision highp float;
+
INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
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;
+};
+UNIFORM_BLOCK VisualVertBlock
+{
//Visual size and offset
- UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 offset;
UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
};
+
void main()
{
- highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw);
+ highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw) + extraSize;
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;
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM sampler2D sTexture;
#ifdef IS_REQUIRED_STYLE
UNIFORM sampler2D sStyle;
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp mat4 uMvpMatrix;
UNIFORM highp vec3 uSize;
+};
+UNIFORM_BLOCK VisualVertBlock
+{
//Visual size and offset
- UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 offset;
UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
return vec4( (aPosition + anchorPoint) * visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0 );
}
//@version 100
-INPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 vTexCoord;
UNIFORM samplerExternalOES sTexture;
UNIFORM_BLOCK FragBlock
//@version 100
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+precision highp float;
+
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp mat4 uMvpMatrix;
UNIFORM highp vec2 uSizeRatio;
UNIFORM highp mat2 uRotationMatrix;
};
-OUTPUT mediump vec2 sTexCoordRect;
highp vec2 getSize(highp vec2 size)
{
//@version 100
+precision highp float;
+
void main()
{
gl_FragColor = vec4(0.0);
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp mat4 uMvpMatrix;
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;
}
//@version 100
+precision highp float;
+
UNIFORM_BLOCK FragBlock
{
UNIFORM lowp vec4 uColor;
//@version 100
-INPUT mediump vec2 aPosition;
+precision highp float;
+
+INPUT highp vec2 aPosition;
UNIFORM_BLOCK VertBlock
{
UNIFORM highp mat4 uMvpMatrix;
UNIFORM highp vec3 uSize;
+};
-//Visual size and offset
- UNIFORM mediump vec2 offset;
- UNIFORM highp vec2 size;
+UNIFORM_BLOCK VisualVertBlock
+{
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM highp vec2 extraSize;
UNIFORM mediump vec4 offsetSizeMode;
UNIFORM mediump vec2 origin;
UNIFORM mediump vec2 anchorPoint;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw );
+ vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw ) + extraSize;
vec2 visualOffset = mix(offset * uSize.xy, offset, offsetSizeMode.xy);
return vec4( (aPosition + anchorPoint)*visualSize + visualOffset + origin * uSize.xy, 0.0, 1.0 );
}
projects / platform / core / uifw / dali-toolkit.git / commitdiff