Line thinning

#include "ReShadeUI.fxh";

uniform float LOD < __UNIFORM_DRAG_FLOAT1
	ui_min = -1.0; ui_max = 10.0;
	ui_tooltip = "Lower retains more detail.";
> = 0.25;

uniform float Brightness < __UNIFORM_DRAG_FLOAT1
	ui_min = -1.0; ui_max = 10.0;
	ui_tooltip = "Adjust LOD with this at 1 first, then adjust this. Higher => darker.";
> = 1.0;

uniform bool Two_dimensional_input <> = false;

uniform int Two_dimensional_input_type <__UNIFORM_COMBO_INT1
    ui_items = "Crosshairs on\0Crosshairs off\0";
	> = 0;

uniform float LOD_Brightness_Range < __UNIFORM_SLIDER_FLOAT1
	ui_min = 0.0; ui_max = 7.0;
> = 1.0;

uniform int dxy < __UNIFORM_SLIDER_INT1
	ui_min = 0; ui_max = 100;
	ui_tooltip = "No. of adjacent pixels to include in the sample.";
> = 2;

uniform bool Final_grey_S_curve <> = false;

uniform float greyChangeAmnt < __UNIFORM_DRAG_FLOAT1
	ui_min = 0.0; ui_max = 5.0;
> = 1;

uniform bool Omit_centre_pixel <> = false;

uniform bool Debug <
ui_tooltip = "Shows adjustment in greyscale.";
> = false;

uniform bool Split <> = false;

uniform bool Flip_split <> = false;

uniform float Split_position < __UNIFORM_SLIDER_FLOAT1
	ui_min = 0; ui_max =1;
	ui_tooltip = "0 is on the far left, 1 on the far right.";
> = 0.5;

#include "ReShade.fxh"

#include "DrawText_mod.fxh"

uniform bool buttondown < source = "mousebutton"; keycode = 0; mode = ""; >;

uniform float2 mousepoint < source = "mousepoint"; >;

