The Witcher 3 - witcher senses (fisheye & combining) 1.0

// No HLSL available - function stub generated

//SamplerComparisonState sampler0 : register(s0); // can't disambiguate
SamplerState sampler0 : register(s0); // can't disambiguate
//SamplerComparisonState sampler2 : register(s2); // can't disambiguate
SamplerState sampler2 : register(s2); // can't disambiguate
Texture2D texture0 : register(t0);
Texture2D texture2 : register(t2);
Texture2D texture3 : register(t3);


cbuffer cbuffer0 : register(b0) {
	float4 cb0_v0 : packoffset(c0.x);
	float4 cb0_v1 : packoffset(c1.x);
	float4 cb0_v2 : packoffset(c2.x);
};

cbuffer cbuffer3 : register(b3) {
	float4 cb3_v0 : packoffset(c0.x);
	float4 cb3_v1 : packoffset(c1.x);
	float4 cb3_v2 : packoffset(c2.x);
	float4 cb3_v3 : packoffset(c3.x);
	float4 cb3_v4 : packoffset(c4.x);
	float4 cb3_v5 : packoffset(c5.x);
	float4 cb3_v6 : packoffset(c6.x);
};

static const float PI = 3.1415;
static const float PI_4 = PI / 4.0;


float4 EditedShaderPS( float4 PosH : SV_Position )  : SV_Target0
{
	// *** Inputs

    // * Zoom amount, always 1
	float zoomAmount = cb3_v1.x;

    // Another value which affect fisheye effect
    // but always set to float2(1.0, 1.0).
	float2 amount = cb0_v2.zw;

    // Elapsed time in seconds
	float time = cb0_v0.x;

    // Colors of witcher senses
	float3 colorInteresting = cb3_v5.rgb;
	float3 colorTraces = cb3_v4.rgb;

    // Was always set to float2(0.0, 0.0).
    // Setting this to higher values
    // makes "greyish corners" effect weaker.
    float2 offset = cb3_v2.xy;

    // Dimensions of fullscreen
    float2 texSize = cb0_v2.xy;
	float2 invTexSize = cb0_v1.zw;


	// *** Shader

    // Main uv
	float2 uv = PosH.xy / texSize;

    // Scale at first from [0-1] to [-1;1], then calculate abs
	float2 uv3 = abs( uv * 2.0 - 1.0);

    // Aspect ratio
	float aspectRatio = texSize.x / texSize.y;


	// * Mask used to make corners grey
    float mask_gray_corners;
    {
        float2 newUv = float2( uv3.x * aspectRatio, uv3.y ) - offset;
        newUv = saturate( newUv / 1.8 );
        newUv = pow(newUv, 2.5);

        mask_gray_corners = 1-min(1.0,  length(newUv) );
    }


	// Main value which causes fisheye effect [0-1]
	const float fisheyeAmount = saturate( cb3_v6.x );


	// circle radius used further
    float circle_radius;
    {
        float2 corners0 = saturate( float2(0.03, 0.03) - uv );
        float cor = corners0.x + corners0.y;

        float2 corners1 = saturate( uv - float2(0.97, 0.97) );

        cor += corners1.x;
        cor += corners1.y;

        circle_radius = saturate( cor * 20.0) ; // r0.x, line 21
    }



	// * Zooming effect
    float2 offsetUV = 0;
    float2 colorUV = 0;
    {
        float2 uv4  = 2 * PosH.xy;
        uv4 /= cb0_v2.xy;
        uv4 -= float2(1.0, 1.0);

        float mask3  = dot(uv4, uv4);
        uv4 *= mask3;

        float attenuation = fisheyeAmount * 0.1;
        uv4 *= attenuation;

        offsetUV = clamp( uv4, float2(-0.4, -0.4), float2(0.4, 0.4) );
        offsetUV *= zoomAmount;

        float2 uv = PosH.xy * invTexSize; // main uv
        colorUV = uv - offsetUV*amount;
    }


	// * Sample color map
	float3 color = texture0.Sample( sampler0, colorUV ).rgb; // r2.xyz


	// * Sample outline map

	// interesting objects (upper left square)
	float2 outlineUV = colorUV * 0.5;
	float outlineInteresting = texture2.Sample( sampler2, outlineUV ).x; // r0.y

	// traces (upper right square)
	outlineUV = colorUV * 0.5  + float2(0.5, 0.0);
	float outlineTraces = texture2.Sample( sampler2, outlineUV ).x;  // r2.w


	outlineInteresting /= 8.0; // r4.x
	outlineTraces /= 8.0; // r4.y

    float timeParam =  time * 0.1;

    // adjust circle radius
    circle_radius = 1.0 - circle_radius;
    circle_radius *= 0.03;

	float3 color_circle_main = float3(0.0, 0.0, 0.0);

    [loop]
	for (int i=0; 8 > i; i++)
	{
		// full 2*PI = 360 angles cycle
		const float angleRadians = (float) i * PI_4 - timeParam;

		// unit circle
		float2 unitCircle;
		sincos(angleRadians, unitCircle.y, unitCircle.x); // unitCircle.x = cos, unitCircle.y = sin

		// adjust radius
		unitCircle *= circle_radius;

		// * base texcoords (circle) - note we also scale radius here by 8
        // * probably because of dimensions of outline map.
		// line 55
		float2 uv_outline_base = colorUV + unitCircle / 8.0;

		// * interesting objects (circle)
		float2 uv_outline_interesting_circle = uv_outline_base * 0.5;
		float outline_interesting_circle  = texture2.Sample( sampler2, uv_outline_interesting_circle ).x;
		outlineInteresting += outline_interesting_circle / 8.0;

		// * traces (circle)
		float2 uv_outline_traces_circle =  uv_outline_base * 0.5 + float2(0.5, 0.0);
		float outline_traces_circle  = texture2.Sample( sampler2, uv_outline_traces_circle ).x;
		outlineTraces += outline_traces_circle / 8.0;

		// * sample color texture with perturbation
		float2 uv_color_circle  = colorUV + unitCircle * offsetUV;
		float3 color_circle = texture0.Sample( sampler0, uv_color_circle ).rgb;
		color_circle_main += color_circle / 8.0;
	}

	// * Sample intensity map
	float2 intensityMap = texture3.Sample( sampler0, colorUV ).xy;

	float intensityInteresting = intensityMap.r;
	float intensityTraces = intensityMap.g;

	// * Adjust outlines
	float mainOutlineInteresting = saturate( outlineInteresting - 0.8*intensityInteresting );
	float mainOutlineTraces = saturate( outlineTraces - 0.75*intensityTraces );

	// * Greyish color
	float3 color_greyish = dot( color_circle_main, float3(0.3, 0.3, 0.3) ).xxx;

	// * Determine main color.
    // (1) At first, combine "circled" color with grey one.
    // Now we have have greyish corners here.
	float3 mainColor = lerp(color_greyish, color_circle_main, mask_gray_corners) * 0.6;

    // (2) Then mix "regular" color with the above.
    // Please note this operation makes corners gradually grey (because fisheyeAmount rises from 0 to 1).
	mainColor = lerp( color, mainColor, fisheyeAmount );

	// * Determine color of witcher senses
    float3 senses_traces = mainOutlineTraces * colorTraces;
	float3 senses_interesting = mainOutlineInteresting * colorInteresting;

    // * Slightly boost traces
    float3 senses_total = 1.2 * senses_traces + senses_interesting;

    // * Final combining
	float3 senses_total_sat = saturate(senses_total);
    float dot_senses_total = saturate( dot(senses_total, float3(1.0, 1.0, 1.0) ) );

    float3 finalColor = lerp( mainColor, senses_total_sat, dot_senses_total );
	return float4( finalColor, 1.0 );
}