Importing the experimental shaders

bs_bp_volfog.glsl

@@ -0,0 +1,23 @@
+#pragma anki vert_shader_begins
+
+void main()
+{
+	gl_Position = ftransform();
+}
+
+#pragma anki frag_shader_begins
+
+#pragma anki include "shaders/linear_depth.glsl"
+
+uniform sampler2D ms_depth_fai;
+
+void main()
+{
+	vec2 tex_coords_ = gl_FragCoord.xy*vec2( 1.0/R_W, 1.0/R_H );
+	
+	float depth_exp_ = texture2D( ms_depth_fai, tex_coords_ ).r;
+	if( depth_exp_ == 1 ) discard;
+	
+	float depth_ = LinearizeDepth( depth_exp_, 0.1, 10.0 );
+	gl_FragColor = vec4( depth_ );
+}

dbg.glsl

@@ -0,0 +1,14 @@
+#pragma anki vert_shader_begins
+
+void main()
+{
+	gl_Position = ftransform();
+	gl_FrontColor = gl_Color;
+}
+
+#pragma anki frag_shader_begins
+
+void main()
+{
+	gl_FragData[0].rgb = gl_Color.rgb;
+}

dp.glsl

@@ -0,0 +1 @@
+#pragma anki include "shaders/dp_generic.glsl"

dp_generic.glsl

@@ -0,0 +1,35 @@
+#pragma anki vert_shader_begins
+
+varying vec2 tex_coords;
+
+void main()
+{
+	#if defined( _GRASS_LIKE_ )
+		tex_coords = gl_MultiTexCoord0.xy;
+	#endif
+
+	#if defined( _HW_SKINNING_ )
+		mat3 _rot;
+		vec3 _tsl;
+
+		HWSkinning( _rot, _tsl );
+		
+		vec3 pos_lspace = ( _rot * gl_Vertex.xyz) + _tsl;
+		gl_Position =  gl_ModelViewProjectionMatrix * vec4(pos_lspace, 1.0);
+	#else
+	  gl_Position = ftransform();
+	#endif
+}
+
+#pragma anki frag_shader_begins
+
+uniform sampler2D diffuse_map;
+varying vec2 tex_coords;
+
+void main()
+{
+	#if defined( _GRASS_LIKE_ )
+		vec4 _diff = texture2D( diffuse_map, tex_coords );
+		if( _diff.a == 0.0 ) discard;
+	#endif
+}

dp_grass.glsl

@@ -0,0 +1,3 @@
+#define _GRASS_LIKE_
+
+#pragma anki include "shaders/dp_generic.glsl"

dp_hw_skinning.glsl

@@ -0,0 +1,10 @@
+#define _HW_SKINNING_
+
+#pragma anki uniform skinning_rotations 0
+#pragma anki uniform skinning_translations 1
+#pragma anki attribute vert_weight_bones_num 0
+#pragma anki attribute vert_weight_bone_ids 1
+#pragma anki attribute vert_weight_weights 2
+
+#pragma anki include "shaders/hw_skinning.glsl"
+#pragma anki include "shaders/dp_generic.glsl"

final.glsl

@@ -0,0 +1,17 @@
+#pragma anki vert_shader_begins
+
+#pragma anki inlcude "shaders/simple_vert.glsl"
+
+#pragma anki frag_shader_begins
+
+#pragma anki uniform raster_image 0
+uniform sampler2D raster_image;
+varying vec2 tex_coords;
+
+void main()
+{
+	//if( gl_FragCoord.x > 0.5 ) discard;
+
+	gl_FragColor.rgb = texture2D( raster_image, tex_coords ).rgb;
+	//gl_FragColor.rgb = gl_FragCoord.xyz;
+}

hw_skinning.glsl

@@ -0,0 +1,26 @@
+
+// hardware skinning data
+attribute float vert_weight_bones_num;
+attribute vec4  vert_weight_bone_ids;
+attribute vec4  vert_weight_weights;
+
+const int MAX_BONES_PER_MESH = 60;
+
+uniform mat3 skinning_rotations[ MAX_BONES_PER_MESH ];
+uniform vec3 skinning_translations[ MAX_BONES_PER_MESH ];
+
+
+void HWSkinning( out mat3 _rot, out vec3 _tsl )
+{
+	_rot = mat3( 0.0 );
+	_tsl = vec3( 0.0 );
+
+	for( int i=0; i<int(vert_weight_bones_num); i++ )
+	{
+		int bone_id = int( vert_weight_bone_ids[i] );
+		float weight = vert_weight_weights[i];
+
+		_rot += skinning_rotations[bone_id] * weight;
+		_tsl += skinning_translations[bone_id] * weight;
+	}
+}

is_ap.glsl

@@ -0,0 +1,16 @@
+#pragma anki vert_shader_begins
+
+#pragma anki include "shaders/simple_vert.glsl"
+
+#pragma anki frag_shader_begins
+
+#pragma anki uniform ambient_color 0
+uniform vec3 ambient_color;
+#pragma anki uniform ms_diffuse_fai 1
+uniform sampler2D ms_diffuse_fai;
+varying vec2 tex_coords;
+
+void main()
+{
+	gl_FragData[0].rgb = texture2D( ms_diffuse_fai, tex_coords ).rgb * ambient_color;
+}

is_lp_generic.glsl