float4 PS_LineThin(float4 pos : SV_Position, float2 texcoord : TEXCOORD0) : SV_Target
{	

float4 c0=tex2D(ReShade::BackBuffer, texcoord);

float4 c1=c0;

float LOD_Range=(BUFFER_WIDTH>=BUFFER_HEIGHT)?LOD_Brightness_Range*(BUFFER_RCP_HEIGHT/BUFFER_RCP_WIDTH):LOD_Brightness_Range;

float Brightness_Range=(BUFFER_WIDTH>=BUFFER_HEIGHT)?LOD_Brightness_Range:LOD_Brightness_Range*(BUFFER_RCP_WIDTH/BUFFER_RCP_HEIGHT);

float LOD= (buttondown==0 && Two_dimensional_input==1)?  mousepoint.x*ReShade::PixelSize.x*((LOD+0.5*LOD_Range)-(LOD-0.5*LOD_Range))+(LOD-0.5*LOD_Range):LOD;

float LOD_Pos=(buttondown==1 && Two_dimensional_input==1)?(LOD-(LOD-0.5*LOD_Range))/((LOD+0.5*LOD_Range)-(LOD-0.5*LOD_Range)):mousepoint.x*ReShade::PixelSize.x;

float Brightness= (buttondown==0 && Two_dimensional_input==1)?mousepoint.y*ReShade::PixelSize.y*((Brightness+0.5*Brightness_Range)-(Brightness-0.5*Brightness_Range))+(Brightness-0.5*Brightness_Range):Brightness;

float Brightness_Pos=(buttondown==1 && Two_dimensional_input==1)?(Brightness-(Brightness-0.5*Brightness_Range))/((Brightness+0.5*Brightness_Range)-(Brightness-0.5*Brightness_Range)):mousepoint.y*ReShade::PixelSize.y;


float c0Max=max(c0.r,max(c0.g,c0.b));

int x=0;
int y=0;
float count=0;
float accm=0;

			for (x=-1*dxy; x<=dxy; x+=1){
			for (y=-1*dxy; y<=dxy; y+=1){
			
			float4 current=tex2Dlod(ReShade::BackBuffer, float4(texcoord.x+float(x)*BUFFER_RCP_WIDTH, texcoord.y+float(y)*BUFFER_RCP_HEIGHT, 0, 0));
			float currentMax=max(current.r,max(current.g,current.b));
			
			float omit=(float2(float(x),float(y))==float2(0,0))?1:0;
			
			accm=(omit*Omit_centre_pixel==1)?accm:accm+currentMax;
			count=(omit*Omit_centre_pixel==1)?count:count+1;

				}
				}
				
float surrAvg=accm*pow(count,-1);

float dMax=max(1-surrAvg,max(surrAvg,max(1-c0Max,c0Max)));
float finalVal=pow(abs(c0Max),LOD*(dMax+1));
finalVal=pow(finalVal,Brightness);

c1.rgb=finalVal*(c1.rgb/c0Max);


float color=max(c1.r,max(c1.g,c1.b));
float colorOG=color;
color*=2;
color=(color<0.5)?pow(abs(0.5*color),greyChangeAmnt):1-(0.5*pow(abs(2-color),greyChangeAmnt));

c1.rgb=(Final_grey_S_curve==1)?saturate(color*(c0.rgb/colorOG)):c1.rgb;

float cl2=max(c1.r,max(c1.g,c1.b));

float cl3=(Final_grey_S_curve==1)?cl2:finalVal;

c1.rgb=(Debug!=1)?c1.rgb:cl3;

float4 c2=(texcoord.x>=Split_position*Split)?c1:c0;
float4 c3=(texcoord.x<=Split_position*Split)?c1:c0;

float4 c4=(Flip_split==1 && Split==1)?c3:c2;

float divLine = abs(texcoord.x - Split_position) < BUFFER_RCP_WIDTH;
c4 =(Split==0)?c4: c4*(1.0 - divLine); //invert divline

c4.rgb =(Two_dimensional_input==1 && Two_dimensional_input_type==0 && (abs(texcoord.x-LOD_Pos)<BUFFER_RCP_WIDTH || abs(texcoord.y-Brightness_Pos)<BUFFER_RCP_HEIGHT))?float3(0.369,0.745,0):c4.rgb;

c4.rgb =(Two_dimensional_input==1 && Two_dimensional_input_type==1 && (abs(texcoord.x-LOD_Pos)<3*BUFFER_RCP_WIDTH && abs(texcoord.y-Brightness_Pos)<3*BUFFER_RCP_HEIGHT))?float3(0.498,1,0):c4.rgb;

float4 res =float4(c4.rgb,0);

float textSize=33;

[flatten]if(Two_dimensional_input==1){
    DrawText_Digit(   DrawText_Shift(DrawText_Shift(float2(0.5*BUFFER_WIDTH,0), int2(-9, 0), textSize, 1), int2(8, 0), textSize, 1) , 
						textSize, 1, texcoord,  3, LOD, res,1); //Customxy.x
						
						
						DrawText_Digit(DrawText_Shift(DrawText_Shift(float2(0.5*BUFFER_WIDTH,0), int2(-9, 1), textSize, 1), int2(8, 0), textSize, 1) , 
						textSize, 1, texcoord,  3, Brightness, res,1);
}

c4.rgb=res.rgb;

return c4;

}

technique Line_Thinning {
	pass LineThin {
		VertexShader=PostProcessVS;
		PixelShader=PS_LineThin;
	}
}

//Original by kingeric1992, modded by crabshank 08/10/2019

#ifndef _DRAWTEXT_H_
#define _DRAWTEXT_H_

#define _DRAWTEXT_GRID_X 14.0
#define _DRAWTEXT_GRID_Y 7.0

///////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                   //
//  Available functions:                                                                             //
//      DrawText_String( offset, text size, xy ratio, input coord, string array, array size, output) //
//          float2 offset       = top left corner of string, screen hight pixel unit.                //
//          float  text size    = text size, screen hight pixel unit.                                //
//          float  xy ratio     = xy ratio of text.                                                  //
//          float2 input coord  = current texture coord.                                             //
//          int    string array = string data in float2 array format, ex: "Demo Text"                //
//              int String0[9] = { __D, __e, __m, __o, __Space, __T, __e, __x, __t};                 //
//          int    string size  = size of the string array.                                          //
//          float  output       = output.                                                            //
//                                                                                                   //
//      DrawText_Digit( offset, text size, xy ratio, input coord, precision after dot, data, output) //
//          float2 offset       = same as DrawText_String.                                           //
//          float  text size    = same as DrawText_String.                                           //
//          float  xy ratio     = same as DrawText_String.                                           //
//          float2 input coord  = same as DrawText_String.                                           //
//          int    precision    = digits after dot.                                                  //
//          float  data         = input float.                                                       //
//          float  output       = output.                                                            //
//                                                                                                   //
//      float2 DrawText_Shift(shift, text size, xy ratio)                                            //
//          float2 shift        = shift line(y) and column.                                          //
//          float text size     = same as DrawText_String.                                           //
//          float xy ratio      = same as DrawText_String.                                           //
//                                                                                                   //
///////////////////////////////////////////////////////////////////////////////////////////////////////


