const int REPLACE = 0;
const int MODULATE = 1;
const int DECAL = 2;
const int BLEND = 3;
const int ADD = 4;
const int SUBTRACT = 5;
const int COMBINE = 5;

void applyTexture2D(in sampler2D texUnit, in int type, in int index, inout vec4 color)
{
// Read from the texture
vec4 texture = texture2D(texUnit, gl_TexCoord[index].st);

if (type == REPLACE)
{
color = texture;
}
else if (type == MODULATE)
{
color *= texture;
}
else if (type == DECAL)
{
vec3 temp = mix(color.rgb, texture.rgb, texture.a);

color = vec4(temp, color.a);
}
else if (type == BLEND)
{
vec3 temp = mix(color.rgb, gl_TextureEnvColor[index].rgb, texture.rgb);

color = vec4(temp, color.a * texture.a);
}
else if (type == ADD)
{
color.rgb += texture.rgb;
color.a *= texture.a;

color = clamp(color, 0.0, 1.0);
}
else if (type == SUBTRACT)
{
color.rgb -= texture.rgb;
color.a *= texture.a;

color = clamp(color, 0.0, 1.0);
}
else
{
color = clamp(texture * color, 0.0, 1.0);
}
}

void applyBumpMap2D(in vec3 bump, in vec3 deluxe, inout vec4 color)
{
/*
decode the normal and light direction (it's encoded in an rgb value) and
re-normalize the light and reflection normals. Remember that during
interpolation by the GL these values can become non unit length
*/
vec3 decbump = bump * 2.0 - 1.0;
vec3 decdeluxe = deluxe * 2.0 - 1.0;

/*
sample the color map to get our diffuse color
*/
color.rgb *= max(dot(normalize(decbump), normalize(decdeluxe) ), 0.0);
color.rgb = min(color.rgb, vec3(1.0));
}

void applyGlossMap2D(in vec3 gloss, in vec3 bump, in vec4 localView, inout vec4 color)
{
// decode the normal (it's encoded in an rgb value)
vec3 decbump = bump * 2.0 - 1.0;

// get the specular amount
float spec = dot(localView.xyz, normalize(decbump));
vec3 colorSpec = pow(spec, 8.0)*gloss;
color.rgb = mix(color.rgb, gl_TextureEnvColor[0].rgb,colorSpec);
}

uniform sampler2D base_map;
uniform sampler2D light_map;
uniform sampler2D luma_map;
uniform sampler2D deluxe_map;
uniform sampler2D bump_map;
uniform sampler2D gloss_map;

uniform int renderluma, renderbump, renderspec;

varying vec4 viewTangetSpace;
varying mat3 tbn;

void main()
{
vec4 pixel = gl_Color;
applyTexture2D(base_map, REPLACE, 0, pixel);
applyTexture2D(light_map, BLEND, 1, pixel);

if (renderluma) applyTexture2D(luma_map, ADD, 0, pixel);

vec4 bump, deluxe, gloss;

if (renderbump) {
// sample the normal for the bumpiness at this pixel.
applyTexture2D(bump_map, REPLACE, 0, bump);
// sample the deluxe for the light direction at this pixel.
applyTexture2D(deluxe_map, REPLACE, 1, deluxe);
// apply the bump map
applyBumpMap2D(bump.rgb, deluxe.rgb, pixel);
}

if (renderspec) {
// sample the gloss for the glossiness at this pixel.
applyTexture2D(gloss_map, REPLACE, 0, gloss);
// apply the gloss map
applyGlossMap2D(gloss.rgb, bump.rgb, normalize(viewTangetSpace), pixel);
}

/*
compute our final fragment color as a combination of
diffuse map, light map, bump map and the specular highlight
*/
gl_FragColor = vec4(pixel.rgb, 1.0);
}