bool SetSphericalHarmonics( const unsigned char index, const vec3 component )

vec3 GetSphericalHarmonics( const unsigned char index )

#define GAMMA vec3(2.2)

uniform vec3 _sh2[ 9 ];

uniform mat3 gfx_ViewMatrixInverseTranspose;

varying vec3 normal;

void main()
{
vec3 N = normalize( gfx_ViewMatrixInverseTranspose * normal );

N = N.xzy; // If the cubemap up vector is Y flip it to Z.

vec3 sh2 = vec3( 

 0.282095 * _sh2[0] +

-0.488603 * N.z * _sh2[1] +
 0.488603 * N.y * _sh2[2] +
-0.488603 * N.x * _sh2[3] +

 1.092548 * N.x * N.z * _sh2[4] +
-1.092548 * N.z * N.y * _sh2[5] + 
 0.315392 * ( 3.0 * N.y * N.y - 1.0 ) * _sh2[6] +
-1.092548 * N.x * N.y * _sh2[7] +
 0.546274 * ( N.x * N.x - N.z * N.z ) * _sh2[8] );

gl_FragColor = vec4( pow( sh2, GAMMA ), metallic );
}

attribute lowp vec2 POSITION;

varying lowp vec2  texcoord0;

void main()
{
	texcoord0 = POSITION.xy * 0.5 + 0.5;

	gl_Position = vec4( POSITION.xy, 0.0, 1.0 );
}

// https://github.com/congard/algine/blob/master/resources/shaders/SSR.frag.glsl

// SSR based on tutorial by Imanol Fotia

// http://imanolfotia.com/blog/update/2017/03/11/ScreenSpaceReflections.html

uniform sampler2D SAMPLER0; // composite (rgb + metallic)
uniform sampler2D SAMPLER1; // normal (rgb + roughess)
uniform sampler2D SAMPLER2; // depth

uniform mat4 _view;
uniform mat4 _viewinv;
uniform mat4 _projection;
uniform mat4 _projectioninv;

uniform int   binarySearchCount; // 4
uniform int   rayMarchCount;// 64
uniform float rayStep;// 0.015
uniform float falloff;// 7.250
uniform float depth_bias; // 0.125
uniform float minStep; // 6.125

varying vec2 texcoord0;

vec3 get_eye_pos( const in vec2 texcoord )
{
	float depth = texture2D( SAMPLER2, texcoord ).r;

    vec4 pos = _projectioninv * 
    		   vec4( texcoord0 * 2.0 - 1.0, 
    	  		   depth     * 2.0 - 1.0, 
    	  		   1.0 );  
    
   return pos.xyz / pos.w;
}


float get_eye_depth( const in vec2 texcoord )
{
	float depth = texture2D( SAMPLER2, texcoord ).r * 2.0 - 1.0;

    return ( ( depth * _projectioninv[2][2] ) +
			 _projectioninv[3][2] ) /			
		   ( ( depth * _projectioninv[2][3] ) +
			 _projectioninv[3][3] );
}


vec4 get_projected_coord( const in vec3 hitCoord )
{
	vec4 projectedCoord = _projection * vec4( hitCoord, 1.0 );

    projectedCoord.xy /= projectedCoord.w;
    projectedCoord.xy = projectedCoord.xy * 0.5 + 0.5;
    
    return projectedCoord;
}


vec2 binarySearch( inout vec3 dir,
				   inout vec3 hitCoord )
{
    vec4 projectedCoord;

    for( int i = 0; i < binarySearchCount; ++i )
    {
        projectedCoord = get_projected_coord( hitCoord );        

        float depth = hitCoord.z - get_eye_depth( projectedCoord.xy );

        dir *= 0.5;

		hitCoord += depth > 0.0 ? dir : -dir;
    }

    return projectedCoord.xy;
}


vec2 raycast( in	vec3 dir, 
			  inout vec3 hitCoord )
{   
    vec2 coords = vec2( -1.0 );
    
    dir *= rayStep;
    
    for( int i = 0; i < rayMarchCount; ++i )
    {
        hitCoord += dir;

        vec4 projectedCoord = get_projected_coord( hitCoord );
        
        float depth = hitCoord.z - get_eye_depth( projectedCoord.xy );

        if( ( dir.z - depth ) < depth_bias && depth < 0.0 )
        {
            coords = binarySearch( dir, hitCoord );
            break;
        }
    }

    return coords;
}


vec3 hash3( in vec3 a )
{
    a = fract( a * vec3( 0.8 ) );
    a += dot(a, a.yxz + 19.19 );
    return fract( ( a.xxy + a.yxx ) * a.zyx );
}


void main()
{
	vec4 composite = texture2D( SAMPLER0, texcoord0 );

	gl_FragColor = vec4( composite.rgb, 0.0 );


	vec4 normal = texture2D(SAMPLER1, texcoord0 );

	normal.xyz = normalize( normal.xyz );


    vec3 viewPos = get_eye_pos( texcoord0 );

    vec3 worldPos = vec3( vec4( viewPos, 1.0 ) * _viewinv );
    
    vec3 jitter = hash3( worldPos ) * normal.a * normal.a;


    vec3 reflected = reflect( normalize( viewPos ), normal.xyz );

    vec3 hitPos = viewPos;

	vec2 coords = raycast( jitter + reflected * max( -viewPos.z, minStep ), hitPos );

	if( coords.xy == vec2( -1.0 ) )
	{ return; }


	float D = length( viewPos - hitPos );

	float A = ( 1.0 / ( 1.0 + ( D * D ) ) );

    vec2 dCoords = smoothstep( 0.2, 0.6, abs( vec2(0.5) - coords.xy ) );

    float edge_factor = clamp( 1.0 - ( dCoords.x + dCoords.y ), 0.0, 1.0 );

	//  * -reflected.z
	float mul = clamp( A * falloff, 0.0, 1.0 ) * composite.a * edge_factor;

    gl_FragColor = vec4( texture2D( SAMPLER0, coords.xy ).rgb,
    					 mul );
}