//Sample Usage

/*
float4 main_fragment( float4 position : POSITION,
                      float2 txcoord  : TEXCOORD) : COLOR {
    float res = 0.0;

    int line0[9]  = { __D, __e, __m, __o, __Space, __T, __e, __x, __t };   //Demo Text
    int line1[15] = { __b, __y, __Space, __k, __i, __n, __g, __e, __r, __i, __c, __1, __9, __9, __2 }; //by kingeric1992
    int line2[6]  = { __S, __i, __z, __e, __Colon, __Space }; // Size: %d.

    DrawText_String(float2(100.0 , 100.0), 32, 1, txcoord,  line0, 9, res);
    DrawText_String(float2(100.0 , 134.0), textSize, 1, txcoord,  line1, 15, res);
    DrawText_String(DrawText_Shift(float2(100.0 , 134.0), int2(0, 1), textSize, 1), 18, 1, txcoord,  line2, 6, res);
    DrawText_Digit(DrawText_Shift(DrawText_Shift(float2(100.0 , 134.0), int2(0, 1), textSize, 1), int2(8, 0), 18, 1),
                    18, 1, txcoord,  0, textSize, res);

    return res;
}

*/

//Text display
//Character indexing
#define __Space       0 //  (space)
#define __Exclam      1 //  !
#define __Quote       2 //  "
#define __Pound       3 //  #
#define __Dollar      4 //  $
#define __Percent     5 //  %
#define __And         6 //  &
#define __sQuote      7 //  '
#define __rBrac_O     8 //  (
#define __rBrac_C     9 //  )
#define __Asterisk   10 //  *
#define __Plus       11 //  +
#define __Comma      12 //  ,
#define __Minus      13 //  -

#define __Dot        14 //  .
#define __Slash      15 //  /
#define __0          16 //  0
#define __1          17 //  1
#define __2          18 //  2
#define __3          19 //  3
#define __4          20 //  4
#define __5          21 //  5
#define __6          22 //  6
#define __7          23 //  7
#define __8          24 //  8
#define __9          25 //  9
#define __Colon      26 //  :
#define __sColon     27 //  ;

#define __Less       28 //  <
#define __Equals     29 //  =
#define __Greater    30 //  >
#define __Question   31 //  ?
#define __at         32 //  @
#define __A          33 //  A
#define __B          34 //  B
#define __C          35 //  C
#define __D          36 //  D
#define __E          37 //  E
#define __F          38 //  F
#define __G          39 //  G
#define __H          40 //  H
#define __I          41 //  I

#define __J          42 //  J
#define __K          43 //  K
#define __L          44 //  L
#define __M          45 //  M
#define __N          46 //  N
#define __O          47 //  O
#define __P          48 //  P
#define __Q          49 //  Q
#define __R          50 //  R
#define __S          51 //  S
#define __T          52 //  T
#define __U          53 //  U
#define __V          54 //  V
#define __W          55 //  W

#define __X          56 //  X
#define __Y          57 //  Y
#define __Z          58 //  Z
#define __sBrac_O    59 //  [
#define __Backslash  60 //  \..
#define __sBrac_C    61 //  ]
#define __Caret      62 //  ^
#define __Underscore 63 //  _
#define __Punc       64 //  `
#define __a          65 //  a
#define __b          66 //  b
#define __c          67 //  c
#define __d          68 //  d
#define __e          69 //  e

#define __f          70 //  f
#define __g          71 //  g
#define __h          72 //  h
#define __i          73 //  i
#define __j          74 //  j
#define __k          75 //  k
#define __l          76 //  l
#define __m          77 //  m
#define __n          78 //  n
#define __o          79 //  o
#define __p          80 //  p
#define __q          81 //  q
#define __r          82 //  r
#define __s          83 //  s

#define __t          84 //  t
#define __u          85 //  u
#define __v          86 //  v
#define __w          87 //  w
#define __x          88 //  x
#define __y          89 //  y
#define __z          90 //  z
#define __cBrac_O    91 //  {
#define __vBar       92 //  |
#define __cBrac_C    93 //  }
#define __Tilde      94 //  ~
#define __tridot     95 // (...)
#define __empty0     96 // (null)
#define __empty1     97 // (null)
//Character indexing ends

texture Texttex < source = "FontAtlas.png"; > {
    Width  = 512;
    Height = 512;
};

sampler samplerText {
    Texture = Texttex;
};

