data/glsl/default.glsl

   1 // ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader
   2 // written by Forest 'LordHavoc' Hale
   3
   4 // common definitions between vertex shader and fragment shader:
   5
   6 #ifdef __GLSL_CG_DATA_TYPES
   7 #define myhalf half
   8 #define myhvec2 hvec2
   9 #define myhvec3 hvec3
  10 #else
  11 #define myhalf float
  12 #define myhvec2 vec2
  13 #define myhvec3 vec3
  14 #endif
  15
  16
  17 varying vec2 TexCoord;
  18 varying vec2 TexCoordLightmap;
  19
  20 varying vec3 CubeVector;
  21 varying vec3 LightVector;
  22 varying vec3 EyeVector;
  23 #ifdef USEFOG
  24 varying vec3 EyeVectorModelSpace;
  25 #endif
  26
  27 varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)
  28 varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)
  29 varying vec3 VectorR; // direction of R texcoord (surface normal)
  30
  31
  32
  33
  34 // vertex shader specific:
  35 #ifdef VERTEX_SHADER
  36
  37 uniform vec3 LightPosition;
  38 uniform vec3 EyePosition;
  39 uniform vec3 LightDir;
  40
  41 // TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)
  42
  43 void main(void)
  44 {
  45         gl_FrontColor = gl_Color;
  46         // copy the surface texcoord
  47         TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);
  48 #if !defined(MODE_LIGHTSOURCE) && !defined(MODE_LIGHTDIRECTION)
  49         TexCoordLightmap = vec2(gl_MultiTexCoord4);
  50 #endif
  51
  52 #ifdef MODE_LIGHTSOURCE
  53         // transform vertex position into light attenuation/cubemap space
  54         // (-1 to +1 across the light box)
  55         CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);
  56
  57         // transform unnormalized light direction into tangent space
  58         // (we use unnormalized to ensure that it interpolates correctly and then
  59         //  normalize it per pixel)
  60         vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;
  61         LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);
  62         LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);
  63         LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);
  64 #endif
  65
  66 #ifdef MODE_LIGHTDIRECTION
  67         LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);
  68         LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);
  69         LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);
  70 #endif
  71
  72         // transform unnormalized eye direction into tangent space
  73 #ifndef USEFOG
  74         vec3 EyeVectorModelSpace;
  75 #endif
  76         EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;
  77         EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);
  78         EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);
  79         EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);
  80
  81 #ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE
  82         VectorS = gl_MultiTexCoord1.xyz;
  83         VectorT = gl_MultiTexCoord2.xyz;
  84         VectorR = gl_MultiTexCoord3.xyz;
  85 #endif
  86
  87         // transform vertex to camera space, using ftransform to match non-VS
  88         // rendering
  89         gl_Position = ftransform();
  90 }
  91
  92 #endif // VERTEX_SHADER
  93
  94
  95
  96
  97 // fragment shader specific:
  98 #ifdef FRAGMENT_SHADER
  99
 100 uniform sampler2D Texture_Normal;
 101 uniform sampler2D Texture_Color;
 102 uniform sampler2D Texture_Gloss;
 103 uniform samplerCube Texture_Cube;
 104 uniform sampler2D Texture_FogMask;
 105 uniform sampler2D Texture_Pants;
 106 uniform sampler2D Texture_Shirt;
 107 uniform sampler2D Texture_Lightmap;
 108 uniform sampler2D Texture_Deluxemap;
 109 uniform sampler2D Texture_Glow;
 110
 111 uniform myhvec3 LightColor;
 112 uniform myhvec3 AmbientColor;
 113 uniform myhvec3 DiffuseColor;
 114 uniform myhvec3 SpecularColor;
 115 uniform myhvec3 Color_Pants;
 116 uniform myhvec3 Color_Shirt;
 117 uniform myhvec3 FogColor;
 118
 119 uniform float OffsetMapping_Scale;
 120 uniform float OffsetMapping_Bias;
 121 uniform float FogRangeRecip;
 122
 123 uniform myhalf AmbientScale;
 124 uniform myhalf DiffuseScale;
 125 uniform myhalf SpecularScale;
 126 uniform myhalf SpecularPower;
 127
 128 void main(void)
 129 {
 130         // apply offsetmapping
 131 #ifdef USEOFFSETMAPPING
 132         vec2 TexCoordOffset = vec2(TexCoord);
 133 #define TexCoord TexCoordOffset
 134
 135         vec3 eyedir = vec3(normalize(EyeVector));
 136         float depthbias = 1.0 - eyedir.z; // should this be a -?
 137         depthbias = 1.0 - depthbias * depthbias;
 138
 139 #ifdef USEOFFSETMAPPING_RELIEFMAPPING
 140         // 14 sample relief mapping: linear search and then binary search
 141         //vec3 OffsetVector = vec3(EyeVector.xy * (1.0 / EyeVector.z) * depthbias * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);
 142         //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);
 143         vec3 OffsetVector = vec3(eyedir.xy * OffsetMapping_Scale * vec2(-0.1, 0.1), -0.1);
 144         vec3 RT = vec3(TexCoord - OffsetVector.xy * 10.0, 1.0) + OffsetVector;
 145         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 146         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 147         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 148         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 149         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 150         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 151         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 152         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;
 153         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;
 154         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;
 155         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;
 156         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;
 157         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;
 158         if (RT.z > texture2D(Texture_Normal, RT.xy).a) RT += OffsetVector;OffsetVector *= 0.5;RT -= OffsetVector;
 159         TexCoord = RT.xy;
 160 #elif 1
 161         // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)
 162         //vec2 OffsetVector = vec2(EyeVector.xy * (1.0 / EyeVector.z) * depthbias) * OffsetMapping_Scale * vec2(-0.333, 0.333);
 163         //vec2 OffsetVector = vec2(normalize(EyeVector.xy)) * OffsetMapping_Scale * vec2(-0.333, 0.333);
 164         vec2 OffsetVector = vec2(eyedir.xy) * OffsetMapping_Scale * vec2(-0.333, 0.333);
 165         //TexCoord += OffsetVector * 3.0;
 166         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 167         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 168         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 169 #elif 0
 170         // 10 sample offset mapping
 171         //vec2 OffsetVector = vec2(EyeVector.xy * (1.0 / EyeVector.z) * depthbias) * OffsetMapping_Scale * vec2(-0.333, 0.333);
 172         //vec2 OffsetVector = vec2(normalize(EyeVector.xy)) * OffsetMapping_Scale * vec2(-0.333, 0.333);
 173         vec2 OffsetVector = vec2(eyedir.xy) * OffsetMapping_Scale * vec2(-0.1, 0.1);
 174         //TexCoord += OffsetVector * 3.0;
 175         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 176         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 177         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 178         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 179         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 180         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 181         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 182         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 183         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 184         TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;
 185 #elif 1
 186         // parallax mapping as described in the paper
 187         // "Parallax Mapping with Offset Limiting: A Per-Pixel Approximation of Uneven Surfaces" by Terry Welsh
 188         // The paper provides code in the ARB fragment program assembly language
 189         // I translated it to GLSL but may have done something wrong - SavageX
 190         // LordHavoc: removed bias and simplified to one line
 191         // LordHavoc: this is just a single sample offsetmapping...
 192         TexCoordOffset += vec2(eyedir.x, -1.0 * eyedir.y) * OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).a;
 193 #else
 194         // parallax mapping as described in the paper
 195         // "Parallax Mapping with Offset Limiting: A Per-Pixel Approximation of Uneven Surfaces" by Terry Welsh
 196         // The paper provides code in the ARB fragment program assembly language
 197         // I translated it to GLSL but may have done something wrong - SavageX
 198         float height = texture2D(Texture_Normal, TexCoord).a;
 199         height = (height - 0.5) * OffsetMapping_Scale; // bias and scale
 200         TexCoordOffset += height * vec2(eyedir.x, -1.0 * eyedir.y);
 201 #endif
 202 #endif
 203
 204         // combine the diffuse textures (base, pants, shirt)
 205         vec4 color = vec4(texture2D(Texture_Color, TexCoord));
 206 #ifdef USECOLORMAPPING
 207         color.rgb += vec3(myhvec3(texture2D(Texture_Pants, TexCoord)) * myhvec3(Color_Pants) + myhvec3(texture2D(Texture_Shirt, TexCoord)) * myhvec3(Color_Shirt));
 208 #endif
 209
 210
 211
 212
 213 #ifdef MODE_LIGHTSOURCE
 214         // light source
 215
 216         // get the surface normal and light normal
 217         myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - 0.5);
 218         myhvec3 diffusenormal = myhvec3(normalize(LightVector));
 219
 220         // calculate directional shading
 221         color.rgb *= (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));
 222 #ifdef USESPECULAR
 223         myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));
 224         color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);
 225 #endif
 226
 227 #ifdef USECUBEFILTER
 228         // apply light cubemap filter
 229         //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));
 230         color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));
 231 #endif
 232
 233         // apply light color
 234         color.rgb *= LightColor;
 235
 236         // apply attenuation
 237         //
 238         // the attenuation is (1-(x*x+y*y+z*z)) which gives a large bright
 239         // center and sharp falloff at the edge, this is about the most efficient
 240         // we can get away with as far as providing illumination.
 241         //
 242         // pow(1-(x*x+y*y+z*z), 4) is far more realistic but needs large lights to
 243         // provide significant illumination, large = slow = pain.
 244         color.rgb *= max(1.0 - dot(CubeVector, CubeVector), 0.0);
 245
 246
 247
 248
 249 #elif defined(MODE_LIGHTDIRECTION)
 250         // directional model lighting
 251
 252         // get the surface normal and light normal
 253         myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhalf(0.5));
 254         myhvec3 diffusenormal = myhvec3(normalize(LightVector));
 255
 256         // calculate directional shading
 257         color.rgb *= vec3(myhvec3(AmbientColor) + myhvec3(DiffuseColor) * myhalf(max(dot(vec3(surfacenormal), vec3(diffusenormal)), 0.0)));
 258
 259 #ifdef USESPECULAR
 260         myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));
 261         color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);
 262 #endif
 263
 264
 265
 266
 267 #elif defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)
 268         // deluxemap lightmapping using light vectors in modelspace (evil q3map2)
 269
 270         // get the surface normal and light normal
 271         myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - 0.5);
 272
 273 #ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE
 274         myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - 0.5;
 275         myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, VectorS), dot(diffusenormal_modelspace, VectorT), dot(diffusenormal_modelspace, VectorR)));
 276 #else
 277         myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - 0.5);
 278 #endif
 279         // calculate directional shading
 280         myhvec3 tempcolor = color.rgb * (DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));
 281 #ifdef USESPECULAR
 282         myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));
 283         tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);
 284 #endif
 285
 286         // apply lightmap color
 287         color.rgb = tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) + color.rgb * myhvec3(AmbientScale);
 288
 289
 290 #else // MODE none (lightmap)
 291         // apply lightmap color
 292         color.rgb *= myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * DiffuseScale + myhvec3(AmbientScale);
 293 #endif // MODE
 294
 295         color *= gl_Color;
 296
 297 #ifdef USEGLOW
 298         color.rgb += texture2D(Texture_Glow, TexCoord).rgb;
 299 #endif
 300
 301 #ifdef USEFOG
 302         // apply fog
 303         myhalf fog = texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0)).x;
 304         color.rgb = color.rgb * fog + FogColor * (1.0 - fog);
 305 #endif
 306
 307         gl_FragColor = color;
 308 }
 309
 310 #endif // FRAGMENT_SHADER