ProjectArcade

1
#include "ReShade.fxh"
2

3
uniform float display_sizeX <
4
	ui_type = "drag";
5
	ui_min = 1.0;
6
	ui_max = BUFFER_WIDTH;
7
	ui_label = "Screen Width (NTSC)";
8
> = 320.0;
9

10
uniform float display_sizeY <
11
	ui_type = "drag";
12
	ui_min = 1.0;
13
	ui_max = BUFFER_HEIGHT;
14
	ui_label = "Screen Height (NTSC)";
15
> = 240.0;
16

17
uniform bool bUseTwoPhase <
18
	ui_label = "Use Two-Phase (NTSC)";
19
> = false;
20

21
uniform bool bUseSVideo <
22
	ui_label = "Use S-Video (NTSC)";
23
	ui_tooltip = "Uses S-Video Cables instead of Composite.";
24
> = false;
25

26
uniform float NTSC_DISPLAY_GAMMA <
27
	ui_type = "drag";
28
	ui_min = 1.0;
29
	ui_max = 10.0;
30
	ui_step = 0.1;
31
	ui_label = "NTSC Display Gamma (NTSC)";
32
> = 2.1;
33

34
uniform float NTSC_CRT_GAMMA <
35
	ui_type = "drag";
36
	ui_min = 1.0;
37
	ui_max = 10.0;
38
	ui_step = 0.1;
39
	ui_label = "NTSC CRT Gamma (NTSC)";
40
> = 2.5;
41

42
#define PI 3.14159265
43

44
#define CHROMA_MOD_FREQ (PI / 3.0)
45
#define CHROMA_MOD_FREQ_TWO (4.0 * PI / 15.0)
46

47
#define SATURATION 1.0
48
#define BRIGHTNESS 1.0
49
#define ARTIFACTING 1.0
50
#define FRINGING 1.0
51

52
#define ARTIFACTING_SV 0.0
53
#define FRINGING_SV 0.0
54

55
#define display_size int2(display_sizeX,display_sizeY)
56

57
static const float3x3 mix_mat = float3x3(
58
      BRIGHTNESS, ARTIFACTING, ARTIFACTING,
59
      FRINGING, 2.0 * SATURATION, 0.0,
60
      FRINGING, 0.0, 2.0 * SATURATION 
61
);
62

63
static const float3x3 mix_mat_sv = float3x3(
64
      BRIGHTNESS, ARTIFACTING_SV, ARTIFACTING_SV,
65
      FRINGING_SV, 2.0 * SATURATION, 0.0,
66
      FRINGING_SV, 0.0, 2.0 * SATURATION 
67
);
68

69
static const float3x3 yiq2rgb_mat = float3x3(
70
   1.0, 0.956, 0.6210,
71
   1.0, -0.2720, -0.6474,
72
   1.0, -1.1060, 1.7046);
73

74
float3 yiq2rgb(float3 yiq)
75
{
76
   return mul(yiq2rgb_mat, yiq);
77
}
78

79
static const float3x3 yiq_mat = float3x3(
80
      0.2989, 0.5870, 0.1140,
81
      0.5959, -0.2744, -0.3216,
82
      0.2115, -0.5229, 0.3114
83
);
84

85
float3 rgb2yiq(float3 col)
86
{
87
   return mul(yiq_mat, col);
88
};
89

90
float fmod(float a, float b) {
91
    float c = frac(abs(a / b)) * abs(b);
92
    return (a < 0) ? -c : c;
93
};
94

95
texture target0_ntsc
96
{
97
    Width = BUFFER_WIDTH;
98
    Height = BUFFER_HEIGHT;
99
	Format = RGBA32F;
100
};
101
sampler s0 { Texture = target0_ntsc; };
102

103
uniform int framecount < source = "framecount"; >;
104

105
float4 NTSCStartPS( float4 pos : SV_Position, float2 texcoord : TEXCOORD0) : SV_Target
106
{
107
	return tex2D(s0,texcoord);
108
}
109

