Ported Storybook Shader

texture colorTex : COLOR;
sampler colorSamp { Texture = colorTex; };

// x = left or image without black borders, y = top, z = right, w = bottom
float4 CalculateViewport()
{
	float4 viewport = float4(0, 0, 1, 1);
	
	// Look through the pixels on x and y axis until one that is not black is found.
	while (dot(tex2D(colorSamp, float2(viewport.x, 0.5))) > 0 && viewport.x < 1)
	{
		viewport.x += BUFFER_RCP_WIDTH;
	}
	while (dot(tex2D(colorSamp, float2(viewport.y, 0.5))) > 0 && viewport.y < 1)
	{
		viewport.y += BUFFER_RCP_HEIGHT;
	}

	// Let's asume the black bars are mirrored across the screen
	viewport.z = 1 - viewport.x;
	viewport.w = 1 - viewport.y;

	// Return our gathered information. It's a rectangle containing the position and size of our image without black borders.
	return viewport;
}

texture viewportTex { Width = 1; Height = 1; Format = RGBA32F; };
sampler viewportSamp { Texture = viewportTex; MinFilter = POINT; MagFilter = POINT; };

float4 CalculateViewport(in float4 pos : SV_Position) : SV_Target
{
	...
	return viewport;
}

float4 SomeOtherShader(in float4 pos : SV_Position, in float2 texcoord : TEXCOORD) : SV_Target
{
	// Retrieve our viewport information from the texture we rendered it to below.
	float4 viewport = tex2D(viewportSamp, float2(0, 0));

	// Lets just use it to discard/abort rendering in the black borders and only do stuff on the actual image.
	if (texcoord.x < viewport.x || texcoord.y < viewport.y || texcoord.x > viewport.z || texcoord.y > viewport.w)
	{
		discard;
	}
	
	float4 color;

	...

	return color;
}

technique MyTechnique
{
	pass
	{
		// Render the result of the CalculateViewport function into a texture ("viewportTex") only once (at start of post processing).
		VertexShader = ...;
		PixelShader = CalculateViewport;
		RenderTarget = viewportTex;
	}
	pass
	{
		// Now we can execute other shaders and use the result stored inside "viewportTex".
		VertexShader = ...;
		PixelShader = SomeOtherShader;
	}
}

tex2D(MySampler, texcoord * viewport);

// This technique is only executed during the first 2000 milliseconds it gets enabled, which in this case means 2000 milliseconds after game start, because "enabled" is set to true. It is toggled off afterwards. But the last result written into "viewportTex" is still available and you can continue to use it.
technique RunMeOnlyOnce < enabled = true; timeout = 2000; >
{
	pass
	{
		VertexShader = ...;
		PixelShader = CalculateViewport;
		RenderTarget = viewportTex;
	}
}

// This technique is executed every frame
technique MyTechnique < enabled = true; >
{
	pass
	{
		VertexShader = ...;
		PixelShader = SomeOtherShader;
	}
}

uniform float Intensity <
	ui_type = "drag";
	ui_min = 0.0; ui_max = 200.0;
	ui_tooltip = "Adjust";
> = 80.0;                   

uniform float Morph <
	ui_type = "drag";
	ui_min = 0.0; ui_max = 100.0;
	ui_tooltip = "Adjust";
> = 30.0;     

uniform float Brightness <
	ui_type = "drag";
	ui_min = 0.0; ui_max = 100.0;
	ui_tooltip = "Adjust";
> = 100.0;     

uniform float Edge <
	ui_type = "drag";
	ui_min = 0.0; ui_max = 200.0;
	ui_tooltip = "Adjust";
> = 70.0;     

uniform float Mix <
	ui_type = "drag";
	ui_min = 0.0; ui_max = 70.0;
	ui_tooltip = "Adjust";
> = 50.0;     

//how to get screen width not buffer width
texture texColorBuffer : COLOR; // or SV_Target

texture texImage < source = "noise.png"; >
{
	Width = 256;
	Height = 256;
};

sampler samplerColor
{
	Texture = texColorBuffer;
};

sampler samplerImage
{
	Texture = texImage;
};

void MainVS(in uint id : SV_VertexID, out float4 position : SV_Position, out float2 texcoord : TEXCOORD0)
{
	texcoord = float2((id == 2) ? 2.0 : 0.0, (id == 1) ? 2.0 : 0.0);
	position = float4(texcoord * float2(2.0, -2.0) + float2(-1.0, 1.0), 0.0, 1.0);
}

float4 PS(in float4 pos : SV_Position, in float2 texcoord : TEXCOORD0) : SV_Target
{
	float3 c11 = tex2D(samplerColor, texcoord).xyz;
	float3 paper = tex2D(samplerImage, texcoord).xyz;
	//float3 paper = float3(0.97,0.86,0.72); //Manual paper color.

	float dx =BUFFER_RCP_WIDTH;    //BUFFER_RCP_WIDTH;   
	float dy = 0.00095; //BUFFER_RCP_HEIGHT; 

	float3 c00 = tex2D(samplerColor, texcoord + float2(-dx, -dy)).xyz;
	float3 c10 = tex2D(samplerColor, texcoord  + float2( 0, -dy)).xyz;
	float3 c02 = tex2D(samplerColor, texcoord  + float2( dx, -dy)).xyz;
	float3 c01 = tex2D(samplerColor, texcoord + float2(-dx, 0)).xyz;
	float3 c21 = tex2D(samplerColor, texcoord + float2( dx, 0)).xyz;
	float3 c20 = tex2D(samplerColor, texcoord + float2(-dx, dy)).xyz;
	float3 c12 = tex2D(samplerColor, texcoord + float2( 0, dy)).xyz;
	float3 c22 = tex2D(samplerColor, texcoord + float2( dx, dy)).xyz;
	float3 dt = float3(1.0,1.0,1.0); 

	float d1=dot(abs(c00-c22),dt);
	float d2=dot(abs(c20-c02),dt);
	float hl=dot(abs(c01-c21),dt);
	float vl=dot(abs(c10-c12),dt);
	float d = (d1+d2+hl+vl)/(dot(c11+c10+c02+c22,dt)+0.2);
	d = max(Intensity/100.0*pow(abs(d),Morph/100.0) + d,0); //Intensity and morph

	c11 = max((Brightness/100.0-(Edge/100.0*d))*c11,0); //brightness, edge darkness/thickness
	d = min(d,1.1);
    d = max(d-0.1,0.0);
	d = pow(d,(Mix/100.0)); //Mix, set to 0 for no background color.
	return float4(lerp(paper, c11, d),1.0);
}

technique Storybook < enabled = true; >
{
	pass
	{
	    VertexShader = MainVS;
		PixelShader = PS;
	}

}