FaceShader2.0

#---FRAGMENT---#
#include "shaders/template_perframe.glinc"
#include "shaders/template_matrixhelpers.glinc"
#include "shaders/template_noise.glinc"						#only:TERRAIN
#include "shaders/template_lighting_fs.glinc"				#only:LIT

uniform sampler2D tex0; // name: texDiffuse
uniform sampler2D tex1; // name: texTangentNormal			#only:HAS_TNORMALMAP
uniform sampler2D tex1; // name: texWorldNormal				#only:HAS_WNORMALMAP
uniform sampler2D tex2; // name: texEmissive
uniform sampler2D tex3; // name: texSpecular				#only:HAS_SPECULAR
uniform sampler2D tex4; // name: texColourSet
uniform samplerCube tex8; // name: texCube0					#only:HAS_ENVIRONMENTMAP
uniform sampler2DArray tex6;								#only:TERRAIN

uniform mat4 world;											#only:HAS_WNORMALMAP

in vec4 VSOutTEXCOORD0; // name: OutTexCoord0
in vec3 VSOutTEXCOORD1; // name: OutWorldPosition
in vec3 VSOutTEXCOORD2; // name: OutNormal					#only:~HAS_WNORMALMAP
in vec3 VSOutTEXCOORD3; // name: OutTangent					#only:HAS_TNORMALMAP
in vec3 VSOutTEXCOORD4; // name: OutBitangent				#only:HAS_TNORMALMAP

out vec4 FragmentColor0; // name: FragmentColor
out vec4 FragmentColor1; // name: FragmentColor1			#only:DEFERRED
out vec4 FragmentColor2; // name: FragmentColor2			#only:DEFERRED

uniform vec4 specularSettings;
uniform vec4 fillColor;										#only:FILLCOLOR
uniform vec4 alphaSettings;									#only:ALPHATEST
uniform vec4 environmentSettings;							#only:HAS_ENVIRONMENTMAP
uniform vec4 albedoColor;									#only:COLOR_ALBEDO

uniform vec4 color1;
uniform vec4 color2;
uniform vec4 color3;
uniform vec4 color4;
uniform vec4 color5;
uniform vec4 color6;

	float halfLambert(in vec3 vect1, in vec3 vect2)
	{
		float product = dot(vect1,vect2);
		return product * 0.5 + 0.5;
	}

	float blinnPhongSpecular(in vec3 normalVec, in vec3 lightVec, in float specPower)
	{
		vec3 halfAngle = normalize(normalVec + lightVec);
		return pow(clamp(0.0,1.0,dot(normalVec,halfAngle)),specPower);
	}

void main()
{

#ifdef HAS_TNORMALMAP
	vec4 normalSample = texture(tex1, VSOutTEXCOORD0.xy);
	vec3 tangentSpaceNormal = ( normalSample.xyz - 0.5) * 2.0;

	// HLSL: mat3 tangentToWorldMatrix = {VSOutTEXCOORD3, VSOutTEXCOORD4, VSOutTEXCOORD2};
	// HLSL: vec3 normal = mul( tangentSpaceNormal, tangentToWorldMatrix);
	mat3 tangentToWorldMatrix = mat3(VSOutTEXCOORD3, VSOutTEXCOORD4, VSOutTEXCOORD2);
	vec3 normal = ( tangentToWorldMatrix* tangentSpaceNormal);
#else
	vec3 normal = (world * vec4(texture(tex1, VSOutTEXCOORD0.xy).xyz * 2.0 - 1.0, 0.0)).xyz;		#only:HAS_WNORMALMAP
	vec3 normal = VSOutTEXCOORD2;																	#only:~HAS_WNORMALMAP
#endif

	vec4 albedo=texture(tex0, VSOutTEXCOORD0.xy);
	albedo *= albedoColor;																			#only:COLOR_ALBEDO

	// specular factor
	float specular = specularSettings.z;
	specular=texture(tex3, VSOutTEXCOORD0.xy).r*specularSettings.z;								   	#only:HAS_SPECULAR
	specular=albedo.w*specularSettings.z; albedo.w = 1.0;								    		#only:HAS_SPECULAR_IN_DIFFUSE_ALPHA

#ifdef LIT
	FragmentColor0 = vec4(CalculateForwardLighting(albedo, normal, VSOutTEXCOORD1, specularSettings.x, specular), albedo.w);
#else
	FragmentColor0 = texture(tex0, VSOutTEXCOORD0.xy);												#only:~FILLCOLOR
#endif
	FragmentColor0 = fillColor;																		#only:FILLCOLOR


#ifdef HAS_ENVIRONMENTMAP
	vec3 viewDir = normalize(GetTranslation(inverseView)-VSOutTEXCOORD1);
	FragmentColor0.xyz += texture(tex8, -reflect(viewDir,normal).xzy).xyz * environmentSettings.x * saturate(1.0-abs(dot(viewDir,normal))*environmentSettings.y);
#endif

	if(FragmentColor0.a < alphaSettings.x) { discard; } else { FragmentColor0.a = 1.0; }			#only:ALPHATEST

#ifdef TEST_MIPMAP
    vec3 colors[] = vec3[](vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), vec3(0.0, 0.0, 1.0), vec3(1.0, 0.0, 1.0), vec3(1.0, 1.0, 0.0), vec3(0.0, 1.0, 1.0), vec3(1.0, 0.5, 0.0), vec3(0.0, 0.5, 1.0) );
	vec2 lod=textureQueryLod(tex0, VSOutTEXCOORD0.xy);
	int lodlevel = int(floor(lod.x));
	FragmentColor0.xyz *= mix(colors[lodlevel], colors[lodlevel+1], fract(lod.x));
