The Ecere SDK - sdk/blob - ecere/src/gfx/drivers/gl3/default.frag

   1 #if GLSL_FLOAT_PRECISION
   2 precision highp float;
   3 #endif
   4
   5 #if LIGHTING_ON
   6    #if PER_VERTEX_COLOR
   7       varying vec4 diffuseColor;
   8       varying vec3 ambientColor;
   9    #else
  10       uniform vec4 matDiffuse;
  11       uniform vec3 matAmbient;
  12    #endif
  13    varying vec3 tNormal;
  14 #if NORMALS_MAPPING
  15    varying vec3 tTangent1;
  16    varying vec3 tTangent2;
  17 #endif
  18
  19 #if ENVIRONMENT_MAPPING || (LIGHTING_ON && ((!NON_LOCAL_VIEWER && MAT_SPECULAR) || (LIGHT0_POSITIONAL || LIGHT1_POSITIONAL || LIGHT2_POSITIONAL || LIGHT3_POSITIONAL || LIGHT4_POSITIONAL || LIGHT5_POSITIONAL || LIGHT6_POSITIONAL || LIGHT7_POSITIONAL)))
  20    varying vec3 nnEyeToSurface;
  21 #endif
  22
  23 #if MAT_SPECULAR
  24
  25    // Materials
  26    uniform vec3 matSpecular;
  27    uniform float matPower;
  28 #endif
  29
  30    uniform vec3 matEmissive;
  31
  32    // Lights
  33    uniform vec3 lightsPos[NUM_LIGHTS];
  34    uniform vec3 lightsAtt[NUM_LIGHTS];
  35
  36    uniform vec3 lightsSpotDir[NUM_LIGHTS];
  37    uniform float lightsSpotCutOffCos[NUM_LIGHTS];
  38    uniform float lightsSpotExp[NUM_LIGHTS];
  39
  40    uniform vec3 lightsDiffuse[NUM_LIGHTS];
  41    uniform vec3 lightsAmbient[NUM_LIGHTS];
  42    uniform vec3 lightsSpecular[NUM_LIGHTS];
  43
  44    uniform vec3 globalAmbient;
  45 #elif PER_VERTEX_COLOR
  46    varying vec4 fColor;
  47 #else
  48    uniform vec4 matDiffuse;
  49 #endif
  50
  51 #if ENVIRONMENT_MAPPING
  52    uniform samplerCube envTex;
  53    uniform mat3 cubemap_matrix;
  54
  55    #if ENVIRONMENT_REFLECTION
  56       uniform float matReflectivity;
  57    #endif
  58
  59    #if ENVIRONMENT_MAPPING
  60       uniform float matRefractionETA;
  61    #endif
  62
  63 #endif
  64
  65 #if TEXTURE_ON || NORMALS_MAPPING || SPECULAR_MAPPING || REFLECTION_MAP || CUBEMAP_ON
  66
  67    #if SPECULAR_MAPPING
  68       uniform sampler2D specularTex;
  69    #endif
  70
  71    #if CUBEMAP_ON
  72       uniform samplerCube diffuseTex;
  73       varying vec3 fTexCoord;
  74    #else
  75       varying vec2 fTexCoord;
  76    #endif
  77
  78    #if TEXTURE_ON
  79       uniform sampler2D diffuseTex;
  80    #endif
  81
  82    #if NORMALS_MAPPING
  83       uniform sampler2D bumpTex;
  84    #endif
  85
  86    #if REFLECTION_MAP
  87       uniform sampler2D reflectTex;
  88    #endif
  89
  90    #if TEXTURE_MATRIX
  91       uniform mat4 texture_matrix;
  92    #endif
  93 #endif
  94
  95 #if FOG_ON
  96    uniform vec3 fogColor;
  97    varying float fogZ;
  98 #endif
  99
 100 #if LIGHTING_ON
 101 void computeLight(vec3 light, vec3 n, vec3 eye, inout vec3 ambient, inout vec3 diffuse, inout vec3 specular,
 102    bool isPositional, bool isSpot, bool doAttenuation, vec3 spotDir, float spotCutOffCos, float spotExp, vec3 att,
 103    vec3 lightAmbient, vec3 lightDiffuse, vec3 lightSpecular)
 104 {
 105    float nDotL, attenuation = 1.0;
 106 #if MAT_SPECULAR
 107    float pf = 0.0;
 108 #endif
 109    vec3 l;
 110    float d;
 111
 112    if(isPositional && doAttenuation)
 113    {
 114       d = length(light);
 115       l = light / d;
 116    }
 117    else
 118       l = normalize(light);
 119
 120    if(isPositional && isSpot)
 121    {
 122       float spotDot = dot(l, spotDir);
 123       attenuation = (spotDot < spotCutOffCos) ? 0.0 : pow(max(0.0, spotDot), spotExp);
 124    }
 125
 126    nDotL = max(0.0, dot(n, l));
 127
 128    if(isPositional && doAttenuation)
 129       attenuation /= (att.x + att.y * d + att.z * d * d);
 130
 131 #if MAT_SPECULAR
 132    {
 133    #if LIGHTING_SPECULAR_BLINN
 134       float nDotHV = dot(n, normalize(l + eye));
 135       if(nDotL > 0.0)
 136    #else
 137       float nDotHV = dot(reflect(-l, n), eye);
 138    #endif
 139       pf = pow(max(0.0, nDotHV), matPower);
 140    }
 141 #endif
 142
 143    ambient  += lightAmbient  * attenuation;
 144    diffuse  += lightDiffuse  * attenuation * nDotL;
 145 #if MAT_SPECULAR
 146    specular += lightSpecular * attenuation * pf;
 147 #endif
 148 }
 149 #endif
 150
 151 void main(void)
 152 {
 153    vec4 c;
 154
 155 #if CUBEMAP_ON
 156    vec3 texCoord;
 157    #if TEXTURE_MATRIX
 158        texCoord = (vec4(fTexCoord, 1) * texture_matrix).xyz;
 159    #else
 160        texCoord = fTexCoord;
 161    #endif
 162 #endif
 163
 164 #if NORMALS_MAPPING || TEXTURE_ON || SPECULAR_MAPPING || REFLECTION_MAP
 165    vec2 texCoord;
 166    #if TEXTURE_MATRIX
 167        texCoord = (vec4(fTexCoord, 0, 1) * texture_matrix).xy;
 168    #else
 169        texCoord = fTexCoord;
 170    #endif
 171 #endif
 172
 173 #if LIGHTING_ON || ENVIRONMENT_MAPPING
 174    vec3 n;
 175 #endif
 176
 177 #if LIGHTING_ON && !PER_VERTEX_COLOR
 178    vec4 diffuseColor = matDiffuse;
 179    vec3 ambientColor = matAmbient;
 180 #endif
 181
 182 #if ENVIRONMENT_MAPPING || (LIGHTING_ON && !NON_LOCAL_VIEWER && MAT_SPECULAR)
 183    vec3 eyeToSurface = normalize(nnEyeToSurface);
 184 #endif
 185
 186 #if LIGHTING_ON
 187    vec3 lights[NUM_LIGHTS];
 188    vec3 diffuse = vec3(0), ambient = vec3(0), specular = vec3(0);
 189    {
 190    #if !NON_LOCAL_VIEWER && MAT_SPECULAR
 191       vec3 lEye = -eyeToSurface;
 192    #else
 193       vec3 lEye = vec3(0.0, 0.0, 1.0);
 194    #endif
 195
 196    #if NORMALS_MAPPING
 197       mat3 tbn = mat3(normalize(tTangent1), normalize(tTangent2), normalize(tNormal));
 198       n = tbn * (2.0 * vec3(texture2D(bumpTex, texCoord)) - 1.0);
 199       // n = tbn * (2.0 * vec3(0.5, 0.5, 1.0) - 1.0);
 200    #else
 201       n = normalize(tNormal);
 202    #endif
 203
 204       #if NUM_LIGHTS > 0 && LIGHT0_ON && LIGHT0_POSITIONAL
 205          lights[0] = lightsPos[0] - nnEyeToSurface;
 206       #endif
 207       #if NUM_LIGHTS > 1 && LIGHT1_ON && LIGHT1_POSITIONAL
 208          lights[1] = lightsPos[1] - nnEyeToSurface;
 209       #endif
 210       #if NUM_LIGHTS > 2 && LIGHT2_ON && LIGHT2_POSITIONAL
 211          lights[2] = lightsPos[2] - nnEyeToSurface;
 212       #endif
 213       #if NUM_LIGHTS > 3 && LIGHT3_ON && LIGHT3_POSITIONAL
 214          lights[3] = lightsPos[3] - nnEyeToSurface;
 215       #endif
 216       #if NUM_LIGHTS > 4 && LIGHT4_ON && LIGHT4_POSITIONAL
 217          lights[4] = lightsPos[4] - nnEyeToSurface;
 218       #endif
 219       #if NUM_LIGHTS > 5 && LIGHT5_ON && LIGHT5_POSITIONAL
 220          lights[5] = lightsPos[5] - nnEyeToSurface;
 221       #endif
 222       #if NUM_LIGHTS > 6 && LIGHT6_ON && LIGHT6_POSITIONAL
 223          lights[6] = lightsPos[6] - nnEyeToSurface;
 224       #endif
 225       #if NUM_LIGHTS > 7 && LIGHT7_ON && LIGHT7_POSITIONAL
 226          lights[7] = lightsPos[7] - nnEyeToSurface;
 227       #endif
 228
 229    #if MAT_TWOSIDED
 230       if(!gl_FrontFacing) n = -n;
 231    #endif
 232
 233    #if NUM_LIGHTS > 0 && LIGHT0_ON
 234       computeLight(bool(LIGHT0_POSITIONAL) ? lights[0] : lightsPos[0], n, lEye, ambient, diffuse, specular,
 235          bool(LIGHT0_POSITIONAL), bool(LIGHT0_SPOT), bool(LIGHT0_ATT),
 236          bool(LIGHT0_SPOT) ? lightsSpotDir[0] : vec3(0), bool(LIGHT0_SPOT) ? lightsSpotCutOffCos[0] : 0.0, bool(LIGHT0_SPOT) ? lightsSpotExp[0] : 0.0,
 237          bool(LIGHT0_ATT) ? lightsAtt[0] : vec3(1,0,0),
 238          lightsAmbient[0], lightsDiffuse[0], lightsSpecular[0]);
 239    #endif
 240    #if NUM_LIGHTS > 1 && LIGHT1_ON
 241       computeLight(bool(LIGHT1_POSITIONAL) ? lights[1] : lightsPos[1], n, lEye, ambient, diffuse, specular,
 242          bool(LIGHT1_POSITIONAL), bool(LIGHT1_SPOT), bool(LIGHT1_ATT),
 243          bool(LIGHT1_SPOT) ? lightsSpotDir[1] : vec3(0), bool(LIGHT1_SPOT) ? lightsSpotCutOffCos[1] : 0.0, bool(LIGHT1_SPOT) ? lightsSpotExp[1] : 0.0,
 244          bool(LIGHT1_ATT) ? lightsAtt[1] : vec3(1,0,0),
 245          lightsAmbient[1], lightsDiffuse[1], lightsSpecular[1]);
 246    #endif
 247    #if NUM_LIGHTS > 2 && LIGHT2_ON
 248       computeLight(bool(LIGHT2_POSITIONAL) ? lights[2] : lightsPos[2], n, lEye, ambient, diffuse, specular,
 249          bool(LIGHT2_POSITIONAL), bool(LIGHT2_SPOT), bool(LIGHT2_ATT),
 250          bool(LIGHT2_SPOT) ? lightsSpotDir[2] : vec3(0), bool(LIGHT2_SPOT) ? lightsSpotCutOffCos[2] : 0.0, bool(LIGHT2_SPOT) ? lightsSpotExp[2] : 0.0,
 251          bool(LIGHT2_ATT) ? lightsAtt[2] : vec3(1,0,0),
 252          lightsAmbient[2], lightsDiffuse[2], lightsSpecular[2]);
 253    #endif
 254    #if NUM_LIGHTS > 3 && LIGHT3_ON
 255       computeLight(bool(LIGHT3_POSITIONAL) ? lights[3] : lightsPos[3], n, lEye, ambient, diffuse, specular,
 256          bool(LIGHT3_POSITIONAL), bool(LIGHT3_SPOT), bool(LIGHT3_ATT),
 257          bool(LIGHT3_SPOT) ? lightsSpotDir[3] : vec3(0), bool(LIGHT3_SPOT) ? lightsSpotCutOffCos[3] : 0.0, bool(LIGHT3_SPOT) ? lightsSpotExp[3] : 0.0,
 258          bool(LIGHT3_ATT) ? lightsAtt[3] : vec3(1,0,0),
 259          lightsAmbient[3], lightsDiffuse[3], lightsSpecular[3]);
 260    #endif
 261    #if NUM_LIGHTS > 4 && LIGHT4_ON
 262       computeLight(bool(LIGHT4_POSITIONAL) ? lights[4] : lightsPos[4], n, lEye, ambient, diffuse, specular,
 263          bool(LIGHT4_POSITIONAL), bool(LIGHT4_SPOT), bool(LIGHT4_ATT),
 264          bool(LIGHT4_SPOT) ? lightsSpotDir[4] : vec3(0), bool(LIGHT4_SPOT) ? lightsSpotCutOffCos[4] : 0.0, bool(LIGHT4_SPOT) ? lightsSpotExp[4] : 0.0,
 265          bool(LIGHT4_ATT) ? lightsAtt[4] : vec3(1,0,0),
 266          lightsAmbient[4], lightsDiffuse[4], lightsSpecular[4]);
 267    #endif
 268    #if NUM_LIGHTS > 5 && LIGHT5_ON
 269       computeLight(bool(LIGHT5_POSITIONAL) ? lights[5] : lightsPos[5], n, lEye, ambient, diffuse, specular,
 270          bool(LIGHT5_POSITIONAL), bool(LIGHT5_SPOT), bool(LIGHT5_ATT),
 271          bool(LIGHT5_SPOT) ? lightsSpotDir[5] : vec3(0), bool(LIGHT5_SPOT) ? lightsSpotCutOffCos[5] : 0.0, bool(LIGHT5_SPOT) ? lightsSpotExp[5] : 0.0,
 272          bool(LIGHT5_ATT) ? lightsAtt[5] : vec3(1,0,0),
 273          lightsAmbient[5], lightsDiffuse[5], lightsSpecular[5]);
 274    #endif
 275    #if NUM_LIGHTS > 6 && LIGHT6_ON
 276       computeLight(bool(LIGHT6_POSITIONAL) ? lights[6] : lightsPos[6], n, lEye, ambient, diffuse, specular,
 277          bool(LIGHT6_POSITIONAL), bool(LIGHT6_SPOT), bool(LIGHT6_ATT),
 278          bool(LIGHT6_SPOT) ? lightsSpotDir[6] : vec3(0), bool(LIGHT6_SPOT) ? lightsSpotCutOffCos[6] : 0.0, bool(LIGHT6_SPOT) ? lightsSpotExp[6] : 0.0,
 279          bool(LIGHT6_ATT) ? lightsAtt[6] : vec3(1,0,0),
 280          lightsAmbient[6], lightsDiffuse[6], lightsSpecular[6]);
 281    #endif
 282    #if NUM_LIGHTS > 7 && LIGHT7_ON
 283       computeLight(bool(LIGHT7_POSITIONAL) ? lights[7] : lightsPos[7], n, lEye, ambient, diffuse, specular,
 284          bool(LIGHT7_POSITIONAL), bool(LIGHT7_SPOT), bool(LIGHT7_ATT),
 285          bool(LIGHT7_SPOT) ? lightsSpotDir[7] : vec3(0), bool(LIGHT7_SPOT) ? lightsSpotCutOffCos[7] : 0.0, bool(LIGHT7_SPOT) ? lightsSpotExp[7] : 0.0,
 286          bool(LIGHT7_ATT) ? lightsAtt[7] : vec3(1,0,0),
 287          lightsAmbient[7], lightsDiffuse[7], lightsSpecular[7]);
 288    #endif
 289
 290    #if MAT_SPECULAR && SPECULAR_MAPPING
 291       vec3 specTexel = vec3(texture2D(specularTex, texCoord));
 292       specular *= vec3(specTexel.r, specTexel.r, specTexel.r);
 293    #endif
 294
 295       c = vec4(min(vec3(1.0),
 296             ambientColor * (ambient + globalAmbient) + diffuseColor.xyz * diffuse + matEmissive
 297    #if MAT_SPECULAR && !MAT_SEPARATE_SPECULAR
 298             + matSpecular * specular
 299    #endif
 300          ), diffuseColor.w);
 301    }
 302 #elif PER_VERTEX_COLOR
 303    c = fColor;
 304 #else
 305    c = matDiffuse;
 306 #endif
 307
 308 #if TEXTURE_ON
 309    vec4 texel;
 310    texel = texture2D(diffuseTex, texCoord);
 311    #if SWIZZLE_ALPHA
 312       texel = vec4(1,1,1,texel.a);
 313    #elif SWIZZLE_RED
 314       texel = vec4(1,1,1,texel.r);
 315    #endif
 316    c *= texel;
 317 #elif CUBEMAP_ON
 318    vec4 texel;
 319    texel = textureCube(diffuseTex, texCoord);
 320    #if SWIZZLE_ALPHA
 321       texel = vec4(1,1,1,texel.a);
 322    #elif SWIZZLE_RED
 323       texel = vec4(1,1,1,texel.r);
 324    #endif
 325    c *= texel;
 326 #endif
 327
 328 #if ENVIRONMENT_MAPPING
 329    vec3 v;
 330    #if ENVIRONMENT_REFRACTION
 331    {
 332       float opacity = c.w;
 333       v = refract(eyeToSurface, n, matRefractionETA);
 334       c = vec4(opacity * c + (1.0 - opacity) * textureCube(envTex, vec3(cubemap_matrix * v)));
 335    }
 336    #endif
 337
 338    #if ENVIRONMENT_REFLECTION
 339    {
 340       float reflectivity = matReflectivity;
 341    #if REFLECTION_MAP
 342       reflectivity *= texture2D(reflectTex, texCoord).r;
 343    #endif
 344       v = reflect(eyeToSurface, n);
 345       c = (1.0 - reflectivity) * c + reflectivity * textureCube(envTex, vec3(cubemap_matrix * v));
 346    }
 347    #endif
 348 #endif
 349
 350 #if LIGHTING_ON && MAT_SPECULAR && MAT_SEPARATE_SPECULAR
 351    c = min(vec4(1.0), vec4(vec3(c) + matSpecular * specular, 1.0));
 352 #endif
 353
 354 #if FOG_ON
 355    {
 356       float fog = clamp(exp(fogZ), 0.0, 1.0);
 357       c = vec4(fog * c.xyz + (1.0 - fog) * fogColor, c.w);
 358    }
 359 #endif
 360
 361 #ifdef LIMITED_COLORS
 362    #define LIMITED_MULTIPLIER    10.0
 363    #define LIMITED_MODULO        2.0
 364
 365    c.x -= mod(c.x * LIMITED_MULTIPLIER, LIMITED_MODULO) / LIMITED_MULTIPLIER;
 366    c.y -= mod(c.y * LIMITED_MULTIPLIER, LIMITED_MODULO) / LIMITED_MULTIPLIER;
 367    c.z -= mod(c.z * LIMITED_MULTIPLIER, LIMITED_MODULO) / LIMITED_MULTIPLIER;
 368 #endif
 369
 370 #if DEBUGGING
 371    //c = vec4(0.5 * (n + 1.0), 1.0);
 372
 373    #if NORMALS_MAPPING
 374       //c = vec4(0.5 * (normalize(-tNormal) + 1.0), 1.0);
 375       //c = vec4(0.5 * (normalize(tTangent1) + 1.0), 1.0);
 376       //c = vec4(0.5 * (normalize(tTangent2) + 1.0), 1.0);
 377    #endif
 378    //c = c * 0.5;
 379    //c = vec4(vec3(c), 0.5);
 380
 381    #if NORMALS_MAPPING
 382       //c = vec4((vec3(n.x + 1.0, n.y + 1.0, n.z + 1.0) / 2.0), 1.0);
 383       //c = texture2D(bumpTex, fTexCoord);
 384    #endif
 385    #if TEXTURE_ON || NORMALS_MAPPING || SPECULAR_MAPPING || REFLECTION_MAP
 386       //c = vec4(texCoord.x, texCoord.y, 0.0, 1.0);
 387    #endif
 388
 389
 390    #if MAT_SPECULAR
 391       #if !NON_LOCAL_VIEWER
 392          //c = vec4((vec3(0.0, eyeToSurface.y + 1.0, 0.0) / 2.0), 1.0);
 393
 394          //c = vec4((n / 2.0) + vec3(0.5), 1.0);
 395
 396          #if ENVIRONMENT_MAPPING
 397             // c = vec4((v / 2.0) + vec3(0.5), 1.0);
 398          #endif
 399       #endif
 400    #endif
 401 #endif
 402
 403    gl_FragColor = c;
 404 }