110
float4 NTSCEncodePS( float4 pos : SV_Position, float2 texcoord : TEXCOORD0) : SV_Target
111
{
112
	float3 col = tex2D(ReShade::BackBuffer, texcoord).rgb;
113
	float3 yiq = rgb2yiq(col);
114
	
115
	float2 pix_no = texcoord * display_size * float2( 4.0, 1.0 );
116
	float2 one = 1.0 / ReShade::ScreenSize;
117
	
118
	float chroma_phase = 0.6667 * PI * (fmod(pix_no.y, 3.0) + framecount);
119
	float mod_phase = chroma_phase + pix_no.x * CHROMA_MOD_FREQ;
120
	
121
	if (bUseTwoPhase){
122
		chroma_phase = PI * (fmod(pix_no.y, 2.0) + framecount);
123
		mod_phase = chroma_phase + pix_no.x * CHROMA_MOD_FREQ_TWO;
124
	}
125

126
	float i_mod = cos(mod_phase);
127
	float q_mod = sin(mod_phase);
128
	
129
	if(bUseSVideo){
130
		yiq.yz *= float2(i_mod, q_mod); // Modulate.
131
		yiq = mul(mix_mat_sv,yiq); // Cross-talk.
132
		yiq.yz *= float2(i_mod, q_mod); // Demodulate.
133
	} else {
134
		yiq.yz *= float2(i_mod, q_mod); // Modulate.
135
		yiq = mul(mix_mat,yiq); // Cross-talk.
136
		yiq.yz *= float2(i_mod, q_mod); // Demodulate.
137
	}
138
	
139
	return float4(yiq, 1.0);
140
}
141

142
float3 t2d(float2 texcoord)
143
{
144
	return tex2D(s0,texcoord).rgb;
145
}
146

147
#define fixCoord (texcoord - float2( 0.5 * one_x, 0.0)) 
148
#define fetch_offset(offset, one_x) t2d(fixCoord + float2( (offset) * (one_x), 0.0))
149