#endif

#ifdef DEFERRED
	FragmentColor1.xyz = (normal.xyz + 1.0) * 0.5;
	FragmentColor1.w = 0.0;
	FragmentColor2.x = specularSettings.x;
	FragmentColor2.y = specular;

	FragmentColor0.a = 1.0;
	//return;
#endif

	//FragmentColor0 += texture(tex2, VSOutTEXCOORD0.xy);

	vec4 colorValue = texture(tex2, VSOutTEXCOORD0.xy);

	if (colorValue.x > 0.7 && colorValue.x <= 1.0 && colorValue.y > 0.7 && colorValue.y <= 1.0 && colorValue.z > 0.7 && colorValue.z <= 1.0)
		FragmentColor0.xyz *= color6.xyz * pow(2.3, 2.3);
	else if (colorValue.r > 0.5 && colorValue.r <= 1.0 && colorValue.g < 0.5 && colorValue.b < 0.5) {
		FragmentColor0.xyz *= color1.xyz;}
	else if (colorValue.g > 0.5 && colorValue.g <= 1.0 && colorValue.r < 0.5 && colorValue.b < 0.5) {
		FragmentColor0.xyz *= color2.xyz;}
	else if (colorValue.b > 0.5 && colorValue.b <= 1.0 && colorValue.r < 0.5 && colorValue.g < 0.5) {
		FragmentColor0.xyz *= color3.xyz;}
	else if (colorValue.r > 0.5 && colorValue.r <= 1.0 && colorValue.g > 0.5 && colorValue.g <= 1.0 && colorValue.b < 0.5) {
		FragmentColor0.xyz *= color4.xyz;}
	else if (colorValue.r > 0.5 && colorValue.r <= 1.0  && colorValue.g < 0.5 && colorValue.b > 0.5 && colorValue.b <= 1.0 ) {
		FragmentColor0.xyz *= color5.xyz;}
	else { FragmentColor0.xyz *= vec3(0.1, 0.1, 0.1);}

	vec3 viewDir = normalize(GetTranslation(inverseView)-VSOutTEXCOORD1);

	float attenuation = 10.0 * (1.0 / distance(1.0,0.25));
	float thickness = 0.1;

	vec3 indirectLightComponent = vec3(thickness * max(0.0,dot(-normal.xyz,viewDir)));
    indirectLightComponent += thickness * halfLambert(-viewDir.xyz,normal.xyz);
    indirectLightComponent *= attenuation;
    indirectLightComponent.r *= 0.2;
    indirectLightComponent.g *= 0.2;
    indirectLightComponent.b *= 0.2;


	vec3 rim = vec3(1.0 - max(0.0,dot(normal,viewDir)));
    rim *= rim;
    rim *= max(0.1,dot(normal,VSOutTEXCOORD1.xyz)) * specularSettings.rgb;

	vec4 dotLN = vec4(halfLambert(viewDir.xyz,normal.xyz) * attenuation * 0.1);

	dotLN *=  albedo;

	vec4 finalColour = dotLN + vec4(indirectLightComponent, 1.0);
	finalColour.rgb += (rim * finalColour.a * 0.05);
	finalColour.rgb += vec3(blinnPhongSpecular(normal, VSOutTEXCOORD1, specularSettings.z) * attenuation * specular * finalColour.a *  0.05);
	finalColour.rgb *= FragmentColor0.rgb;

	FragmentColor0 *= finalColour;
};

