anki-3d-engine/shaders/ms_mp_generic.glsl

//
#if defined( _DIFFUSE_MAPPING_ ) || defined( _NORMAL_MAPPING_ ) || defined( _SPECULAR_MAPPING_ )
	#define NEEDS_TEX_MAPPING 1
#else
	#define NEEDS_TEX_MAPPING 0
#endif


#if defined( _NORMAL_MAPPING_ ) || defined( _PARALLAX_MAPPING_ )
	#define NEEDS_TANGENT 1
#else
	#define NEEDS_TANGENT 0
#endif


#pragma anki vertShaderBegins

/**
 * This a generic shader to fill the deferred shading buffers. You can always build your own if you dont need to write in all the
 * buffers.
 */
#pragma anki include "shaders/hw_skinning.glsl"

// attributes
attribute vec3 position;
attribute vec3 normal;
attribute vec2 texCoords;
attribute vec4 tangent;

// uniforms
uniform mat4 MVP_mat;
uniform mat4 MV_mat;
uniform mat3 N_mat;

// varyings
varying vec3 normal_v2f;
varying vec2 texCoords_v2f;
varying vec3 tangent_v2f;
varying float w_v2f;
varying vec3 vertPosEyeSpace_v2f; ///< For env mapping. AKA view_vector



//=====================================================================================================================================
// main                                                                                                                               =
//=====================================================================================================================================
void main()
{
	// calculate the vert pos, normal and tangent

	// if we have hardware skinning then:
	#if defined( _HARDWARE_SKINNING_ )
		mat3 _rot;
		vec3 _tsl;

		HWSkinning( _rot, _tsl );

		normal_v2f = gl_NormalMatrix * ( _rot * normal );

		#if NEEDS_TANGENT
			tangent_v2f = gl_NormalMatrix * ( _rot * vec3(tangent) );
		#endif

		vec3 pos_lspace = ( _rot * position) + _tsl;
		gl_Position =  gl_ModelViewProjectionMatrix * vec4(pos_lspace, 1.0);

	// if DONT have hardware skinning
	#else
		normal_v2f = gl_NormalMatrix * normal;

		#if NEEDS_TANGENT
			tangent_v2f = gl_NormalMatrix * vec3(tangent);
		#endif

		gl_Position = gl_ModelViewProjectionMatrix * vec4(position, 1.0);
	#endif


	// calculate the rest

	#if NEEDS_TEX_MAPPING
		texCoords_v2f = texCoords;
	#endif


	#if NEEDS_TANGENT
		w_v2f = tangent.w;
	#endif


	#if defined( _ENVIRONMENT_MAPPING_ ) || defined( _PARALLAX_MAPPING_ )
		vertPosEyeSpace_v2f = vec3( gl_ModelViewMatrix * vec4(position, 1.0) );
	#endif
}


#pragma anki fragShaderBegins

/**
 * Note: The process of calculating the diffuse color for the diffuse MSFAI is divided into two parts. The first happens before the
 * normal calculation and the other just after it. In the first part we read the texture (or the gl_Color) and we set the _diff_color.
 * In case of grass we discard. In the second part we calculate a SEM color and we combine it with the _diff_color. We cannot put
 * the second part before normal calculation because SEM needs the newNormal. Also we cannot put the first part after normal
 * calculation because in case of grass we will waste calculations for the normal. For that two reasons we split the diffuse
 * calculations in two parts
 */

#pragma anki include "shaders/pack.glsl"

/*
=======================================================================================================================================
VARS                                                                                                                                  =
=======================================================================================================================================
*/

uniform sampler2D diffuseMap;
uniform sampler2D normalMap;
uniform sampler2D specularMap;
uniform sampler2D heightMap;
uniform sampler2D environmentMap;
uniform vec3 diffuseCol = vec3( 1.0, 1.0, 1.0 );
uniform vec3 specularCol = vec3( 1.0, 1.0, 1.0 );
uniform float shininess = 50.0;

varying vec3 normal_v2f;
varying vec3 tangent_v2f;
varying float w_v2f;
varying vec2 texCoords_v2f;
varying vec3 eye;
varying vec3 vertPosEyeSpace_v2f;