150
float4 NTSCDecodePS( float4 pos : SV_Position, float2 texcoord : TEXCOORD0) : SV_Target
151
{
152
	int TAPS = 24;
153
	
154
	float luma_filter[33] = {
155
		0.000000000,
156
		0.000000000,
157
		0.000000000,
158
		0.000000000,
159
		0.000000000,
160
		0.000000000,
161
		0.000000000,
162
		0.000000000,
163
		0.000000000,
164
		0.000000000,
165
		0.000000000,
166
		0.000000000,
167
		0.000000000,
168
		0.000000000,
169
		0.000000000,
170
		0.000000000,
171
		0.000000000,
172
		0.000000000,
173
		0.000000000,
174
		0.000000000,
175
		0.000000000,
176
		0.000000000,
177
		0.000000000,
178
		0.000000000,
179
		0.000000000,
180
		0.000000000,
181
		0.000000000,
182
		0.000000000,
183
		0.000000000,
184
		0.000000000,
185
		0.000000000,
186
		0.000000000,
187
		0.000000000
188
	};
189
	
190
	float chroma_filter[33] = {
191
		0.000000000,
192
		0.000000000,
193
		0.000000000,
194
		0.000000000,
195
		0.000000000,
196
		0.000000000,
197
		0.000000000,
198
		0.000000000,
199
		0.000000000,
200
		0.000000000,
201
		0.000000000,
202
		0.000000000,
203
		0.000000000,
204
		0.000000000,
205
		0.000000000,
206
		0.000000000,
207
		0.000000000,
208
		0.000000000,
209
		0.000000000,
210
		0.000000000,
211
		0.000000000,
212
		0.000000000,
213
		0.000000000,
214
		0.000000000,
215
		0.000000000,
216
		0.000000000,
217
		0.000000000,
218
		0.000000000,
219
		0.000000000,
220
		0.000000000,
221
		0.000000000,
222
		0.000000000,
223
		0.000000000
224
	};
225
	
226
	luma_filter[0] =	-0.000012020;
227
	luma_filter[1] =	-0.000022146;
228
	luma_filter[2] =	-0.000013155;
229
	luma_filter[3] =	-0.000012020;
230
	luma_filter[4] =	-0.000049979;
231
	luma_filter[5] =	-0.000113940;
232
	luma_filter[6] =	-0.000122150;
233
	luma_filter[7] =	-0.000005612;
234
	luma_filter[8] =	0.000170516;
235
	luma_filter[9] =	0.000237199;
236
	luma_filter[10] =	0.000169640;
237
	luma_filter[11] =	0.000285688;
238
	luma_filter[12] =	0.000984574;
239
	luma_filter[13] =	0.002018683;
240
	luma_filter[14] =	0.002002275;
241
	luma_filter[15] =	-0.000909882;
242
	luma_filter[16] =	-0.007049081;
243
	luma_filter[17] =	-0.013222860;
244
	luma_filter[18] =	-0.012606931;
245
	luma_filter[19] =	0.002460860;
246
	luma_filter[20] =	0.035868225;
247
	luma_filter[21] =	0.084016453;
248
	luma_filter[22] =	0.135563500;
249
	luma_filter[23] =	0.175261268;
250
	luma_filter[24] =	0.190176552;
251

252
	chroma_filter[0] =	-0.000118847;
253
	chroma_filter[1] =	-0.000271306;
254
	chroma_filter[2] =	-0.000502642;
255
	chroma_filter[3] =	-0.000930833;
256
	chroma_filter[4] =	-0.001451013;
257
	chroma_filter[5] =	-0.002064744;
258
	chroma_filter[6] =	-0.002700432;
259
	chroma_filter[7] =	-0.003241276;
260
	chroma_filter[8] =	-0.003524948;
261
	chroma_filter[9] =	-0.003350284;
262
	chroma_filter[10] =	-0.002491729;
263
	chroma_filter[11] =	-0.000721149;
264
	chroma_filter[12] =	0.002164659;
265
	chroma_filter[13] =	0.006313635;
266
	chroma_filter[14] =	0.011789103;
267
	chroma_filter[15] =	0.018545660;
268
	chroma_filter[16] =	0.026414396;
269
	chroma_filter[17] =	0.035100710;
270
	chroma_filter[18] =	0.044196567;
271
	chroma_filter[19] =	0.053207202;
272
	chroma_filter[20] =	0.061590275;
273
	chroma_filter[21] =	0.068803602;
274
	chroma_filter[22] =	0.074356193;
275
	chroma_filter[23] =	0.077856564;
276
	chroma_filter[24] =	0.079052396;
277
	
278
	if (bUseTwoPhase){
279
		
280
		TAPS = 32;
281
	
282
		luma_filter[0] =	-0.000205844;
283
		luma_filter[1] =	-0.000149453;
284
		luma_filter[2] =	-0.000051693;
285
		luma_filter[3] =	0.000000000;
286
		luma_filter[4] =	-0.000066171;
287
		luma_filter[5] =	-0.000245058;
288
		luma_filter[6] =	-0.000432928;
289
		luma_filter[7] =	-0.000472644;
290
		luma_filter[8] =	-0.000252236;
291
		luma_filter[9] =	0.000198929;
292
		luma_filter[10] =	0.000687058;
293
		luma_filter[11] =	0.000944112;
294
		luma_filter[12] =	0.000803467;
295
		luma_filter[13] =	0.000363199;
296
		luma_filter[14] =	0.000013422;
297
		luma_filter[15] =	0.000253402;
298
		luma_filter[16] =	0.001339461;
299
		luma_filter[17] =	0.002932972;
300
		luma_filter[18] =	0.003983485;
301
		luma_filter[19] =	0.003026683;
302
		luma_filter[20] =	-0.001102056;
303
		luma_filter[21] =	-0.008373026;
304
		luma_filter[22] =	-0.016897700;
305
		luma_filter[23] =	-0.022914480;
306
		luma_filter[24] =	-0.021642347;
307
		luma_filter[25] =	-0.008863273;
308
		luma_filter[26] =	0.017271957;
309
		luma_filter[27] =	0.054921920;
310
		luma_filter[28] =	0.098342579;
311
		luma_filter[29] =	0.139044281;
312
		luma_filter[30] =	0.168055832;
313
		luma_filter[31] =	0.178571429;
314
			
315
		chroma_filter[0] =	0.001384762;
316
		chroma_filter[1] =	0.001678312;
317
		chroma_filter[2] =	0.002021715;
318
		chroma_filter[3] =	0.002420562;
319
		chroma_filter[4] =	0.002880460;
320
		chroma_filter[5] =	0.003406879;
321
		chroma_filter[6] =	0.004004985;
322
		chroma_filter[7] =	0.004679445; 
323
		chroma_filter[8] =	0.005434218;
324
		chroma_filter[9] =	0.006272332; 
325
		chroma_filter[10] =	0.007195654; 
326
		chroma_filter[11] =	0.008204665; 
327
		chroma_filter[12] =	0.009298238; 
328
		chroma_filter[13] =	0.010473450;
329
		chroma_filter[14] =	0.011725413; 
330
		chroma_filter[15] =	0.013047155;
331
		chroma_filter[16] =	0.014429548;
332
		chroma_filter[17] =	0.015861306; 
333
		chroma_filter[18] =	0.017329037; 
334
		chroma_filter[19] =	0.018817382;
335
		chroma_filter[20] =	0.020309220; 
336
		chroma_filter[21] =	0.021785952;
337
		chroma_filter[22] =	0.023227857;
338
		chroma_filter[23] =	0.024614500; 
339
		chroma_filter[24] =	0.025925203;
340
		chroma_filter[25] =	0.027139546; 
341
		chroma_filter[26] =	0.028237893;
342
		chroma_filter[27] =	0.029201910; 
343
		chroma_filter[28] =	0.030015081; 
344
		chroma_filter[29] =	0.030663170;
345
		chroma_filter[30] =	0.031134640;
346
		chroma_filter[31] =	0.031420995; 
347
		chroma_filter[32] =	0.031517031;
348
	}
349
	
350
	float one_x = 1.0 / ReShade::ScreenSize.x;
351
	one_x *= 0.5;
352
	
353
	float3 signal = float3(0.0,0.0,0.0);
354
	for (int i = 0; i < TAPS; i++)
355
	{
356
	   float offset = float(i);
357

358
	   float3 sums = fetch_offset(offset - float(TAPS), one_x) +
359
		  fetch_offset(float(TAPS) - offset, one_x);
360

361
	   signal += sums * float3(luma_filter[i], chroma_filter[i], chroma_filter[i]);
362
	}
363
	signal += tex2D(s0, texcoord).xyz *
364
	   float3(luma_filter[TAPS], chroma_filter[TAPS], chroma_filter[TAPS]);
365
	   
366
   float3 rgb = yiq2rgb(signal);
367
   return float4(rgb, 1.0);
368
}
369