#---VERTEX---#
#include "shaders/template_perframe.glinc"

uniform mat4 world;
uniform mat4 skinmatrix[100];																		#only:SKINNING
uniform mat4 instworld[32];																			#only:INSTANCED_UBO
#define worldSkin (worldSkinMat)																	#only:SKINNING
#define worldSkin (world)																			#only:~SKINNING
#define worldMatrix (worldSkin)																		#only:~INSTANCED
#define skinMatrix skinmatrix

// in variables
in vec3 POSITION; // name: Pos
in vec4 TEXCOORD0; // name: TexCoord0
in vec3 NORMAL; // name: Normal																		#only:~HAS_WNORMALMAP
in vec3 TANGENT; // name: Tangent																	#only:HAS_TNORMALMAP
in vec3 BITANGENT; // name: Bitangent																#only:HAS_TNORMALMAP
in vec4 BLENDINDICES; // name: BlendIndices															#only:SKINNING
in vec4 BLENDWEIGHT; // name: BlendWeight															#only:SKINNING
in mat4 RESERVED1; // name: InstanceWorld															#only:INSTANCED_VB

// out variables
out vec4 VSOutTEXCOORD0; // name: OutTexCoord0
out vec3 VSOutTEXCOORD1; // name: OutWorldPosition
out vec3 VSOutTEXCOORD2; // name: OutNormal															#only:~HAS_WNORMALMAP
out vec3 VSOutTEXCOORD3; // name: OutTangent														#only:HAS_TNORMALMAP
out vec3 VSOutTEXCOORD4; // name: OutBitangent														#only:HAS_TNORMALMAP

void main()
{
	VSOutTEXCOORD0 = TEXCOORD0;

	mat4 skinMat =	(skinMatrix[int(BLENDINDICES.x)] * BLENDWEIGHT.x) + (skinMatrix[int(BLENDINDICES.y)] * BLENDWEIGHT.y) + #only:SKINNING
					(skinMatrix[int(BLENDINDICES.z)] * BLENDWEIGHT.z) + (skinMatrix[int(BLENDINDICES.w)] * BLENDWEIGHT.w);	#only:SKINNING
	mat4 worldSkinMat = world * skinMat;																					#only:SKINNING

	mat4 worldMatrix = (RESERVED1 * worldSkin); 													#only:INSTANCED_VB
	mat4 worldMatrix = (instworld[gl_InstanceID] * worldSkin); 										#only:INSTANCED_UBO

	gl_Position = projectionView * (worldMatrix * vec4(POSITION, 1.0));								#only:~SKYBOX
#ifdef SKYBOX
	mat4 viewNoTranslation = view; viewNoTranslation[3] = vec4(0.0, 0.0, 0.0, 1.0);
	gl_Position = projection * viewNoTranslation * worldMatrix * vec4(POSITION, 1.0);
#endif

	VSOutTEXCOORD1 = (worldMatrix * vec4(POSITION, 1.0)).xyz;
	VSOutTEXCOORD2 = normalize((worldMatrix * vec4(NORMAL, 0.0)).xyz);								#only:~HAS_WNORMALMAP
	VSOutTEXCOORD3 = normalize((worldMatrix * vec4(TANGENT,0.0)).xyz);								#only:HAS_TNORMALMAP
	VSOutTEXCOORD4 = normalize((worldMatrix * vec4(BITANGENT,0.0)).xyz);							#only:HAS_TNORMALMAP
};