@@ -0,0 +1,288 @@
+#pragma anki vert_shader_begins
+
+#pragma anki attribute view_vector 0
+attribute vec3 view_vector;
+varying vec2 tex_coords;
+varying vec3 vpos;
+
+void main()
+{
+	vpos = view_vector;
+	vec2 vert_pos = gl_Vertex.xy; // the vert coords are {1.0,1.0}, {0.0,1.0}, {0.0,0.0}, {1.0,0.0}
+	tex_coords = vert_pos;
+	vec2 vert_pos_ndc = vert_pos*2.0 - 1.0;
+	gl_Position = vec4( vert_pos_ndc, 0.0, 1.0 );
+}
+
+
+#pragma anki frag_shader_begins
+
+#pragma anki include "shaders/pack.glsl"
+
+#pragma anki uniform ms_normal_fai 0
+#pragma anki uniform ms_diffuse_fai 1
+#pragma anki uniform ms_specular_fai 2
+#pragma anki uniform ms_depth_fai 3
+uniform sampler2D ms_normal_fai, ms_diffuse_fai, ms_specular_fai, ms_depth_fai;
+#pragma anki uniform planes 4
+uniform vec2 planes; // for the calculation of frag pos in view space
+uniform sampler2D light_tex;
+uniform sampler2DShadow shadow_map;
+
+varying vec2 tex_coords;
+varying vec3 vpos; // for the calculation of frag pos in view space
+
+
+/*
+=======================================================================================================================================
+FragPosVSpace                                                                                                                         =
+return frag pos in view space                                                                                                         =
+=======================================================================================================================================
+*/
+vec3 FragPosVSpace()
+{
+	float _depth = texture2D( ms_depth_fai, tex_coords ).r;
+
+	if( _depth == 1.0 ) discard;
+
+	vec3 _frag_pos_vspace;
+	vec3 _vposn = normalize(vpos);
+	_frag_pos_vspace.z = -planes.y/(planes.x+_depth);
+	_frag_pos_vspace.xy = _vposn.xy/_vposn.z*_frag_pos_vspace.z;
+	return _frag_pos_vspace;
+}
+
+
+/*
+=======================================================================================================================================
+Attenuation                                                                                                                           =
+return the attenuation factor fiven the distance from the frag to the light source                                                    =
+=======================================================================================================================================
+*/
+float Attenuation( in float _frag_light_dist )
+{
+	float _inv_light_radius = gl_LightSource[0].position.w;
+	return clamp(1.0 - _inv_light_radius * sqrt(_frag_light_dist), 0.0, 1.0);
+	//return 1.0 - _frag_light_dist * _inv_light_radius;
+}
+
+
+/*
+=======================================================================================================================================
+PCF                                                                                                                                   =
+it returns a blured shadow                                                                                                            =
+=======================================================================================================================================
+*/
+#if defined(_SPOT_LIGHT_) && defined( _SHADOW_ )
+
+float PCF_Off( in vec3 _shadow_uv )
+{
+	return shadow2D(shadow_map, _shadow_uv ).r;
+}
+
+
+float PCF_Low( in vec3 _shadow_uv )
+{
+	float _shadow_col = shadow2D(shadow_map, _shadow_uv ).r;
+	const float _map_scale = 1.0 / SHADOWMAP_SIZE;
+
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,         0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,         0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0, -_map_scale, 0.0)).r;
+	_shadow_col *= 1.0/9.0;
+
+	return _shadow_col;
+}
+
+
+float PCF_Medium( in vec3 _shadow_uv )
+{
+	float _shadow_col = shadow2D(shadow_map, _shadow_uv ).r;
+	float _map_scale = 1.0 / SHADOWMAP_SIZE;
+
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,         0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,         0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0, -_map_scale, 0.0)).r;
+
+	_map_scale *= 2.0;
+
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,         0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,         0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0, -_map_scale, 0.0)).r;
+
+	_shadow_col *= 0.058823529; // aka: _shadow_col /= 17.0;
+	return _shadow_col;
+}
+
+
+float PCF_High( in vec3 _shadow_uv )
+{
+	float _shadow_col = shadow2D(shadow_map, _shadow_uv ).r;
+	float _map_scale = 1.0 / SHADOWMAP_SIZE;
+
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3( _map_scale,  	     0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale,  	     0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0,  _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(        0.0, -_map_scale, 0.0)).r;
+
+
+	float _map_scale_2 = 2.0 * _map_scale;
+
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(_map_scale_2, _map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(_map_scale, _map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(0.0, _map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale, _map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale_2, _map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale_2, _map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale_2, 0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale_2, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale_2, -_map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(-_map_scale, -_map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(0.0, -_map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(_map_scale, -_map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(_map_scale_2, -_map_scale_2, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(_map_scale_2, -_map_scale, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(_map_scale_2, 0.0, 0.0)).r;
+	_shadow_col += shadow2D(shadow_map, _shadow_uv.xyz + vec3(_map_scale_2, _map_scale, 0.0)).r;
+
+	_shadow_col /= 25.0;
+	return _shadow_col;
+}
+#endif
+
+
+
+/*
+=======================================================================================================================================
+Phong                                                                                                                                 =
+=======================================================================================================================================
+*/
+vec3 Phong( in vec3 _frag_pos_vspace, out float _frag_light_dist )
+{
+	// get the lambert term
+	vec3 _light_pos_eyespace = gl_LightSource[0].position.xyz;
+	vec3 _light_frag_vec = _light_pos_eyespace - _frag_pos_vspace;
+
+	_frag_light_dist = dot( _light_frag_vec, _light_frag_vec ); // instead of using normalize(_frag_light_dist) we brake the operation...
+	vec3 _light_dir = _light_frag_vec * inversesqrt(_frag_light_dist); // ...because we want frag_light_dist for the calc of the attenuation
+
+	// read the normal
+	//vec3 _normal = texture2D( ms_normal_fai, tex_coords ).rgb;
+	vec3 _normal = UnpackNormal( texture2D( ms_normal_fai, tex_coords ).rg );
+
+	// the lambert term
+	float _lambert_term = dot( _normal, _light_dir );
+
+	if( _lambert_term < 0.0 ) discard;
+	//_lambert_term = max( 0.0, _lambert_term );
+
+	// diffuce lighting
+	vec3 _diffuse = texture2D( ms_diffuse_fai, tex_coords ).rgb;
+	_diffuse = (_diffuse * gl_LightSource[0].diffuse.rgb);
+	vec3 _color = _diffuse * _lambert_term;
+
+	// specular lighting
+	vec4 _specular_mix = texture2D( ms_specular_fai, tex_coords );
+	vec3 _specular = _specular_mix.xyz;
+	float _shininess = _specular_mix.w;
+
+	vec3 _eye_vec = normalize( -_frag_pos_vspace );
+	vec3 _h = normalize( _light_dir + _eye_vec );
+	float _spec_intensity = pow(max(0.0, dot(_normal, _h)), _shininess);
+	_color += _specular * vec3(gl_LightSource[0].specular) * (_spec_intensity * _lambert_term);
+
+	return _color;
+}
+
+
+
+/*
+=======================================================================================================================================
+main                                                                                                                                  =
+=======================================================================================================================================
+*/
+void main()
+{
+	// get frag pos in view space
+	vec3 _frag_pos_vspace = FragPosVSpace();
+
+	//===================================================================================================================================
+	// POINT LIGHT                                                                                                                      =
+	//===================================================================================================================================
+	#if defined(_POINT_LIGHT_)
+		// The func Phong calculates the frag to light distance (_frag_light_dist) and be cause we need that distance
+		// latter for other calculations we export it
+		float _frag_light_dist;
+		vec3 _color = Phong( _frag_pos_vspace, _frag_light_dist );
+		gl_FragData[0] = vec4( _color * Attenuation(_frag_light_dist), 1.0 );
+
+	//===================================================================================================================================
+	// SPOT LIGHT                                                                                                                       =
+	//===================================================================================================================================
+	#elif defined(_SPOT_LIGHT_)
+		vec4 _tex_coord2 = gl_TextureMatrix[0] * vec4(_frag_pos_vspace, 1.0);
+		vec3 _tex_coords3 = _tex_coord2.xyz / _tex_coord2.w;
+
+		if
+		(
+			_tex_coord2.w > 0.0 &&
+			_tex_coords3.x > 0.0 &&
+			_tex_coords3.x < 1.0 &&
+			_tex_coords3.y > 0.0 &&
+			_tex_coords3.y < 1.0 &&
+			_tex_coord2.w < 1.0/gl_LightSource[0].position.w
+		)
+		{
+			#if defined( _SHADOW_ )
+				#if defined( _SHADOW_MAPPING_PCF_ )
+					float _shadow_color = PCF_Low( _tex_coords3 );
+				#else
+					float _shadow_color = PCF_Off( _tex_coords3 );
+				#endif
+
+				if( _shadow_color == 0.0 ) discard;
+			#endif // shadow
+
+			float _frag_light_dist;
+			vec3 _color = Phong( _frag_pos_vspace, _frag_light_dist );
+
+			vec3 _texel = texture2DProj( light_tex, _tex_coord2.xyz ).rgb;
+			float _att = Attenuation(_frag_light_dist);
+
+			#if defined( _SHADOW_ )
+				gl_FragData[0] = vec4(_texel * _color * (_shadow_color * _att), 1.0);
+			#else
+				gl_FragData[0] = vec4( _color * _texel * _att, 1.0 );
+			#endif
+			//gl_FragData[0] = vec4( 1.0, 0.0, 1.0, 1.0 );
+		}
+		else
+		{
+			discard;
+		}
+	#endif // spot light
+
+	/*#if defined(_SPOT_LIGHT_)
+	gl_FragData[0] = vec4( UnpackNormal(texture2D( ms_normal_fai, tex_coords ).rg), 1.0 );
+	//gl_FragData[0] = vec4( texture2D( ms_depth_fai, tex_coords ).rg), 1.0 );
+	#endif*/
+}

is_lp_point.glsl

@@ -0,0 +1,3 @@
+#define _POINT_LIGHT_
+
+#pragma anki include "shaders/is_lp_generic.glsl"

is_lp_spot.glsl

@@ -0,0 +1,5 @@
+#define _SPOT_LIGHT_
+
+#pragma anki uniform light_tex 5
+
+#pragma anki include "shaders/is_lp_generic.glsl"

is_lp_spot_shad.glsl

@@ -0,0 +1,7 @@
+#define _SPOT_LIGHT_
+#define _SHADOW_
+
+#pragma anki uniform light_tex 5
+#pragma anki uniform shadow_map 6
+
+#pragma anki include "shaders/is_lp_generic.glsl"

linear_depth.glsl

@@ -0,0 +1,11 @@
+// convert to linear depth
+
+float LinearizeDepth( in float depth_, in float znear_, in float zfar_ )
+{
+	return (2.0 * znear_) / (zfar_ + znear_ - depth_ * (zfar_ - znear_));
+}
+
+float ReadFromTexAndLinearizeDepth( in sampler2D depth_map_, in vec2 tex_coord_, in float znear_, in float zfar_ )
+{
+	return LinearizeDepth( texture2D( depth_map_, tex_coord_ ).r, znear_, zfar_ );
+}

ms_mp format (dnspgke)

@@ -0,0 +1,9 @@
+dnspgke aka
+
+diffuse mapping
+normal mapping
+specular mapping
+parallax mapping
+grass like
+hardware skinning
+environment mapping

ms_mp_dne.glsl

@@ -0,0 +1,5 @@
+#define _HAS_DIFFUSE_MAP_
+#define _HAS_NORMAL_MAP_
+#define _ENVIRONMENT_MAPPING_
+
+#pragma anki include "shaders/ms_mp_generic.glsl"

ms_mp_dnsk.glsl

@@ -0,0 +1,6 @@
+#define _HAS_DIFFUSE_MAP_
+#define _HAS_NORMAL_MAP_
+#define _HAS_SPECULAR_MAP_
+#define _HARDWARE_SKINNING_
+
+#pragma anki include "shaders/ms_mp_generic.glsl"

ms_mp_generic.glsl

@@ -0,0 +1,268 @@
+#pragma anki vert_shader_begins
+
+/**
+ * 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"
+
+varying vec3 normal;
+
+
+#if defined( _HAS_DIFFUSE_MAP_ ) || defined( _HAS_NORMAL_MAP_ ) || defined( _HAS_SPECULAR_MAP_ )
+	#define NEEDS_TEX_MAPPING 1
+#else
+	#define NEEDS_TEX_MAPPING 0
+#endif
+
+
+#if defined( _HAS_NORMAL_MAP_ ) || defined( _PARALLAX_MAPPING_ )
+	#define NEEDS_TANGENT 1
+#else
+	#define NEEDS_TANGENT 0
+#endif
+
+
+varying vec2 tex_coords_v2f;
+uniform vec2 tex_coords;
+
+attribute vec4 tangent;
+varying vec3 tangent_v2f;
+varying float w_v2f;
+
+varying vec3 eye_v2f; ///< In tangent space
+varying vec3 vert_pos_eye_space_v2f;
+
+
+
+//=====================================================================================================================================
+// 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 = gl_NormalMatrix * ( _rot * gl_Normal );
+
+		#if NEEDS_TANGENT
+			tangent_v2f = gl_NormalMatrix * ( _rot * vec3(tangent) );
+		#endif
+
+		vec3 pos_lspace = ( _rot * gl_Vertex.xyz) + _tsl;
+		gl_Position =  gl_ModelViewProjectionMatrix * vec4(pos_lspace, 1.0);
+
+	// if DONT have hardware skinning
+	#else
+		normal = gl_NormalMatrix * gl_Normal;
+
+		#if NEEDS_TANGENT
+			tangent_v2f = gl_NormalMatrix * vec3(tangent);
+		#endif
+
+		gl_Position = ftransform();
+	#endif
+
+
+	// calculate the rest
+
+	#if NEEDS_TEX_MAPPING
+		tex_coords_v2f = gl_MultiTexCoord0.xy;
+	#endif
+
+
+	#if NEEDS_TANGENT
+		w_v2f = tangent.w;
+	#endif
+
+
+	#if defined( _ENVIRONMENT_MAPPING_ )
+		vert_pos_eye_space_v2f = vec3( gl_ModelViewMatrix * gl_Vertex );
+	#endif
+
+
+	#if defined( _PARALLAX_MAPPING_ )
+		vec3 t = gl_NormalMatrix * tangent.xyz;
+		vec3 n = normal;
+		vec3 b = cross( n, t ) /* tangent.w*/;
+
+		vec3 eye_pos = gl_Position.xyz - gl_ModelViewMatrixInverse[3].xyz;
+		eye_pos = eye_pos - ( gl_ModelViewMatrixInverse * gl_Vertex ).xyz;
+
+		mat3 tbn_mat = mat3( t, b, n );
+		eye = tbn_mat * eye_pos;
+		//eye.y = -eye.y;
+		//eye.x = -eye.x;
+	#endif
+}
+
+
+#pragma anki frag_shader_begins
+
+/**
+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 _new_normal. 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                                                                                                                                  =
+=======================================================================================================================================
+*/
+varying vec3 normal;
+
+#if defined( _HAS_DIFFUSE_MAP_ )
+	uniform sampler2D diffuse_map;
+#endif
+
+#if defined( _HAS_NORMAL_MAP_ )
+	uniform sampler2D normal_map;
+	varying vec3 tangent_v2f;
+	varying float w_v2f;
+#endif
+
+#if defined( _HAS_SPECULAR_MAP_ )
+	uniform sampler2D specular_map;
+#endif
+
+#if defined( _HAS_DIFFUSE_MAP_ ) || defined( _HAS_NORMAL_MAP_ ) || defined( _HAS_SPECULAR_MAP_ ) || defined( _PARALLAX_MAPPING_ )
+	varying vec2 tex_coords_v2f;
+#endif
+
+#if defined( _PARALLAX_MAPPING_ )
+	uniform sampler2D height_map;
+	varying vec3 eye;
+#endif
+
+
+#if defined( _ENVIRONMENT_MAPPING_ )
+	uniform sampler2D environment_map;
+	varying vec3 vert_pos_eye_space_v2f;
+#endif
+
+
+/*
+=======================================================================================================================================
+main                                                                                                                                  =
+=======================================================================================================================================
+*/
+void main()
+{
+	//===================================================================================================================================
+	// Paralax Mapping Calculations                                                                                                     =
+	// The code below reads the height map, makes some calculations and returns a new tex_coords                                        =
+	//===================================================================================================================================
+	#if defined( _PARALLAX_MAPPING_ )
+		const float _scale = 0.04;
+		const float _bias = scale * 0.4;
+
+		vec3 _norm_eye = normalize( eye );
+
+		float _h = texture2D( height_map, tex_coords_v2f ).r;
+		float _height = _scale * _h - _bias;
+
+		vec2 _super_tex_coords_v2f = _height * _norm_eye.xy + tex_coords_v2f;
+	#else
+		#define _super_tex_coords tex_coords_v2f
+	#endif
+
+
+	//===================================================================================================================================
+	// Diffuse Calculations (Part I)                                                                                                    =
+	// Get the color from the diffuse map and discard if grass                                                                          =
+	//===================================================================================================================================
+	vec3 _diff_color;
+	#if defined( _HAS_DIFFUSE_MAP_ )
+
+		#if defined( _GRASS_LIKE_ )
+			vec4 _diff_color4 = texture2D( diffuse_map, _super_tex_coords );
+			if( _diff_color4.a == 0.0 ) discard;
+			_diff_color = _diff_color4.rgb;
+		#else
+			_diff_color = texture2D( diffuse_map, _super_tex_coords ).rgb;
+		#endif
+
+		_diff_color *= gl_FrontMaterial.diffuse.rgb;
+	#else
+		_diff_color = gl_FrontMaterial.diffuse.rgb;
+	#endif
+
+
+	//===================================================================================================================================
+	// Normal Calculations                                                                                                              =
+	// Either use a normap map and make some calculations or use the vertex normal                                                      =
+	//===================================================================================================================================
+	#if defined( _HAS_NORMAL_MAP_ )
+		vec3 _n = normalize( normal );
+		vec3 _t = normalize( tangent_v2f );
+		vec3 _b = cross(_n, _t) * w_v2f;
+
+		mat3 _tbn_mat = mat3(_t,_b,_n);
+
+		vec3 _n_at_tangentspace = ( texture2D( normal_map, _super_tex_coords ).rgb - 0.5 ) * 2.0;
+
+		vec3 _new_normal = normalize( _tbn_mat * _n_at_tangentspace );
+	#else
+		vec3 _new_normal = normalize(normal);
+	#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 vert_pos_eye_space_v2f, environment_map and the _new_normal
+	#if defined( _ENVIRONMENT_MAPPING_ )
+		vec3 _u = normalize( vert_pos_eye_space_v2f );
+		vec3 _r = reflect( _u, _new_normal ); // 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_tex_coords = _r.xy/_m + 0.5;
+
+		vec3 _sem_col = texture2D( environment_map, _sem_tex_coords ).rgb;
+		_diff_color = _diff_color + _sem_col; // blend existing color with the SEM texture map
+	#endif
+
+
+	//===================================================================================================================================
+	// Specular Calculations                                                                                                            =
+	//===================================================================================================================================
+
+	// has specular map
+	#if defined( _HAS_SPECULAR_MAP_ )
+		vec4 _specular = vec4(texture2D( specular_map, _super_tex_coords ).rgb * gl_FrontMaterial.specular.rgb, gl_FrontMaterial.shininess);
+	// no specular map
+	#else
+		vec4 _specular = vec4(gl_FrontMaterial.specular.rgb, gl_FrontMaterial.shininess);
+	#endif
+
+
+	//===================================================================================================================================
+	// Final Stage. Write all data                                                                                                      =
+	//===================================================================================================================================
+	//gl_FragData[0].rgb = _new_normal;
+	gl_FragData[0].rg = PackNormal( _new_normal );
+	gl_FragData[1].rgb = _diff_color;
+	gl_FragData[2] = _specular;
+
+	/*#if defined( _HARDWARE_SKINNING_ )
+		gl_FragData[1] = gl_Color;
+	#endif*/
+}
+
+
+

ms_mp_skybox.glsl

@@ -0,0 +1,52 @@
+#pragma anki vert_shader_begins
+
+varying vec2 txtr_coords;
+
+void main()
+{
+	txtr_coords = gl_MultiTexCoord0.xy;
+	gl_Position = ftransform();
+}
+
+#pragma anki frag_shader_begins
+
+#pragma anki uniform colormap 0
+uniform sampler2D colormap;
+#pragma anki uniform noisemap 1
+uniform sampler2D noisemap;
+#pragma anki uniform timer 2
+uniform float timer;
+#pragma anki uniform scene_ambient_color 3
+uniform vec3 scene_ambient_color;
+varying vec2 txtr_coords;
+
+#define PI 3.14159265358979323846
+
+
+void main()
+{
+	vec3 _noise_vec;
+	vec2 displacement;
+	float scaled_timer;
+
+	displacement = txtr_coords;
+
+	scaled_timer = timer*0.4;
+
+	displacement.x -= scaled_timer;
+	displacement.y -= scaled_timer;
+
+	_noise_vec = normalize( texture2D(noisemap, displacement).xyz );
+	_noise_vec = (_noise_vec * 2.0 - 1.0);
+
+	// edge_factor is a value that varies from 1.0 to 0.0 and then again to 1.0. Its zero in the edge of the skybox quad
+	// and white in the middle of the quad. We use it in order to reduse the distortion at the edges because of artefacts
+	float _edge_factor = sin( txtr_coords.s * PI ) * sin( txtr_coords.t * PI );
+
+	const float _strength_factor = 0.015;
+
+	_noise_vec = _noise_vec * _strength_factor * _edge_factor;
+
+	gl_FragData[1].rgb = texture2D(colormap, txtr_coords + _noise_vec.xy).rgb * scene_ambient_color; // write to the diffuse buffer
+}
+

pack.glsl

@@ -0,0 +1,34 @@
+vec2 PackNormal( in vec3 _normal )
+{
+    /*original code:
+    const float _scale = 1.7777;
+    vec2 _enc = _normal.xy / (_normal.z+1.0);
+    _enc /= _scale;
+    _enc = _enc*0.5 + 0.5;
+    return _enc;*/
+
+    const float _scale = 1.7777;
+    float scalar1 = (_normal.z+1.0)*(_scale*2.0);
+    return _normal.xy / scalar1 + 0.5;
+}
+
+
+vec3 UnpackNormal( in vec2 _enc )
+{
+	/*original code:
+	float _scale = 1.7777;
+	vec3 _nn = vec3( _enc*vec2(2.0*_scale, 2.0*_scale) + vec2(-_scale, -_scale), 1.0 );
+	float _g = 2.0 / dot(_nn.xyz, _nn.xyz);
+	vec3 _normal;
+	_normal.xy = _g * _nn.xy;
+	_normal.z = _g - 1.0;
+	return _normal;*/
+
+	const float _scale = 1.7777;
+	vec2 _nn = _enc*(2.0*_scale) - _scale;
+	float _g = 2.0 / (dot(_nn.xy, _nn.xy) + 1.0);
+	vec3 _normal;
+	_normal.xy = _g * _nn.xy;
+	_normal.z = _g - 1.0;
+	return _normal;
+}

photoshop_filters.glsl

@@ -0,0 +1,245 @@
+/*
+** Photoshop & misc math
+** Blending modes, RGB/HSL/Contrast/Desaturate, levels control
+**
+** Romain Dura | Romz
+** Blog: http://blog.mouaif.org
+** Post: http://blog.mouaif.org/?p=94
+*/
+
+
+/*
+** Desaturation
+*/
+
+vec4 Desaturate(vec3 color, float Desaturation)
+{
+	vec3 grayXfer = vec3(0.3, 0.59, 0.11);
+	vec3 gray = vec3(dot(grayXfer, color));
+	return vec4(mix(color, gray, Desaturation), 1.0);
+}
+
+
+/*
+** Hue, saturation, luminance
+*/
+
+vec3 RGBToHSL(vec3 color)
+{
+	vec3 hsl; // init to 0 to avoid warnings ? (and reverse if + remove first part)
+
+	float fmin = min(min(color.r, color.g), color.b);    //Min. value of RGB
+	float fmax = max(max(color.r, color.g), color.b);    //Max. value of RGB
+	float delta = fmax - fmin;             //Delta RGB value
+
+	hsl.z = (fmax + fmin) / 2.0; // Luminance
+
+	if (delta == 0.0)		//This is a gray, no chroma...
+	{
+		hsl.x = 0.0;	// Hue
+		hsl.y = 0.0;	// Saturation
+	}
+	else                                    //Chromatic data...
+	{
+		if (hsl.z < 0.5)
+			hsl.y = delta / (fmax + fmin); // Saturation
+		else
+			hsl.y = delta / (2.0 - fmax - fmin); // Saturation
+
+		float deltaR = (((fmax - color.r) / 6.0) + (delta / 2.0)) / delta;
+		float deltaG = (((fmax - color.g) / 6.0) + (delta / 2.0)) / delta;
+		float deltaB = (((fmax - color.b) / 6.0) + (delta / 2.0)) / delta;
+
+		if (color.r == fmax )
+			hsl.x = deltaB - deltaG; // Hue
+		else if (color.g == fmax)
+			hsl.x = (1.0 / 3.0) + deltaR - deltaB; // Hue
+		else if (color.b == fmax)
+			hsl.x = (2.0 / 3.0) + deltaG - deltaR; // Hue
+
+		if (hsl.x < 0.0)
+			hsl.x += 1.0; // Hue
+		else if (hsl.x > 1.0)
+			hsl.x -= 1.0; // Hue
+	}
+
+	return hsl;
+}
+
+float HueToRGB(float f1, float f2, float hue)
+{
+	if (hue < 0.0)
+		hue += 1.0;
+	else if (hue > 1.0)
+		hue -= 1.0;
+	float res;
+	if ((6.0 * hue) < 1.0)
+		res = f1 + (f2 - f1) * 6.0 * hue;
+	else if ((2.0 * hue) < 1.0)
+		res = f2;
+	else if ((3.0 * hue) < 2.0)
+		res = f1 + (f2 - f1) * ((2.0 / 3.0) - hue) * 6.0;
+	else
+		res = f1;
+	return res;
+}
+
+vec3 HSLToRGB(vec3 hsl)
+{
+	vec3 rgb;
+
+	if (hsl.y == 0.0)
+		rgb = vec3(hsl.z); // Luminance
+	else
+	{
+		float f2;
+
+		if (hsl.z < 0.5)
+			f2 = hsl.z * (1.0 + hsl.y);
+		else
+			f2 = (hsl.z + hsl.y) - (hsl.y * hsl.z);
+
+		float f1 = 2.0 * hsl.z - f2;
+
+		rgb.r = HueToRGB(f1, f2, hsl.x + (1.0/3.0));
+		rgb.g = HueToRGB(f1, f2, hsl.x);
+		rgb.b= HueToRGB(f1, f2, hsl.x - (1.0/3.0));
+	}
+
+	return rgb;
+}
+
+
+/*
+** Contrast, saturation, brightness
+** Code of this function is from TGM's shader pack
+** http://irrlicht.sourceforge.net/phpBB2/viewtopic.php?t=21057
+*/
+
+// For all settings: 1.0 = 100% 0.5=50% 1.5 = 150%
+vec3 ContrastSaturationBrightness(vec3 color, float brt, float sat, float con)
+{
+	// Increase or decrease theese values to adjust r, g and b color channels seperately
+	const float AvgLumR = 0.5;
+	const float AvgLumG = 0.5;
+	const float AvgLumB = 0.5;
+
+	const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
+
+	vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
+	vec3 brtColor = color * brt;
+	vec3 intensity = vec3(dot(brtColor, LumCoeff));
+	vec3 satColor = mix(intensity, brtColor, sat);
+	vec3 conColor = mix(AvgLumin, satColor, con);
+	return conColor;
+}
+
+
+/*
+** Float blending modes
+** Adapted from here: http://www.nathanm.com/photoshop-blending-math/
+** But I modified the HardMix (wrong condition), Overlay, SoftLight, ColorDodge, ColorBurn, VividLight, PinLight (inverted layers) ones to have correct results
+*/
+
+#define BlendLinearDodgef 			BlendAddf
+#define BlendLinearBurnf 			BlendSubstractf
+#define BlendAddf(base, blend) 		min(base + blend, 1.0)
+#define BlendSubstractf(base, blend) 	max(base + blend - 1.0, 0.0)
+#define BlendLightenf(base, blend) 		max(blend, base)
+#define BlendDarkenf(base, blend) 		min(blend, base)
+#define BlendLinearLightf(base, blend) 	(blend < 0.5 ? BlendLinearBurnf(base, (2.0 * blend)) : BlendLinearDodgef(base, (2.0 * (blend - 0.5))))
+#define BlendScreenf(base, blend) 		(1.0 - ((1.0 - base) * (1.0 - blend)))
+#define BlendOverlayf(base, blend) 	(base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend)))
+#define BlendSoftLightf(base, blend) 	((blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend)))
+#define BlendColorDodgef(base, blend) 	((blend == 1.0) ? blend : min(base / (1.0 - blend), 1.0))
+#define BlendColorBurnf(base, blend) 	((blend == 0.0) ? blend : max((1.0 - ((1.0 - base) / blend)), 0.0))
+#define BlendVividLightf(base, blend) 	((blend < 0.5) ? BlendColorBurnf(base, (2.0 * blend)) : BlendColorDodgef(base, (2.0 * (blend - 0.5))))
+#define BlendPinLightf(base, blend) 	((blend < 0.5) ? BlendDarkenf(base, (2.0 * blend)) : BlendLightenf(base, (2.0 *(blend - 0.5))))
+#define BlendHardMixf(base, blend) 	((BlendVividLightf(base, blend) < 0.5) ? 0.0 : 1.0)
+#define BlendReflectf(base, blend) 		((blend == 1.0) ? blend : min(base * base / (1.0 - blend), 1.0))
+
+
+/*
+** Vector3 blending modes
+*/
+
+// Component wise blending
+#define Blend(base, blend, funcf) 		vec3(funcf(base.r, blend.r), funcf(base.g, blend.g), funcf(base.b, blend.b))
+
+#define BlendNormal(base, blend) 		(blend)
+#define BlendLighten				BlendLightenf
+#define BlendDarken				BlendDarkenf
+#define BlendMultiply(base, blend) 		(base * blend)
+#define BlendAverage(base, blend) 		((base + blend) / 2.0)
+#define BlendAdd(base, blend) 		min(base + blend, vec3(1.0))
+#define BlendSubstract(base, blend) 	max(base + blend - vec3(1.0), vec3(0.0))
+#define BlendDifference(base, blend) 	abs(base - blend)
+#define BlendNegation(base, blend) 	(vec3(1.0) - abs(vec3(1.0) - base - blend))
+#define BlendExclusion(base, blend) 	(base + blend - 2.0 * base * blend)
+#define BlendScreen(base, blend) 		Blend(base, blend, BlendScreenf)
+#define BlendOverlay(base, blend) 		Blend(base, blend, BlendOverlayf)
+#define BlendSoftLight(base, blend) 	Blend(base, blend, BlendSoftLightf)
+#define BlendHardLight(base, blend) 	BlendOverlay(blend, base)
+#define BlendColorDodge(base, blend) 	Blend(base, blend, BlendColorDodgef)
+#define BlendColorBurn(base, blend) 	Blend(base, blend, BlendColorBurnf)
+#define BlendLinearDodge			BlendAdd
+#define BlendLinearBurn			BlendSubstract
+// Linear Light is another contrast-increasing mode
+// If the blend color is darker than midgray, Linear Light darkens the image by decreasing the brightness. If the blend color is lighter than midgray, the result is a brighter image due to increased brightness.
+#define BlendLinearLight(base, blend) 	Blend(base, blend, BlendLinearLightf)
+#define BlendVividLight(base, blend) 	Blend(base, blend, BlendVividLightf)
+#define BlendPinLight(base, blend) 		Blend(base, blend, BlendPinLightf)
+#define BlendHardMix(base, blend) 		Blend(base, blend, BlendHardMixf)
+#define BlendReflect(base, blend) 		Blend(base, blend, BlendReflectf)
+#define BlendGlow(base, blend) 		BlendReflect(blend, base)
+#define BlendPhoenix(base, blend) 		(min(base, blend) - max(base, blend) + vec3(1.0))
+#define BlendOpacity(base, blend, F, O) 	(F(base, blend) * O + blend * (1.0 - O))
+
+
+// Hue Blend mode creates the result color by combining the luminance and saturation of the base color with the hue of the blend color.
+vec3 BlendHue(vec3 base, vec3 blend)
+{
+	vec3 baseHSL = RGBToHSL(base);
+	return HSLToRGB(vec3(RGBToHSL(blend).r, baseHSL.g, baseHSL.b));
+}
+
+// Saturation Blend mode creates the result color by combining the luminance and hue of the base color with the saturation of the blend color.
+vec3 BlendSaturation(vec3 base, vec3 blend)
+{
+	vec3 baseHSL = RGBToHSL(base);
+	return HSLToRGB(vec3(baseHSL.r, RGBToHSL(blend).g, baseHSL.b));
+}
+
+// Color Mode keeps the brightness of the base color and applies both the hue and saturation of the blend color.
+vec3 BlendColor(vec3 base, vec3 blend)
+{
+	vec3 blendHSL = RGBToHSL(blend);
+	return HSLToRGB(vec3(blendHSL.r, blendHSL.g, RGBToHSL(base).b));
+}
+
+// Luminosity Blend mode creates the result color by combining the hue and saturation of the base color with the luminance of the blend color.
+vec3 BlendLuminosity(vec3 base, vec3 blend)
+{
+	vec3 baseHSL = RGBToHSL(base);
+	return HSLToRGB(vec3(baseHSL.r, baseHSL.g, RGBToHSL(blend).b));
+}
+
+
+/*
+** Gamma correction
+** Details: http://blog.mouaif.org/2009/01/22/photoshop-gamma-correction-shader/
+*/
+
+#define GammaCorrection(color, gamma)								pow(color, 1.0 / gamma)
+
+/*
+** Levels control (input (+gamma), output)
+** Details: http://blog.mouaif.org/2009/01/28/levels-control-shader/
+*/
+
+#define LevelsControlInputRange(color, minInput, maxInput)				min(max(color - vec3(minInput), vec3(0.0)) / (vec3(maxInput) - vec3(minInput)), vec3(1.0))
+#define LevelsControlInput(color, minInput, gamma, maxInput)				GammaCorrection(LevelsControlInputRange(color, minInput, maxInput), gamma)
+#define LevelsControlOutputRange(color, minOutput, maxOutput) 			mix(vec3(minOutput), vec3(maxOutput), color)
+#define LevelsControl(color, minInput, gamma, maxInput, minOutput, maxOutput) 	LevelsControlOutputRange(LevelsControlInput(color, minInput, gamma, maxInput), minOutput, maxOutput)
+
+

pps.glsl

@@ -0,0 +1,202 @@
+#pragma anki vert_shader_begins
+
+#pragma anki include "shaders/simple.glsl"
+
+#pragma anki frag_shader_begins
+
+#pragma anki include "shaders/photoshop_filters.glsl"
+
+uniform sampler2D is_fai;
+uniform sampler2D pps_ssao_fai;
+uniform sampler2D ms_normal_fai;
+uniform sampler2D pps_boom_fai;
+uniform sampler2D pps_lscatt_fai;
+
+varying vec2 tex_coords;
+
+
+/*
+=======================================================================================================================================
+GrayScale                                                                                                                             =
+=======================================================================================================================================
+*/
+vec3 GrayScale( in vec3 _col )
+{
+	float _grey = (_col.r + _col.g + _col.b) * 0.333333333; // aka: / 3.0
+	return vec3(_grey);
+}
+
+
+/*
+=======================================================================================================================================
+Saturation                                                                                                                            =
+=======================================================================================================================================
+*/
+vec3 Saturation( in vec3 _col, in float _satur_factor )
+{
+	const vec3 lumCoeff = vec3 ( 0.2125, 0.7154, 0.0721);
+
+	vec3 intensity = vec3( dot(_col, lumCoeff) );
+	return mix( intensity, _col, _satur_factor );
+}
+
+
+/*
+=======================================================================================================================================
+EdgeAA                                                                                                                                =
+=======================================================================================================================================
+*/
+#if defined(_EDGEAA_)
+
+//float LinearizeDepth( in float _depth )
+//{
+//	return (2.0 * camerarange.x) / (camerarange.y + camerarange.x - _depth * (camerarange.y - camerarange.x));
+//}
+//
+//float ReadLinearDepth( in vec2 coord )
+//{
+//	return LinearizeDepth( texture2D( depth_map, coord ).r );
+//}
+
+vec3 EdgeAA()
+{
+	vec2 kernel[8];
+	kernel[0] = vec2(-1,1);
+	kernel[1] = vec2(1,-1);
+	kernel[2] = vec2(-1,-1);
+	kernel[3] = vec2(1,1);
+	kernel[4] = vec2(-1,0);
+	kernel[5] = vec2(1,0);
+	kernel[6] = vec2(0,-1);
+	kernel[7] = vec2(0,1);
+
+	vec2 pixelsize = vec2( 1.0/(R_W*R_Q), 1.0/(R_H*R_Q) );
+	const float weight = 1.0;
+
+	vec3 tex = texture2D( ms_normal_fai, tex_coords ).rgb;
+	float factor = -0.5;
+
+	for( int i=0; i<4; i++ )
+	{
+		vec3 t = texture2D( ms_normal_fai, tex_coords + kernel[i]*pixelsize ).rgb;
+		t -= tex;
+		factor += dot(t, t);
+	}
+
+	factor = min(1.0, factor) * weight;
+
+	//return vec3(factor);
+	//if( factor < 0.01 ) return texture2D( is_fai, tex_coords ).rgb;
+
+	vec3 color = vec3(0.0);
+
+	for( int i=0; i<8; i++ )
+	{
+		color += texture2D( is_fai, tex_coords + kernel[i]*pixelsize*factor ).rgb;
+	}
+
+	color += 2.0 * texture2D( is_fai, tex_coords ).rgb;
+
+	return color*(1.0/9.0);
+
+//	const float aob = 1.0; // area of blur
+//
+//	vec2 kernel[8];
+//	kernel[0] = vec2(-aob,aob);
+//	kernel[1] = vec2(aob,-aob);
+//	kernel[2] = vec2(-aob,-aob);
+//	kernel[3] = vec2(aob,aob);
+//	kernel[4] = vec2(-aob,0);
+//	kernel[5] = vec2(aob,0);
+//	kernel[6] = vec2(0,-aob);
+//	kernel[7] = vec2(0,aob);
+//
+//	vec2 pixelsize = vec2( 1.0/R_W, 1.0/R_H );
+//
+//	float d = ReadLinearDepth( tex_coords );
+//	float factor = 0.0;
+//
+//	const float weight = 8.0;
+//
+//	for( int i=0; i<4; i++ )
+//	{
+//		float ds = ReadLinearDepth( tex_coords + kernel[i]*pixelsize );
+//
+//		factor += abs(d - ds);
+//	}
+//
+//	factor = (factor / 4)*weight;
+//
+//	//return vec3(factor);
+//
+//	/*if( factor < 0.001 )
+//	{
+//		return texture2D( is_fai, tex_coords ).rgb;
+//	}*/
+//
+//	vec3 color = vec3(0.0);
+//
+//	for( int i=0; i<8; i++ )
+//	{
+//		color += texture2D( is_fai, tex_coords + kernel[i]*pixelsize*factor ).rgb;
+//	}
+//
+//	color += 2.0 * texture2D( is_fai, tex_coords ).rgb;
+//
+//	return color*(1.0/10.0);
+}
+#endif
+
+
+/*
+=======================================================================================================================================
+main                                                                                                                                  =
+=======================================================================================================================================
+*/
+void main (void)
+{
+	vec3 color;
+
+	#if defined(_EDGEAA_)
+		color = EdgeAA();
+	#else
+		color = texture2D( is_fai, tex_coords ).rgb;
+	#endif
+
+	/*const float gamma = 0.7;
+	color.r = pow(color.r, 1.0 / gamma);
+	color.g = pow(color.g, 1.0 / gamma);
+	color.b = pow(color.b, 1.0 / gamma);*/
+
+	#if defined(_SSAO_)
+		float ssao_factor = texture2D( pps_ssao_fai, tex_coords ).a;
+		color *= ssao_factor;
+	#endif
+
+	#if defined(_LSCATT_)
+		vec3 lscatt = texture2D( pps_lscatt_fai, tex_coords ).rgb;
+		color += lscatt;
+	#endif
+
+	#if defined(_BLOOM_)
+		//float bloom_factor = texture2D( pps_boom_fai, tex_coords ).r; // ORIGINAL BLOOM CODE
+		vec3 bloom = texture2D( pps_boom_fai, tex_coords ).rgb;
+		color += bloom;
+	#endif
+
+	color = BlendHardLight( vec3(0.6, 0.62, 0.4), color );
+
+	gl_FragData[0].rgb = color;
+
+	//gl_FragColor = vec4( color, 1.0 );
+	//gl_FragColor = vec4( GrayScale(gl_FragColor.rgb), 1.0 );
+	//gl_FragData[0] = vec4( ssao_factor );
+	//gl_FragData[0] = vec4( lscatt, 1.0 );
+	//gl_FragData[0] = vec4( bloom_factor );
+	//gl_FragColor = vec4( EdgeAA(), 1.0 );
+	//gl_FragColor = texture2D( pps_boom_fai, tex_coords );
+	//gl_FragColor = texture2D( is_fai, tex_coords );
+	//gl_FragData[0].rgb = UnpackNormal( texture2D( ms_normal_fai, tex_coords ).rg );
+	//gl_FragData[0] = vec4( bloom*2, 1.0 );
+}
+

pps_bloom_final.glsl

@@ -0,0 +1,3 @@
+#define _BLOOM_FINAL_
+#pragma anki uniform bloom_final_fai 0
+#pragma anki include "shaders/pps_bloom_generic.glsl"

pps_bloom_generic.glsl

@@ -0,0 +1,78 @@
+#pragma anki vert_shader_begins
+
+#pragma anki include "shaders/simple_vert.glsl"
+
+#pragma anki frag_shader_begins
+
+// the first pass is for horizontal blur and the second for vertical
+
+varying vec2 tex_coords;
+
+#if defined( _BLOOM_VBLUR_ )
+	uniform sampler2D is_fai;
+#elif defined ( _BLOOM_FINAL_ )
+	uniform sampler2D bloom_final_fai; // ToDo: rename
+#else
+	#error "something is wrong"
+#endif
+
+
+
+/*
+=======================================================================================================================================
+main                                                                                                                                  =
+=======================================================================================================================================
+*/
+void main (void)
+{
+	const float super_offset = 1.;
+	#if defined( _BLOOM_VBLUR_ )
+		const float offset = 1.0 / (R_W*R_Q*BLOOM_RENDERING_QUALITY) * super_offset; // 1 / width_of_the_IS_FAI     !!!!!!!!!!!!!!!!!!!!!!!
+	#else
+		const float offset = 1.0 / (R_H*R_Q*BLOOM_RENDERING_QUALITY) * super_offset; // 1 / height_of_the_BLOOM_FAI
+	#endif
+
+	const int kernel_size = 7;
+	float kernel[kernel_size];
+	kernel[0] = -3.0 * offset;
+	kernel[1] = -2.0 * offset;
+	kernel[2] = -1.0 * offset;
+	kernel[3] = 0.0 * offset;
+	kernel[4] = 1.0 * offset;
+	kernel[5] = 2.0 * offset;
+	kernel[6] = 3.0 * offset;
+	/*kernel[7] = -4.0 * offset;
+	kernel[8] = 4.0 * offset;
+	kernel[9] = -5.0 * offset;
+	kernel[10] = 5.0 * offset;*/
+
+	//float bloom_factor = 0.0; // ORIGINAL BLOOM CODE
+	vec3 bloom = vec3(0.0);
+
+	for( int i=0; i<kernel_size; i++ )
+	{
+		#if defined( _BLOOM_VBLUR_ )
+			vec3 color = texture2D( is_fai, tex_coords + vec2(kernel[i], 0.0) ).rgb;
+
+			float Y = dot(vec3(0.30, 0.59, 0.11), color);
+			const float exposure = 4.0;
+			const float brightMax = 4.0;
+			float YD = exposure * (exposure/brightMax + 1.0) / (exposure + 1.0) * Y;
+			color *= YD;
+
+			bloom += color;
+			//vec3 color = texture2D( is_fai, tex_coords + vec2(kernel[i], 0.0) ).rgb; // ORIGINAL BLOOM CODE
+			//bloom_factor += dot(tex,tex); // ORIGINAL BLOOM CODE
+		#else
+			vec3 color = texture2D( bloom_final_fai, tex_coords + vec2(0.0, kernel[i]) ).rgb;
+			bloom += color;
+
+			//float factor = texture2D( bloom_final_fai, tex_coords + vec2(0.0, kernel[i]) ).r; // ORIGINAL BLOOM CODE
+			//bloom_factor += factor; // ORIGINAL BLOOM CODE
+		#endif
+	}
+
+	gl_FragColor.rgb = bloom * (1.0/kernel_size);
+	//gl_FragColor.r = bloom_factor * (1.0/7.0); // ORIGINAL BLOOM CODE
+}
+

pps_bloom_vblur.glsl

@@ -0,0 +1,3 @@
+#define _BLOOM_VBLUR_
+#pragma anki uniform is_fai 0
+#pragma anki include "shaders/pps_bloom_generic.glsl"

pps_lscatt.glsl

@@ -0,0 +1,54 @@
+#pragma anki vert_shader_begins
+
+#pragma anki include "shaders/simple_vert.glsl"
+
+#pragma anki frag_shader_begins
+
+const int SAMPLES_NUM = 100;
+
+float exposure = 2.0;
+float decay = 0.8;
+float density = 1.0;
+float weight = 0.3;
+vec2 light_pos_screen_space = vec2(0.5, 0.5);
+
+#pragma anki uniform ms_depth_fai 0
+uniform sampler2D ms_depth_fai;
+#pragma anki uniform is_fai 1
+uniform sampler2D is_fai;
+
+varying vec2 tex_coords;
+
+
+
+void main()
+{
+	vec2 delta_tex_coord = tex_coords - light_pos_screen_space;
+	vec2 tex_coords2 = tex_coords;
+	delta_tex_coord *= 1.0 / float(SAMPLES_NUM) * density;
+	float illumination_decay = 1.0;
+
+	gl_FragData[0].rgb = vec3(0.0);
+
+	for( int i=0; i<SAMPLES_NUM; i++ )
+	{
+		tex_coords2 -= delta_tex_coord;
+
+		float depth = texture2D( ms_depth_fai, tex_coords2 ).r;
+		if( depth != 1.0 ) // if the fragment is not part of the skybox dont bother continuing
+		{
+			illumination_decay *= decay;
+			continue;
+		}
+
+		vec3 sample = texture2D( is_fai, tex_coords2 ).rgb;			
+		sample *= illumination_decay * weight;
+		gl_FragData[0].rgb += sample;
+		illumination_decay *= decay;
+	}
+
+	gl_FragData[0].rgb *= exposure;
+	
+	//gl_FragData[0].rgb = texture2D( is_fai, tex_coords ).rgb;
+	//gl_FragData[0].rgb = vec3(1, 1, 0);
+}

simple_texturing.glsl

@@ -0,0 +1,32 @@
+#pragma anki vert_shader_begins
+
+varying vec2 tex_coords;
+varying vec3 normal;
+
+void main()
+{
+	tex_coords = gl_MultiTexCoord0.xy;
+	normal = gl_NormalMatrix * gl_Normal;
+	gl_Position = ftransform();
+}
+
+#pragma anki frag_shader_begins
+
+#pragma anki include "pack.glsl"
+
+uniform sampler2D diffuse_map, noise_map;
+varying vec2 tex_coords;
+varying vec3 normal;
+
+void main()
+{
+	/*vec3 _noise = DecodeNormal( texture2D( noise_map, gl_FragCoord.xy*vec2( 1.0/R_W, 1.0/R_H ) ).rg ).rgb;
+	_noise = _noise * 2 - 1;
+	_noise *= 7.0;*/
+	vec4 _texel = texture2D( diffuse_map, (gl_FragCoord.xy+(normal.xy*2))*vec2( 1.0/R_W, 1.0/R_H ) );
+
+
+	//vec4 _texel = texture2D( diffuse_map, tex_coords );
+
+	gl_FragColor = _texel;
+}

simple_vert.glsl

@@ -0,0 +1,18 @@
+/** 
+ * Simple vertex shader for IS and PPS stages. It is used for rendering a quad in the 
+ * screen. Notice that it does not use ftransform(). We dont need it because we can
+ * get the Normalized Display Coordinates ([-1,1]) simply by looking in the vertex
+ * position. The vertex positions of the quad are from 0.0 to 1.0 for both axis.
+ */
+
+varying vec2 tex_coords;
+
+void main()
+{
+	vec2 vert_pos = gl_Vertex.xy; // the vert coords are {1.0,1.0}, {0.0,1.0}, {0.0,0.0}, {1.0,0.0}
+	tex_coords = vert_pos;
+	vec2 vert_pos_ndc = vert_pos*2.0 - 1.0;
+	gl_Position = vec4( vert_pos_ndc, 0.0, 1.0 );
+}
+
+

txt.glsl

@@ -0,0 +1,24 @@
+#pragma anki vert_shader_begins
+
+varying vec2 tex_coords;
+
+void main(void)
+{
+	tex_coords = gl_MultiTexCoord0.xy;
+	gl_FrontColor = gl_Color;
+	gl_Position = ftransform();
+}
+
+#pragma anki frag_shader_begins
+
+uniform sampler2D font_map;
+varying vec2 tex_coords;
+
+void main()
+{
+	vec2 tex_col = texture2D( font_map, tex_coords ).ra; // get only one value and the alpha
+
+	if( tex_col.y == 0.0 ) discard;
+
+	gl_FragColor = vec4(tex_col.x) * gl_Color;
+}