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

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