forked from enlightenment/efl
255 lines
7.0 KiB
Plaintext
255 lines
7.0 KiB
Plaintext
`#ifdef GL_ES
|
|
precision mediump float;
|
|
precision mediump int;
|
|
precision lowp sampler2D;
|
|
#endif'
|
|
|
|
define(`FRAGMENT_SHADER_USE_TEX_COORD',`
|
|
#ifdef NEED_TEX_COORD
|
|
varying vec2 vTexCoord;
|
|
#endif //TEX_COORD')
|
|
|
|
define(`FRAGMENT_SHADER_USE_TEXTURE', `
|
|
#ifdef $1_TEXTURE
|
|
uniform sampler2D uTexture$2`0';
|
|
uniform mat3 uTextureMatrixTransform$2`0';
|
|
#endif //$1_TEXTURE
|
|
#ifdef $1_TEXTURE_BLEND
|
|
uniform sampler2D uTexture$2`1';
|
|
uniform float uTexture$2Weight;
|
|
uniform mat3 uTextureMatrixTransform$2`1';
|
|
#endif //$1_TEXTURE_BLEND')
|
|
|
|
define(`FRAGMENT_SHADER_USE_FOG', `
|
|
#ifdef FOG_ENABLED
|
|
uniform float uFogFactor;
|
|
uniform vec4 uFogColor;
|
|
#endif //FOG_ENABLED')
|
|
define(`FRAGMENT_SHADER_USE_ALPHA_TEST_GLES',
|
|
uniform int uAlphaTestComparison;
|
|
uniform float uAlphaTestRefValue;)
|
|
|
|
define(`FRAGMENT_SHADER_USE_SHADOWS', `
|
|
#ifdef SHADOWED
|
|
varying vec4 vLightPosition;
|
|
uniform sampler2D uShadowMap;
|
|
uniform float uShadowsPCFStep;
|
|
uniform float uShadowsPCFSize;
|
|
uniform float uShadowsConstantBias;
|
|
float shadow;
|
|
float pcf(vec4 lpos)
|
|
{
|
|
vec3 smcoord = lpos.xyz / lpos.w * 0.5 + 0.5;
|
|
float i, j, shadow, q, c;
|
|
q = floor(uShadowsPCFStep * 2.0);
|
|
c = floor(uShadowsPCFStep * uShadowsPCFStep * 4.0);
|
|
shadow = 0.0;
|
|
const vec4 unpack = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);
|
|
for (i = -uShadowsPCFStep; i < uShadowsPCFStep; i += 1.0)
|
|
for (j = -uShadowsPCFStep; j < uShadowsPCFStep; j += 1.0)
|
|
{
|
|
vec4 zvalue = texture2D(uShadowMap, smcoord.xy + vec2(i / q, j / q) * uShadowsPCFSize);
|
|
shadow += float(smcoord.z < dot(zvalue, unpack) + uShadowsConstantBias);
|
|
}
|
|
return shadow / c;
|
|
}
|
|
#endif //SHADOWED')
|
|
|
|
define(`FRAGMENT_SHADER_FOG_APPLY', `
|
|
#ifdef FOG_ENABLED
|
|
float z = gl_FragCoord.z / gl_FragCoord.w;
|
|
float fogFactor = exp2(-uFogFactor * uFogFactor * z * z * 1.44);
|
|
fogFactor = clamp(fogFactor, 0.0, 1.0);
|
|
gl_FragColor = mix(uFogColor, gl_FragColor, fogFactor);
|
|
#endif //FOG_ENABLED')
|
|
|
|
define(`FRAGMENT_SHADER_USE_LIGHT', `
|
|
#ifdef LIGHT_SPOT
|
|
uniform vec3 uLightSpotDir;
|
|
uniform float uLightSpotExp;
|
|
uniform float uLightSpotCutoffCos;
|
|
#endif //LIGHT_SPOT
|
|
#ifdef LIGHT_ATTENUATION
|
|
varying float vLightDist;
|
|
#endif //LIGHT_ATTENUATION')
|
|
|
|
define(`FRAGMENT_SHADER_TEXTURE_BLEND', `
|
|
#ifdef $1_TEXTURE_BLEND
|
|
vec3 Tex0Coord$2 = vec3(vTexCoord, 1.0) * uTextureMatrixTransform$2`0';
|
|
vec3 Tex1Coord$2 = vec3(vTexCoord, 1.0) * uTextureMatrixTransform$2`1';
|
|
color = mix(texture2D(uTexture$2`1', vec2(Tex1Coord$2)),
|
|
texture2D(uTexture$2`0', vec2(Tex0Coord$2)), uTexture$2Weight);
|
|
color *= uMaterial$2;
|
|
#else
|
|
#ifdef $1_TEXTURE
|
|
vec3 Tex0Coord$2 = vec3(vTexCoord, 1.0) * uTextureMatrixTransform$2`0';
|
|
color = texture2D(uTexture$2`0', vec2(Tex0Coord$2)) * uMaterial$2;
|
|
#else
|
|
color = uMaterial$2;
|
|
#endif //$1_TEXTURE
|
|
#endif //$1_TEXTURE_BLEND')
|
|
|
|
define(`FRAGMENT_SHADER_USE_EMISSION_TERM',
|
|
`#ifdef EMISSION'
|
|
uniform vec4 uMaterialEmission;
|
|
FRAGMENT_SHADER_USE_TEXTURE(EMISSION, Emission)
|
|
`#endif //EMISSION')
|
|
|
|
define(`FRAGMENT_SHADER_USE_SPECULAR_TERM',
|
|
`#ifdef SPECULAR'
|
|
uniform vec4 uLightSpecular;
|
|
uniform float uMaterialShininess;
|
|
uniform vec4 uMaterialSpecular;
|
|
FRAGMENT_SHADER_USE_TEXTURE(SPECULAR, Specular)
|
|
`#endif //SPECULAR')
|
|
|
|
define(`FRAGMENT_SHADER_USE_AMBIENT_TERM',
|
|
`#ifdef AMBIENT'
|
|
uniform vec4 uMaterialAmbient;
|
|
uniform vec4 uLightAmbient;
|
|
FRAGMENT_SHADER_USE_TEXTURE(AMBIENT, Ambient)
|
|
`#endif //AMBIENT')
|
|
|
|
define(`FRAGMENT_SHADER_USE_DIFFUSE_TERM',
|
|
`#ifdef DIFFUSE'
|
|
uniform vec4 uMaterialDiffuse;
|
|
uniform vec4 uLightDiffuse;
|
|
FRAGMENT_SHADER_USE_TEXTURE(DIFFUSE, Diffuse)
|
|
`#endif //DIFFUSE')
|
|
|
|
define(`FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY',
|
|
/*uAlphaTestComparison is value of the Evas_3D_Comparison type*/
|
|
const float p = 1000000.0;
|
|
float acolor = floor($1.a * p);
|
|
float refvalue = floor(uAlphaTestRefValue * p);
|
|
if (uAlphaTestComparison == 0) discard;
|
|
else if (uAlphaTestComparison == 1)
|
|
{
|
|
if (acolor < refvalue) gl_FragColor = $1;
|
|
else discard;
|
|
}
|
|
else if (uAlphaTestComparison == 2)
|
|
{
|
|
if (acolor == refvalue) gl_FragColor = $1;
|
|
else discard;
|
|
}
|
|
else if (uAlphaTestComparison == 3)
|
|
{
|
|
if (acolor <= refvalue) gl_FragColor = $1;
|
|
else discard;
|
|
}
|
|
else if (uAlphaTestComparison == 4)
|
|
{
|
|
if (acolor > refvalue) gl_FragColor = $1;
|
|
else discard;
|
|
}
|
|
else if (uAlphaTestComparison == 5)
|
|
{
|
|
if (acolor != refvalue) gl_FragColor = $1;
|
|
else discard;
|
|
}
|
|
else if (uAlphaTestComparison == 6)
|
|
{
|
|
if (acolor >= refvalue) gl_FragColor = $1;
|
|
else discard;
|
|
}
|
|
else if (uAlphaTestComparison == 7) ;)
|
|
|
|
|
|
define(`VERTEX_SHADER_NEED_TEX_COORD',
|
|
`#ifdef NEED_TEX_COORD'
|
|
varying vec2 vTexCoord;
|
|
`#endif //NEED_TEX_COORD')
|
|
|
|
define(`VERTEX_SHADER_USE_LIGHT_ATTENUATION',
|
|
`#ifdef LIGHT_ATTENUATION'
|
|
varying float vLightDist;
|
|
`#endif //LIGHT_ATTENUATION')
|
|
|
|
define(`VERTEX_SHADER_USE_SHADOWS',
|
|
`#ifdef SHADOWED'
|
|
uniform mat4 uMatrixLight;
|
|
varying vec4 vLightPosition;
|
|
`#endif //SHADOWED')
|
|
|
|
define(`VERTEX_SHADER_USE_POSITION',
|
|
`#ifdef VERTEX_POSITION'
|
|
attribute vec4 aPosition0;
|
|
`#endif //VERTEX_POSITION'
|
|
|
|
`#ifdef VERTEX_POSITION_BLEND'
|
|
attribute vec4 aPosition1;
|
|
uniform float uPositionWeight;
|
|
`#endif //VERTEX_POSITION_BLEND')
|
|
|
|
define(`VERTEX_SHADER_USE_NORMALS',
|
|
`#ifdef VERTEX_NORMAL'
|
|
attribute vec4 aNormal0;
|
|
`#endif //VERTEX_NORMAL'
|
|
|
|
`#ifdef VERTEX_NORMAL_BLEND'
|
|
attribute vec4 aNormal1;
|
|
uniform float uNormalWeight;
|
|
`#endif //VERTEX_NORMAL_BLEND'
|
|
)
|
|
|
|
define(`VERTEX_SHADER_USE_TEXCOORD',
|
|
`#ifdef VERTEX_TEXCOORD'
|
|
attribute vec4 aTexCoord0;
|
|
`#endif //VERTEX_TEXCOORD'
|
|
|
|
`#ifdef VERTEX_TEXCOORD_BLEND'
|
|
attribute vec4 aTexCoord1;
|
|
uniform float uTexCoordWeight;
|
|
`#endif //VERTEX_TEXCOORD_BLEND'
|
|
)
|
|
|
|
define(`VERTEX_SHADER_USE_COLOR',
|
|
`#ifdef VERTEX_COLOR'
|
|
attribute vec4 aColor0;
|
|
`#endif //VERTEX_COLOR'
|
|
|
|
`#ifdef VERTEX_COLOR_BLEND'
|
|
attribute vec4 aColor1;
|
|
uniform float uColorWeight;
|
|
`#endif //VERTEX_COLOR_BLEND')
|
|
|
|
define(`VERTEX_SHADER_POSITION',
|
|
`#ifdef VERTEX_POSITION_BLEND'
|
|
vec4 position = mix(aPosition1, aPosition0, uPositionWeight);
|
|
position = vec4(position.xyz, 1.0);
|
|
`#else'
|
|
|
|
`#ifdef VERTEX_POSITION'
|
|
vec4 position = vec4(aPosition0.xyz, 1.0);
|
|
`#endif // VERTEX_POSITION'
|
|
|
|
`#endif //VERTEX_POSITION_BLEND')
|
|
|
|
define(`VERTEX_SHADER_NORMAL',
|
|
`#ifdef VERTEX_NORMAL_BLEND'
|
|
vec3 normal = mix(aNormal1.xyz, aNormal0.xyz, uNormalWeight);
|
|
`#else'
|
|
|
|
`#ifdef VERTEX_NORMAL'
|
|
vec3 normal = aNormal0.xyz;
|
|
`#endif //VERTEX_NORMAL'
|
|
`#endif //VERTEX_NORMAL_BLEND')
|
|
|
|
define(`VERTEX_SHADER_TEXCOORD',
|
|
`#ifdef VERTEX_TEXCOORD_BLEND'
|
|
vTexCoord = mix(vec2(aTexCoord1.s, 1.0 - aTexCoord1.t),
|
|
vec2(aTexCoord0.s, 1.0 - aTexCoord0.t), uTexCoordWeight);
|
|
`#else'
|
|
|
|
`#ifdef VERTEX_TEXCOORD'
|
|
vTexCoord = vec2(aTexCoord0.s, 1.0 - aTexCoord0.t);
|
|
`#endif //VERTEX_TEXCOORD'
|
|
|
|
`#endif //VERTEX_TEXCOORD_BLEND')
|
|
|
|
define(`VERTEX_SHADER_SHADOWED',
|
|
`#ifdef SHADOWED'
|
|
vLightPosition = uMatrixLight * position;
|
|
`#endif //SHADOWED')
|