Edge Smoothing

fine *= (1-saturate(pow(abs(color.xyz), 1 / (fSharpen_DynamicCurve + 0.001))));

/**
 * Smooth Edges
 * by Jakob W. ~ j4712
 * made for Duran.te 
 * NOT FINISHED JUST A CONCEPT FOR NOT USING DEPTH FOR THIS TASK WITHOUT DESTROYING INGAME AA
 */
 
#include "ReShade.fxh"
#include "ReShadeUI.fxh"

texture TexColorBuffer : COLOR;

sampler SamplerColor
{
	Texture = TexColorBuffer;
	AddressU = MIRROR;
	AddressV = MIRROR;
};

texture blurredColor
{
	Width = BUFFER_WIDTH;
	Height = BUFFER_HEIGHT;
};

texture edgesTex
{
	Width = BUFFER_WIDTH;
	Height = BUFFER_HEIGHT;
};

sampler blurredSampler
{
	Texture = blurredColor;
};

sampler edgesSampler
{
	Texture = edgesTex;
};

float rgbLuma(float3 color)
{
	return float3( color.r * 0.2126,  color.g * 0.7152,  color.b * 0.0722);
}

float3 BlurringPass(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
{
	float kernel[9] = { 1, 2, 1,
						2, 4, 2,
						1, 2, 1 };
						
	float3 color = float3(0.f,0.f,0.f);

	int kernalSumm = 0;
	
	for (int y = 0; y < 3; y++)
	{
		for (int x = 0; x < 3; x++)
		{
			int index = y * 3 + x;
			
			float3 pixelColor = tex2D(ReShade::BackBuffer, texcoord + (float2(x-1, y-1) * ReShade::PixelSize)).rgb;
			color += pixelColor * kernel[index];
			kernalSumm += kernel[index];
		}
	}
	
	color /= kernalSumm;
	
	return color;
}

float3 DetectSobelPass(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
{

	float kernel_x[9] = { 	-1.f, 0.f, 1.f,
							-2.f, 0.f, 2.f,
							-1.f, 0.f, 1.f 	};
							
	float kernel_y[9] = { 	1.f, 2.f, 1.f,
							0.f, 0.f, 0.f,
							-1.f, -2.f, -1.f };

	float3 color = float3(0.f, 0.f, 0.f);
		
	float edge_x = 0.f;
	float edge_y = 0.f;
	float kernelSumm_x = -1.f;
	float kernelSumm_y = -1.f;
	
	for (int y = 0; y < 3; y++)
	{
		for (int x = 0; x < 3; x++)
		{
			int index = y * 3 + x;
			float brightness = rgbLuma(tex2D(blurredSampler, texcoord + (float2(x-1, y-1) * ReShade::PixelSize)).rgb);
								 
			edge_x +=  (brightness * kernel_x[index]);	
			edge_y +=  (brightness * kernel_y[index]);	
			
			kernelSumm_x += kernel_x[index];				
			kernelSumm_y += kernel_y[index];
		}			
	}
	
	edge_x = ((edge_x / kernelSumm_x) / 2.f);
	edge_y = ((edge_y / kernelSumm_y) / 2.f);
	
	color.r = edge_x;
	color.g = edge_y;
	
	
	
	return sqrt((color.r * color.r) + (color.g * color.g));
}

float3 EffectPass(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
{
	float3 oColor = tex2D(SamplerColor, texcoord).rgb;
	float3 bColor = tex2D(blurredSampler, texcoord).rgb;
	float  edgeStrength = 0;
	
	float kernel[9] = { 1, 2, 1,
						2, 4, 2,
						1, 2, 1 };

	int kernalSumm = 0;
	
	for (int y = 0; y < 3; y++)
	{
		for (int x = 0; x < 3; x++)
		{
			int index = y * 3 + x;
			
			edgeStrength += tex2D(edgesSampler, texcoord + (float2(x-1, y-1) * ReShade::PixelSize)).r * kernel[index];
			kernalSumm += kernel[index];
		}
	}
	
	edgeStrength /= kernalSumm;
	
	if (edgeStrength < 0.075)
		edgeStrength = 0;
	edgeStrength = saturate(edgeStrength * 5);
	
	return lerp(oColor, bColor, edgeStrength);
}



technique SoftEdges
{
	pass BlurPass
	{
		VertexShader = PostProcessVS;
		PixelShader = BlurringPass;
		RenderTarget = blurredColor;
	}
	
	pass DetectSobel 
	{
		VertexShader = PostProcessVS;
		PixelShader = DetectSobelPass;
		RenderTarget = edgesTex;
	}	
	
	pass Effect 
	{
		VertexShader = PostProcessVS;
		PixelShader = EffectPass;	
	}
}