//accomodate for undef array size.
#define DrawText_String(  pos, size, ratio, tex, array, arrSize, output ) \
    {   float  text = 0.0; \
        float2 uv = (tex * float2(BUFFER_WIDTH, BUFFER_HEIGHT) - pos) / size; \
        uv.y      = saturate(uv.y); \
        uv.x     *= ratio * 2.0; \
        float  id = array[int(trunc(uv.x))]; \
        if(uv.x  <= arrSize && uv.x >= 0.0) \
            text  = tex2D(samplerText, (frac(uv) + float2( id % 14.0, trunc(id / 14.0))) \
            / float2( _DRAWTEXT_GRID_X, _DRAWTEXT_GRID_Y) ).x; \
        output += text;  }

float2 DrawText_Shift( float2 pos, int2 shift, float size, float ratio ) {
    return pos + size * shift * float2(0.5, 1.0) / ratio;
}


	float mulTenIntPow(float number,float power){
float sign=(power>=0)?1:-1;
int pwr=uint(round(abs(power)));
[flatten]if(pwr>1){
for(int i=0; i<pwr;i++){
number=(sign==1)?number*10:number/10;
}
}else{
number=(sign==1)?number*10:number/10;
}

return number;
}

float rounder (float places,float number){
float sign=(number>=0)?1:-1;
int integer=int(round(mulTenIntPow(abs(number),places)));

return sign*(mulTenIntPow(float(round(integer)),-places));
}



void DrawText_Digit( float2 pos, float size, float ratio, float2 tex, int digit, float data, inout float4 res,float textGrey) {
    int digits[13] = {
        __0, __1, __2, __3, __4, __5, __6, __7, __8, __9, __Minus, __Space, __Dot
    };

    float2 uv = (tex * float2(BUFFER_WIDTH, BUFFER_HEIGHT) - pos) / size;
    uv.y      = saturate(uv.y);
    uv.x     *= ratio * 2.0;

data=rounder(digit,data);
    float  t  = abs(data);
    int numDigits = max(ceil(log2(t)/3.32192809),1);

    //early exit:
   if(uv.x <-numDigits-1 || uv.x > digit+1) return;

int index = 0;

[flatten]if(int(uv.x)==0){
index=round(trunc(frac(mulTenIntPow(t,-1))*10));
}else if(int(uv.x)<=-1){
index=round(trunc(frac(trunc(mulTenIntPow(t,uv.x))/10)*10));
}else if(int(uv.x)>=1){
index=round(frac(trunc(mulTenIntPow(t,int(uv.x)))/10)*10);
}

index=(int(uv.x)==0&&int(ceil(uv.x))==1)?12:index;

[flatten]if(int(uv.x)==-numDigits){
if(data>=0){
index=11;
}else{
index=10;
}
}

index=digits[int(index)];

    res  +=(textGrey*2-1)*tex2D(samplerText, (frac(uv) + float2( index % 14.0, trunc(index / 14.0))) /
               float2( _DRAWTEXT_GRID_X, _DRAWTEXT_GRID_Y)).x;
}

#endif

if(Omit_centre_pixel==1)
{
	if(x==0)
	{
		if(y==0)
		{
			accm=accm;
		}
		else
		{
			accm+=rgb2hsv(tex2Dlod(ReShade::BackBuffer, float4(tex.x+float(x)*BUFFER_RCP_WIDTH, tex.y+float(y)*BUFFER_RCP_HEIGHT, 0, 0)).rgb).z;
			count+=1;
		}
	}
	else
	{
		accm+=rgb2hsv(tex2Dlod(ReShade::BackBuffer, float4(tex.x+float(x)*BUFFER_RCP_WIDTH, tex.y+float(y)*BUFFER_RCP_HEIGHT, 0, 0)).rgb).z;
		count+=1;
	}
}
else
{
	accm+=rgb2hsv(tex2Dlod(ReShade::BackBuffer, float4(tex.x+float(x)*BUFFER_RCP_WIDTH, tex.y+float(y)*BUFFER_RCP_HEIGHT, 0, 0)).rgb).z;
	count+=1;
}

if(x==0 && (Omit_centre_pixel==1))
{
	accm+=y==0 ? 0 : rgb2hsv(tex2Dlod(ReShade::BackBuffer, float4(tex.x+float(x)*BUFFER_RCP_WIDTH, tex.y+float(y)*BUFFER_RCP_HEIGHT, 0, 0)).rgb).z;
	count+=(y!=0);
}
else
{
	accm+=rgb2hsv(tex2Dlod(ReShade::BackBuffer, float4(tex.x+float(x)*BUFFER_RCP_WIDTH, tex.y+float(y)*BUFFER_RCP_HEIGHT, 0, 0)).rgb).z;
	count+=1;
}