370
float4 NTSCGaussPS( float4 pos : SV_Position, float2 texcoord : TEXCOORD0) : SV_Target
371
{
372

373
	float2 pix_no = texcoord * display_size * float2( 4.0, 1.0 );
374
	float2 one = 1.0 / ReShade::ScreenSize;
375

376
   #define TEX(off) pow(tex2D(ReShade::BackBuffer, texcoord + float2(0.0, (off) * one.y)).rgb, float3(NTSC_CRT_GAMMA,NTSC_CRT_GAMMA,NTSC_CRT_GAMMA))
377

378
   float3 frame0 = TEX(-2.0);
379
   float3 frame1 = TEX(-1.0);
380
   float3 frame2 = TEX(0.0);
381
   float3 frame3 = TEX(1.0);
382
   float3 frame4 = TEX(2.0);
383

384
   float offset_dist = frac(pix_no.y) - 0.5;
385
   float dist0 =  2.0 + offset_dist;
386
   float dist1 =  1.0 + offset_dist;
387
   float dist2 =  0.0 + offset_dist;
388
   float dist3 = -1.0 + offset_dist;
389
   float dist4 = -2.0 + offset_dist;
390

391
   float3 scanline = frame0 * exp(-5.0 * dist0 * dist0);
392
   scanline += frame1 * exp(-5.0 * dist1 * dist1);
393
   scanline += frame2 * exp(-5.0 * dist2 * dist2);
394
   scanline += frame3 * exp(-5.0 * dist3 * dist3);
395
   scanline += frame4 * exp(-5.0 * dist4 * dist4);
396

397
   return float4(pow(1.15 * scanline, float3(1.0 / NTSC_DISPLAY_GAMMA, 1.0 / NTSC_DISPLAY_GAMMA, 1.0 / NTSC_DISPLAY_GAMMA)), 1.0);
398
}
399

400
float4 NTSCFinalPS( float4 pos : SV_Position, float2 texcoord : TEXCOORD0) : SV_Target
401
{
402
	return tex2D(ReShade::BackBuffer,texcoord);
403
}
404

405

406
technique NTSC_RetroArch
407
{	
408
	// first pass: encode s-video signal
409
	pass p1
410
	{	
411
		RenderTarget = target0_ntsc;
412
		
413
		VertexShader = PostProcessVS;
414
		PixelShader = NTSCEncodePS;
415
	}
416
	
417
	// second pass: decode composite signal
418
	pass p2
419
	{
420
		VertexShader = PostProcessVS;
421
		PixelShader = NTSCDecodePS;
422
	}
423
	// third pass: adds gaussian with scanlines
424
	pass p3
425
	{
426
		VertexShader = PostProcessVS;
427
		PixelShader = NTSCGaussPS;
428
	}
429
	// final pass: decode composite signal
430
	pass p4
431
	{
432
		VertexShader = PostProcessVS;
433
		PixelShader = NTSCFinalPS;
434
	}
435
}