/*
=======================================================================================================================================
main                                                                                                                                  =
=======================================================================================================================================
*/
void main()
{
	//===================================================================================================================================
	// Paralax Mapping Calculations                                                                                                     =
	// The code below reads the height map, makes some calculations and returns a new texCoords                                        =
	//===================================================================================================================================
	#if defined( _PARALLAX_MAPPING_ )
		/*const float _scale = 0.04;
		const float _bias = scale * 0.4;

		vec3 _norm_eye = normalize( eye );

		float _h = texture2D( heightMap, texCoords_v2f ).r;
		float _height = _scale * _h - _bias;

		vec2 superTexCoords_v2f = _height * _norm_eye.xy + texCoords_v2f;*/

		vec2 superTexCoords = texCoords_v2f;
		const float maxStepCount = 100.0;
		float nSteps = maxStepCount * length(superTexCoords);

		vec3 dir = vertPosEyeSpace_v2f;
		dir.xy /= 8.0;
		dir /= -nSteps * dir.z;

		float diff0, diff1 = 1.0 - texture2D( heightMap, superTexCoords ).a;
		if( diff1 > 0.0 )
		{
			do 
			{
				superTexCoords += dir.xy;

				diff0 = diff1;
				diff1 = texture2D(heightMap, superTexCoords ).w;
			} while( diff1 > 0.0 );

			superTexCoords.xy += (diff1 / (diff0 - diff1)) * dir.xy;
		}
	#else
		#define superTexCoords texCoords_v2f
	#endif


	//===================================================================================================================================
	// Diffuse Calculations (Part I)                                                                                                    =
	// Get the color from the diffuse map and discard if grass                                                                          =
	//===================================================================================================================================
	vec3 _diff_color;
	#if defined( _DIFFUSE_MAPPING_ )

		#if defined( _GRASS_LIKE_ )
			vec4 _diff_color4 = texture2D( diffuseMap, superTexCoords );
			if( _diff_color4.a == 0.0 ) discard;
			_diff_color = _diff_color4.rgb;
		#else
			_diff_color = texture2D( diffuseMap, superTexCoords ).rgb;
		#endif

		_diff_color *= diffuseCol.rgb;
	#else
		_diff_color = diffuseCol.rgb;
	#endif


	//===================================================================================================================================
	// Normal Calculations                                                                                                              =
	// Either use a normap map and make some calculations or use the vertex normal                                                      =
	//===================================================================================================================================
	#if defined( _NORMAL_MAPPING_ )
		vec3 _n = normalize( normal_v2f );
		vec3 _t = normalize( tangent_v2f );
		vec3 _b = cross(_n, _t) * w_v2f;

		mat3 tbnMat = mat3(_t,_b,_n);

		vec3 nAtTangentspace = ( texture2D( normalMap, superTexCoords ).rgb - 0.5 ) * 2.0;

		vec3 newNormal = normalize( tbnMat * nAtTangentspace );
	#else
		vec3 newNormal = normalize(normal_v2f);
	#endif


	//===================================================================================================================================
	// Diffuse Calculations (Part II)                                                                                                   =
	// If SEM is enabled make some calculations and combine colors of SEM and the _diff_color                                           =
	//===================================================================================================================================

	// if SEM enabled make some aditional calculations using the vertPosEyeSpace_v2f, environmentMap and the newNormal
	#if defined( _ENVIRONMENT_MAPPING_ )
		vec3 _u = normalize( vertPosEyeSpace_v2f );
		vec3 _r = reflect( _u, newNormal ); // In case of normal mapping I could play with vertex's normal but this gives better...
		                                      // ...results and its allready computed
		_r.z += 1.0;
		float _m = 2.0 * length(_r);
		vec2 _sem_texCoords = _r.xy/_m + 0.5;

		vec3 _sem_col = texture2D( environmentMap, _sem_texCoords ).rgb;
		_diff_color = _diff_color + _sem_col; // blend existing color with the SEM texture map
	#endif


	//===================================================================================================================================
	// Specular Calculations                                                                                                            =
	//===================================================================================================================================

	// has specular map
	#if defined( _SPECULAR_MAPPING_ )
		vec4 _specular = vec4(texture2D( specularMap, superTexCoords ).rgb * specularCol, shininess);
	// no specular map
	#else
		vec4 _specular = vec4(specularCol, shininess);
	#endif


	//===================================================================================================================================
	// Final Stage. Write all data                                                                                                      =
	//===================================================================================================================================
	//gl_FragData[0].rgb = newNormal;
	gl_FragData[0].rg = PackNormal( newNormal );
	gl_FragData[1].rgb = _diff_color;
	gl_FragData[2] = _specular;

	/*#if defined( _HARDWARE_SKINNING_ )
		gl_FragData[1] = gl_Color;
	#endif*/
}