API tools faq
paste
Guest User

Untitled

a guest
Jan 23rd, 2024
99
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 70.29 KB | None | 0 0
raw download clone embed print report
  1. #version 450
  2.  
  3. /*
  4. A shader that tries to emulate a sony PVM type aperture grille screen but with full brightness.
  5.  
  6. The novel thing about this shader is that it relies on the HDR shaders to brighten up the image so that when
  7. we apply this shader which emulates the apperture grille the resulting screen isn't left too dark.
  8.  
  9. I think you need at least a DisplayHDR 600 monitor but to get close to CRT levels of brightness I think DisplayHDR 1000.
  10.  
  11. Please Enable HDR in RetroArch 1.10+
  12.  
  13. NOTE: when this shader is envoked the Contrast, Peak Luminance and Paper White Luminance in the HDR menu do nothing instead set those values through the shader parameters
  14.  
  15. For this shader set Paper White Luminance to above 700 and Peak Luminance to the peak luminance of your monitor.
  16.  
  17. Also try to use a integer scaling - its just better - overscaling is fine.
  18.  
  19. This shader doesn't do any geometry warping or bouncing of light around inside the screen etc - I think these effects just add unwanted noise, I know people disagree. Please feel free to make you own and add them
  20.  
  21. Dont use this shader directly - use the hdr\crt-make-model-hdr.slangp where make and model are the make and model of the CRT you want.
  22.  
  23. THIS SHADER DOES NOT SUPPORT WRGB OLED (Due to the sub pixel layout of WRGB - RGB QD-OLED or LCD (and variants thereof screens are fine)
  24. */
  25.  
  26. #pragma format A2B10G10R10_UNORM_PACK32
  27.  
  28. layout(push_constant) uniform Push
  29. {
  30. // User Settings
  31. float hcrt_hdr;
  32. float hcrt_colour_space;
  33. float hcrt_max_nits;
  34. float hcrt_paper_white_nits;
  35. float hcrt_expand_gamut;
  36.  
  37. float hcrt_colour_accurate;
  38.  
  39. float hcrt_lcd_resolution;
  40. float hcrt_lcd_subpixel;
  41.  
  42. float hcrt_red_vertical_convergence;
  43. float hcrt_green_vertical_convergence;
  44. float hcrt_blue_vertical_convergence;
  45. float hcrt_red_horizontal_convergence;
  46. float hcrt_green_horizontal_convergence;
  47. float hcrt_blue_horizontal_convergence;
  48.  
  49. // Developer Settings
  50. float hcrt_crt_screen_type;
  51. float hcrt_crt_resolution;
  52.  
  53. // Vertical Settings
  54. float hcrt_red_scanline_min;
  55. float hcrt_red_scanline_max;
  56. float hcrt_red_scanline_attack;
  57. float hcrt_green_scanline_min;
  58. float hcrt_green_scanline_max;
  59. float hcrt_green_scanline_attack;
  60. float hcrt_blue_scanline_min;
  61. float hcrt_blue_scanline_max;
  62. float hcrt_blue_scanline_attack;
  63.  
  64. // Horizontal Settings
  65. float hcrt_red_beam_sharpness;
  66. float hcrt_red_beam_attack;
  67. float hcrt_green_beam_sharpness;
  68. float hcrt_green_beam_attack;
  69. float hcrt_blue_beam_sharpness;
  70. float hcrt_blue_beam_attack;
  71.  
  72. } params;
  73.  
  74. layout(std140, set = 0, binding = 0) uniform UBO
  75. {
  76. mat4 MVP;
  77. vec4 SourceSize;
  78. vec4 OriginalSize;
  79. vec4 OutputSize;
  80. uint FrameCount;
  81.  
  82. float hcrt_r709_gamma_out;
  83. float hcrt_srgb_gamma_out;
  84. float hcrt_p3_gamma_out;
  85. float hcrt_r709_gamma_cutoff;
  86. float hcrt_srgb_gamma_cutoff;
  87.  
  88. float hcrt_h_size;
  89. float hcrt_v_size;
  90. float hcrt_h_cent;
  91. float hcrt_v_cent;
  92. float hcrt_pin_phase;
  93. float hcrt_pin_amp;
  94. } global;
  95.  
  96. #include "include/parameters.h"
  97.  
  98. #define HCRT_HDR params.hcrt_hdr
  99. #define HCRT_OUTPUT_COLOUR_SPACE params.hcrt_colour_space
  100. #define HCRT_MAX_NITS params.hcrt_max_nits
  101. #define HCRT_PAPER_WHITE_NITS params.hcrt_paper_white_nits
  102. #define HCRT_EXPAND_GAMUT params.hcrt_expand_gamut
  103. #define HCRT_R709_GAMMA_OUT global.hcrt_r709_gamma_out
  104. #define HCRT_SRGB_GAMMA_OUT global.hcrt_srgb_gamma_out
  105. #define HCRT_P3_GAMMA_OUT global.hcrt_p3_gamma_out
  106. #define HCRT_R709_GAMMA_CUTOFF global.hcrt_r709_gamma_cutoff
  107. #define HCRT_SRGB_GAMMA_CUTOFF global.hcrt_srgb_gamma_cutoff
  108. #define HCRT_COLOUR_ACCURATE params.hcrt_colour_accurate
  109.  
  110. #define HCRT_LCD_RESOLUTION params.hcrt_lcd_resolution
  111. #define HCRT_LCD_SUBPIXEL params.hcrt_lcd_subpixel
  112. #define HCRT_RED_VERTICAL_CONVERGENCE params.hcrt_red_vertical_convergence
  113. #define HCRT_GREEN_VERTICAL_CONVERGENCE params.hcrt_green_vertical_convergence
  114. #define HCRT_BLUE_VERTICAL_CONVERGENCE params.hcrt_blue_vertical_convergence
  115. #define HCRT_RED_HORIZONTAL_CONVERGENCE params.hcrt_red_horizontal_convergence
  116. #define HCRT_GREEN_HORIZONTAL_CONVERGENCE params.hcrt_green_horizontal_convergence
  117. #define HCRT_BLUE_HORIZONTAL_CONVERGENCE params.hcrt_blue_horizontal_convergence
  118.  
  119. #define HCRT_CRT_SCREEN_TYPE params.hcrt_crt_screen_type
  120. #define HCRT_CRT_RESOLUTION params.hcrt_crt_resolution
  121.  
  122. #define HCRT_RED_SCANLINE_MIN params.hcrt_red_scanline_min
  123. #define HCRT_RED_SCANLINE_MAX params.hcrt_red_scanline_max
  124. #define HCRT_RED_SCANLINE_ATTACK params.hcrt_red_scanline_attack
  125. #define HCRT_GREEN_SCANLINE_MIN params.hcrt_green_scanline_min
  126. #define HCRT_GREEN_SCANLINE_MAX params.hcrt_green_scanline_max
  127. #define HCRT_GREEN_SCANLINE_ATTACK params.hcrt_green_scanline_attack
  128. #define HCRT_BLUE_SCANLINE_MIN params.hcrt_blue_scanline_min
  129. #define HCRT_BLUE_SCANLINE_MAX params.hcrt_blue_scanline_max
  130. #define HCRT_BLUE_SCANLINE_ATTACK params.hcrt_blue_scanline_attack
  131.  
  132. #define HCRT_RED_BEAM_SHARPNESS params.hcrt_red_beam_sharpness
  133. #define HCRT_RED_BEAM_ATTACK params.hcrt_red_beam_attack
  134. #define HCRT_GREEN_BEAM_SHARPNESS params.hcrt_green_beam_sharpness
  135. #define HCRT_GREEN_BEAM_ATTACK params.hcrt_green_beam_attack
  136. #define HCRT_BLUE_BEAM_SHARPNESS params.hcrt_blue_beam_sharpness
  137. #define HCRT_BLUE_BEAM_ATTACK params.hcrt_blue_beam_attack
  138.  
  139. #define HCRT_H_SIZE global.hcrt_h_size
  140. #define HCRT_V_SIZE global.hcrt_v_size
  141. #define HCRT_H_CENT global.hcrt_h_cent
  142. #define HCRT_V_CENT global.hcrt_v_cent
  143. #define HCRT_PIN_PHASE global.hcrt_pin_phase
  144. #define HCRT_PIN_AMP global.hcrt_pin_amp
  145.  
  146. #define COMPAT_TEXTURE(c, d) texture(c, d)
  147.  
  148. #pragma stage vertex
  149. layout(location = 0) in vec4 Position;
  150. layout(location = 1) in vec2 TexCoord;
  151. layout(location = 0) out vec2 vTexCoord;
  152.  
  153. void main()
  154. {
  155. gl_Position = global.MVP * Position;
  156. vTexCoord = TexCoord * vec2(1.00001); // To resolve rounding issues when sampling
  157. }
  158.  
  159. #pragma stage fragment
  160. layout(location = 0) in vec2 vTexCoord;
  161. layout(location = 0) out vec4 FragColor;
  162. layout(set = 0, binding = 2) uniform sampler2D SourceSDR;
  163. layout(set = 0, binding = 3) uniform sampler2D SourceHDR;
  164.  
  165.  
  166. #define kChannelMask 3
  167. #define kFirstChannelShift 2
  168. #define kSecondChannelShift 4
  169. #define kThirdChannelShift 6
  170.  
  171. #define kRedId 0
  172. #define kGreenId 1
  173. #define kBlueId 2
  174.  
  175. #define kRed (1 | (kRedId << kFirstChannelShift))
  176. #define kGreen (1 | (kGreenId << kFirstChannelShift))
  177. #define kBlue (1 | (kBlueId << kFirstChannelShift))
  178. #define kMagenta (2 | (kRedId << kFirstChannelShift) | (kBlueId << kSecondChannelShift))
  179. #define kYellow (2 | (kRedId << kFirstChannelShift) | (kGreenId << kSecondChannelShift))
  180. #define kCyan (2 | (kGreenId << kFirstChannelShift) | (kBlueId << kSecondChannelShift))
  181. #define kWhite (3 | (kRedId << kFirstChannelShift) | (kGreenId << kSecondChannelShift) | (kBlueId << kThirdChannelShift))
  182. #define kBlack 0
  183.  
  184. #define kRedChannel vec3(1.0, 0.0, 0.0)
  185. #define kGreenChannel vec3(0.0, 1.0, 0.0)
  186. #define kBlueChannel vec3(0.0, 0.0, 1.0)
  187.  
  188. const vec3 kColourMask[3] = { kRedChannel, kGreenChannel, kBlueChannel };
  189.  
  190. #define kApertureGrille 0
  191. #define kShadowMask 1
  192. #define kSlotMask 2
  193. #define kBlackWhiteMask 3
  194.  
  195. #define kBGRAxis 3
  196. #define kTVLAxis 4
  197. #define kResolutionAxis 3
  198.  
  199. // APERTURE GRILLE MASKS
  200.  
  201. const float kApertureGrilleMaskSize[kResolutionAxis * kTVLAxis] = {
  202. 4.0f, 2.0f, 1.0f, 1.0f , // 1080p: 300 TVL, 600 TVL, 800 TVL, 1000 TVL
  203. 7.0f, 4.0f, 3.0f, 2.0f , // 4K: 300 TVL, 600 TVL, 800 TVL, 1000 TVL
  204. 13.0f, 7.0f, 5.0f, 4.0f }; // 8K: 300 TVL, 600 TVL, 800 TVL, 1000 TVL
  205.  
  206. // SHADOW MASKS
  207.  
  208. const float kShadowMaskSizeX[kResolutionAxis * kTVLAxis] = { 6.0f, 2.0f, 1.0f, 1.0f , 12.0f, 6.0f, 2.0f, 2.0f , 12.0f, 12.0f, 6.0f, 6.0f };
  209. const float kShadowMaskSizeY[kResolutionAxis * kTVLAxis] = { 4.0f, 2.0f, 1.0f, 1.0f , 8.0f, 4.0f, 2.0f, 2.0f , 8.0f, 8.0f, 4.0f, 4.0f };
  210.  
  211. // SLOT MASKS
  212.  
  213. const float kSlotMaskSizeX[kResolutionAxis * kTVLAxis] = { 4.0f, 2.0f, 1.0f, 1.0f , 7.0f, 4.0f, 3.0f, 2.0f , 7.0f, 7.0f, 5.0f, 4.0f }; //1080p: 300 TVL, 600 TVL, 800 TVL, 1000 TVL 4K: 300 TVL, 600 TVL, 800 TVL, 1000 TVL 8K: 300 TVL, 600 TVL, 800 TVL, 1000 TVL
  214. const float kSlotMaskSizeY[kResolutionAxis * kTVLAxis] = { 4.0f, 4.0f, 1.0f, 1.0f , 8.0f, 6.0f, 4.0f, 4.0f , 6.0f, 6.0f, 4.0f, 4.0f }; //1080p: 300 TVL, 600 TVL, 800 TVL, 1000 TVL 4K: 300 TVL, 600 TVL, 800 TVL, 1000 TVL 8K: 300 TVL, 600 TVL, 800 TVL, 1000 TVL
  215.  
  216.  
  217. #include "include/scanline_generation.h"
  218. #include "include/gamma_correct.h"
  219.  
  220. #define k1080p 0
  221. #define k4K 1
  222. #define k8K 2
  223.  
  224. #define k300TVL 0
  225. #define k600TVL 1
  226. #define k800TVL 2
  227. #define k1000TVL 3
  228.  
  229. float rand(vec2 n) {
  230. return fract(sin(dot(n, vec2(12.9898, 4.1414))) * 43758.5453);
  231. }
  232.  
  233. float noise(vec2 p){
  234. vec2 ip = floor(p);
  235. vec2 u = fract(p);
  236. u = u*u*(3.0-2.0*u);
  237.  
  238. float res = mix(
  239. mix(rand(ip),rand(ip+vec2(1.0,0.0)),u.x),
  240. mix(rand(ip+vec2(0.0,1.0)),rand(ip+vec2(1.0,1.0)),u.x),u.y);
  241. return res*res;
  242. }
  243.  
  244. void main()
  245. {
  246. const uint screen_type = uint(HCRT_CRT_SCREEN_TYPE);
  247. const uint crt_resolution = uint(HCRT_CRT_RESOLUTION);
  248. const uint lcd_resolution = uint(HCRT_LCD_RESOLUTION);
  249. const uint lcd_subpixel_layout = uint(HCRT_LCD_SUBPIXEL);
  250. const vec2 source_size = global.SourceSize.xy;
  251. const vec2 output_size = global.OutputSize.xy;
  252.  
  253. vec2 tex_coord = vTexCoord - vec2(0.5f);
  254. tex_coord = tex_coord * vec2(1.0f + (HCRT_PIN_PHASE * tex_coord.y), 1.0f);
  255. tex_coord = tex_coord * vec2(HCRT_H_SIZE, HCRT_V_SIZE);
  256. tex_coord = tex_coord + vec2(0.5f);
  257. tex_coord = tex_coord + (vec2(HCRT_H_CENT, HCRT_V_CENT) / output_size);
  258.  
  259. const vec2 current_position = vTexCoord * output_size;
  260.  
  261. uint colour_mask = 0;
  262.  
  263. switch(screen_type)
  264. {
  265. case kApertureGrille:
  266. {
  267. uint mask = uint(floor(mod(current_position.x, kApertureGrilleMaskSize[(lcd_resolution * kTVLAxis) + crt_resolution])));
  268.  
  269. switch(lcd_resolution)
  270. {
  271. case k1080p:
  272. {
  273. switch(crt_resolution)
  274. {
  275. case k300TVL:
  276. {
  277. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  278. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  279. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  280.  
  281. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  282. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  283.  
  284. #undef kRGBX
  285. #undef kRBGX
  286. #undef kBGRX
  287.  
  288. break;
  289. }
  290. case k600TVL:
  291. {
  292. #define kMG (kMagenta << 0) | (kGreen << 6)
  293. #define kYB (kYellow << 0) | (kBlue << 6)
  294. #define kGM (kGreen << 0) | (kMagenta << 6)
  295.  
  296. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  297. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  298.  
  299. #undef kMG
  300. #undef kYB
  301. #undef kGM
  302.  
  303. break;
  304. }
  305. case k800TVL:
  306. {
  307. colour_mask = kWhite;
  308.  
  309. break;
  310. }
  311. case k1000TVL:
  312. {
  313. colour_mask = kWhite;
  314.  
  315. break;
  316. }
  317. default:
  318. {
  319. break;
  320. }
  321. }
  322.  
  323. break;
  324. }
  325. case k4K:
  326. {
  327. switch(crt_resolution)
  328. {
  329. case k300TVL:
  330. {
  331. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  332. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  333. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  334.  
  335. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  336. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  337.  
  338. #undef kRRGGBBX
  339. #undef kRRBBGGX
  340. #undef kBBGGRRX
  341.  
  342. break;
  343. }
  344. case k600TVL:
  345. {
  346. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  347. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  348. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  349.  
  350. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  351. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  352.  
  353. #undef kRGBX
  354. #undef kRBGX
  355. #undef kBGRX
  356.  
  357. break;
  358. }
  359. case k800TVL:
  360. {
  361. #define kBGR (kBlue << 0) | (kGreen << 4) | (kRed << 8)
  362. #define kGBR (kGreen << 0) | (kBlue << 4) | (kRed << 8)
  363. #define kRGB (kRed << 0) | (kGreen << 4) | (kBlue << 8)
  364.  
  365. const uint rgb_mask[kBGRAxis] = { kBGR, kGBR, kRGB };
  366. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  367.  
  368. #undef kRGB
  369. #undef kGBR
  370. #undef kBGR
  371.  
  372. break;
  373. }
  374. case k1000TVL:
  375. {
  376. #define kMG (kMagenta << 0) | (kGreen << 6)
  377. #define kYB (kYellow << 0) | (kBlue << 6)
  378. #define kGM (kGreen << 0) | (kMagenta << 6)
  379.  
  380. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  381. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  382.  
  383. #undef kMG
  384. #undef kYB
  385. #undef kGM
  386.  
  387. break;
  388. }
  389. default:
  390. {
  391. break;
  392. }
  393. }
  394.  
  395. break;
  396. }
  397. case k8K:
  398. {
  399. switch(crt_resolution)
  400. {
  401. case k300TVL:
  402. {
  403. #define kMaxApertureGrilleSize 13
  404.  
  405. #define kRRRRGGGGBBBBX kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kBlack
  406. #define kRRRRBBBBGGGGX kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kBlack
  407. #define kBBBBGGGGRRRRX kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed, kBlack
  408.  
  409. const uint kApertureGrilleMasks8K300TVL[kBGRAxis * kMaxApertureGrilleSize] =
  410. {
  411. kRRRRGGGGBBBBX, kRRRRBBBBGGGGX, kBBBBGGGGRRRRX
  412. };
  413.  
  414. colour_mask = kApertureGrilleMasks8K300TVL[(lcd_subpixel_layout * kMaxApertureGrilleSize) + mask];
  415.  
  416. #undef kMaxApertureGrilleSize
  417.  
  418. #undef kRRRRGGGGBBBBX
  419. #undef kRRRRBBBBGGGGX
  420. #undef kBBBBGGGGRRRRX
  421.  
  422. break;
  423. }
  424. case k600TVL:
  425. {
  426. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  427. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  428. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  429.  
  430. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  431.  
  432. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  433.  
  434. #undef kRRGGBBX
  435. #undef kRRBBGGX
  436. #undef kBBGGRRX
  437.  
  438. break;
  439. }
  440. case k800TVL:
  441. {
  442. #define kRYCBX (kRed << 0) | (kYellow << 6) | (kCyan << 12) | (kBlue << 18) | (kBlack << 24)
  443. #define kRMCGX (kRed << 0) | (kMagenta << 6) | (kCyan << 12) | (kGreen << 18) | (kBlack << 24)
  444. #define kBCYRX (kBlue << 0) | (kCyan << 6) | (kYellow << 12) | (kRed << 18) | (kBlack << 24)
  445.  
  446. const uint rgb_mask[kBGRAxis] = { kRYCBX, kRMCGX, kBCYRX };
  447. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  448.  
  449. #undef kRYCBX
  450. #undef kRMCGX
  451. #undef kBCYRX
  452.  
  453. break;
  454. }
  455. case k1000TVL:
  456. {
  457. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  458. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  459. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  460.  
  461. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  462.  
  463. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  464.  
  465. #undef kRGBX
  466. #undef kRBGX
  467. #undef kBGRX
  468.  
  469. break;
  470. }
  471. default:
  472. {
  473. break;
  474. }
  475. }
  476.  
  477. break;
  478. }
  479. default:
  480. {
  481. break;
  482. }
  483. }
  484.  
  485. break;
  486. }
  487. case kShadowMask:
  488. {
  489. uint shadow_y = uint(floor(mod(current_position.y, kShadowMaskSizeY[(lcd_resolution * kTVLAxis) + crt_resolution])));
  490.  
  491. uint mask = uint(floor(mod(current_position.x, kShadowMaskSizeX[(lcd_resolution * kTVLAxis) + crt_resolution])));
  492.  
  493. switch(lcd_resolution)
  494. {
  495. case k1080p:
  496. {
  497. switch(crt_resolution)
  498. {
  499. case k300TVL:
  500. {
  501. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  502. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  503.  
  504. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  505. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  506.  
  507. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  508. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  509.  
  510. /*
  511. kGRRBBG
  512. kGRRBBG
  513. kBBGGRR
  514. kBBGGRR
  515.  
  516. kBRRGGB
  517. kBRRGGB
  518. kGGBBRR
  519. kGGBBRR
  520.  
  521. kGBBRRG
  522. kGBBRRG
  523. kRRGGBB
  524. kRRGGBB
  525. */
  526.  
  527. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  528.  
  529. if(shadow_y < 2)
  530. {
  531. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  532. }
  533. else
  534. {
  535. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  536. }
  537.  
  538. #undef kGRRBBG
  539. #undef kBBGGRR
  540.  
  541. #undef kBRRGGB
  542. #undef kGGBBRR
  543.  
  544. #undef kGBBRRG
  545. #undef kRRGGBB
  546.  
  547. break;
  548. }
  549. case k600TVL:
  550. {
  551. #define kMG (kMagenta << 0) | (kGreen << 6)
  552. #define kGM (kGreen << 0) | (kMagenta << 6)
  553.  
  554. #define kYB (kYellow << 0) | (kBlue << 6)
  555. #define kBY (kBlue << 0) | (kYellow << 6)
  556.  
  557. /*
  558. kMG
  559. kGM
  560.  
  561. kYB
  562. kBY
  563.  
  564. kGM
  565. kMG
  566. */
  567.  
  568. const uint rgb_mask[kBGRAxis * 2] = { kMG, kGM, kYB, kBY, kGM, kMG };
  569.  
  570. if(shadow_y < 1)
  571. {
  572. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 6)) & 0x3F;
  573. }
  574. else
  575. {
  576. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 6)) & 0x3F;
  577. }
  578.  
  579. #undef kMG
  580. #undef kGM
  581.  
  582. #undef kYB
  583. #undef kBY
  584.  
  585. break;
  586. }
  587. case k800TVL:
  588. {
  589. colour_mask = kWhite;
  590.  
  591. break;
  592. }
  593. case k1000TVL:
  594. {
  595. colour_mask = kWhite;
  596.  
  597. break;
  598. }
  599. default:
  600. {
  601. break;
  602. }
  603. }
  604.  
  605. break;
  606. }
  607. case k4K:
  608. {
  609. switch(crt_resolution)
  610. {
  611. case k300TVL:
  612. {
  613. #define kMaxShadowMaskSizeX 12
  614. #define kMaxShadowMaskSizeY 8
  615.  
  616. #define kGGRRRRBBBBGG kGreen, kGreen, kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen
  617. #define kBBBBGGGGRRRR kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed
  618.  
  619. #define kBBRRRRGGGGBB kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue
  620. #define kGGGGBBBBRRRR kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed
  621.  
  622. #define kGGBBBBRRRRGG kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen
  623. #define kRRRRGGGGBBBB kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue
  624.  
  625. /*
  626. kGGRRRRBBBBGG
  627. kGGRRRRBBBBGG
  628. kGGRRRRBBBBGG
  629. kGGRRRRBBBBGG
  630. kBBBBGGGGRRRR
  631. kBBBBGGGGRRRR
  632. kBBBBGGGGRRRR
  633. kBBBBGGGGRRRR
  634.  
  635. kBBRRRRGGGGBB
  636. kBBRRRRGGGGBB
  637. kBBRRRRGGGGBB
  638. kBBRRRRGGGGBB
  639. kGGGGBBBBRRRR
  640. kGGGGBBBBRRRR
  641. kGGGGBBBBRRRR
  642. kGGGGBBBBRRRR
  643.  
  644. kGGBBBBRRRRGG
  645. kGGBBBBRRRRGG
  646. kGGBBBBRRRRGG
  647. kGGBBBBRRRRGG
  648. kRRRRGGGGBBBB
  649. kRRRRGGGGBBBB
  650. kRRRRGGGGBBBB
  651. kRRRRGGGGBBBB
  652. */
  653.  
  654. if(shadow_y < 4)
  655. {
  656. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kGGRRRRBBBBGG, kBBRRRRGGGGBB, kGGBBBBRRRRGG };
  657. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  658. }
  659. else
  660. {
  661. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kBBBBGGGGRRRR, kGGGGBBBBRRRR, kRRRRGGGGBBBB };
  662. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  663. }
  664.  
  665. #undef kMaxShadowMaskSizeX
  666. #undef kMaxShadowMaskSizeY
  667.  
  668. #undef kGGRRRRBBBBGG
  669. #undef kBBBBGGGGRRRR
  670.  
  671. #undef kBBRRRRGGGGBB
  672. #undef kGGGGBBBBRRRR
  673.  
  674. #undef kGGBBBBRRRRGG
  675. #undef kRRRRGGGGBBBB
  676.  
  677. break;
  678. }
  679. case k600TVL:
  680. {
  681. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  682. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  683.  
  684. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  685. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  686.  
  687. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  688. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  689.  
  690. /*
  691. kGRRBBG
  692. kGRRBBG
  693. kBBGGRR
  694. kBBGGRR
  695.  
  696. kBRRGGB
  697. kBRRGGB
  698. kGGBBRR
  699. kGGBBRR
  700.  
  701. kGBBRRG
  702. kGBBRRG
  703. kRRGGBB
  704. kRRGGBB
  705. */
  706.  
  707. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  708.  
  709. if(shadow_y < 2)
  710. {
  711. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  712. }
  713. else
  714. {
  715. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  716. }
  717.  
  718. #undef kGRRBBG
  719. #undef kBBGGRR
  720.  
  721. #undef kBRRGGB
  722. #undef kGGBBRR
  723.  
  724. #undef kGBBRRG
  725. #undef kRRGGBB
  726.  
  727. break;
  728. }
  729. case k800TVL:
  730. {
  731. #define kMG (kMagenta << 0) | (kGreen << 6)
  732. #define kGM (kGreen << 0) | (kMagenta << 6)
  733.  
  734. #define kYB (kYellow << 0) | (kBlue << 6)
  735. #define kBY (kBlue << 0) | (kYellow << 6)
  736.  
  737. /*
  738. kMG
  739. kGM
  740.  
  741. kYB
  742. kBY
  743.  
  744. kGM
  745. kMG
  746. */
  747.  
  748. const uint rgb_mask[kBGRAxis * 2] = { kMG, kGM, kYB, kBY, kGM, kMG };
  749.  
  750. if(shadow_y < 1)
  751. {
  752. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 6)) & 0x3F;
  753. }
  754. else
  755. {
  756. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 6)) & 0x3F;
  757. }
  758.  
  759. #undef kMG
  760. #undef kGM
  761.  
  762. #undef kYB
  763. #undef kBY
  764.  
  765. break;
  766. }
  767. case k1000TVL:
  768. {
  769. #define kMG (kMagenta << 0) | (kGreen << 6)
  770. #define kGM (kGreen << 0) | (kMagenta << 6)
  771.  
  772. #define kYB (kYellow << 0) | (kBlue << 6)
  773. #define kBY (kBlue << 0) | (kYellow << 6)
  774.  
  775. /*
  776. kMG
  777. kGM
  778.  
  779. kYB
  780. kBY
  781.  
  782. kGM
  783. kMG
  784. */
  785.  
  786. const uint rgb_mask[kBGRAxis * 2] = { kMG, kGM, kYB, kBY, kGM, kMG };
  787.  
  788. if(shadow_y < 1)
  789. {
  790. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 6)) & 0x3F;
  791. }
  792. else
  793. {
  794. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 6)) & 0x3F;
  795. }
  796.  
  797. #undef kMG
  798. #undef kGM
  799.  
  800. #undef kYB
  801. #undef kBY
  802.  
  803. break;
  804. }
  805. default:
  806. {
  807. break;
  808. }
  809. }
  810.  
  811. break;
  812. }
  813. case k8K:
  814. {
  815. switch(crt_resolution)
  816. {
  817. case k300TVL:
  818. {
  819. #define kMaxShadowMaskSizeX 12
  820. #define kMaxShadowMaskSizeY 8
  821.  
  822. #define kGGRRRRBBBBGG kGreen, kGreen, kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen
  823. #define kBBBBGGGGRRRR kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed
  824.  
  825. #define kBBRRRRGGGGBB kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue
  826. #define kGGGGBBBBRRRR kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed
  827.  
  828. #define kGGBBBBRRRRGG kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen
  829. #define kRRRRGGGGBBBB kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue
  830.  
  831. /*
  832. kGGRRRRBBBBGG
  833. kGGRRRRBBBBGG
  834. kGGRRRRBBBBGG
  835. kGGRRRRBBBBGG
  836. kBBBBGGGGRRRR
  837. kBBBBGGGGRRRR
  838. kBBBBGGGGRRRR
  839. kBBBBGGGGRRRR
  840.  
  841. kBBRRRRGGGGBB
  842. kBBRRRRGGGGBB
  843. kBBRRRRGGGGBB
  844. kBBRRRRGGGGBB
  845. kGGGGBBBBRRRR
  846. kGGGGBBBBRRRR
  847. kGGGGBBBBRRRR
  848. kGGGGBBBBRRRR
  849.  
  850. kGGBBBBRRRRGG
  851. kGGBBBBRRRRGG
  852. kGGBBBBRRRRGG
  853. kGGBBBBRRRRGG
  854. kRRRRGGGGBBBB
  855. kRRRRGGGGBBBB
  856. kRRRRGGGGBBBB
  857. kRRRRGGGGBBBB
  858. */
  859.  
  860. if(shadow_y < 4)
  861. {
  862. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kGGRRRRBBBBGG, kBBRRRRGGGGBB, kGGBBBBRRRRGG };
  863. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  864. }
  865. else
  866. {
  867. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kBBBBGGGGRRRR, kGGGGBBBBRRRR, kRRRRGGGGBBBB };
  868. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  869. }
  870.  
  871. #undef kMaxShadowMaskSizeX
  872. #undef kMaxShadowMaskSizeY
  873.  
  874. #undef kGGRRRRBBBBGG
  875. #undef kBBBBGGGGRRRR
  876.  
  877. #undef kBBRRRRGGGGBB
  878. #undef kGGGGBBBBRRRR
  879.  
  880. #undef kGGBBBBRRRRGG
  881. #undef kRRRRGGGGBBBB
  882.  
  883. break;
  884. }
  885. case k600TVL:
  886. {
  887. #define kMaxShadowMaskSizeX 12
  888. #define kMaxShadowMaskSizeY 8
  889.  
  890. #define kGGRRRRBBBBGG kGreen, kGreen, kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen
  891. #define kBBBBGGGGRRRR kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed
  892.  
  893. #define kBBRRRRGGGGBB kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue
  894. #define kGGGGBBBBRRRR kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed
  895.  
  896. #define kGGBBBBRRRRGG kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen
  897. #define kRRRRGGGGBBBB kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue
  898.  
  899. /*
  900. kGGRRRRBBBBGG
  901. kGGRRRRBBBBGG
  902. kGGRRRRBBBBGG
  903. kGGRRRRBBBBGG
  904. kBBBBGGGGRRRR
  905. kBBBBGGGGRRRR
  906. kBBBBGGGGRRRR
  907. kBBBBGGGGRRRR
  908.  
  909. kBBRRRRGGGGBB
  910. kBBRRRRGGGGBB
  911. kBBRRRRGGGGBB
  912. kBBRRRRGGGGBB
  913. kGGGGBBBBRRRR
  914. kGGGGBBBBRRRR
  915. kGGGGBBBBRRRR
  916. kGGGGBBBBRRRR
  917.  
  918. kGGBBBBRRRRGG
  919. kGGBBBBRRRRGG
  920. kGGBBBBRRRRGG
  921. kGGBBBBRRRRGG
  922. kRRRRGGGGBBBB
  923. kRRRRGGGGBBBB
  924. kRRRRGGGGBBBB
  925. kRRRRGGGGBBBB
  926. */
  927.  
  928. if(shadow_y < 4)
  929. {
  930. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kGGRRRRBBBBGG, kBBRRRRGGGGBB, kGGBBBBRRRRGG };
  931. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  932. }
  933. else
  934. {
  935. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kBBBBGGGGRRRR, kGGGGBBBBRRRR, kRRRRGGGGBBBB };
  936. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  937. }
  938.  
  939. #undef kMaxShadowMaskSizeX
  940. #undef kMaxShadowMaskSizeY
  941.  
  942. #undef kGGRRRRBBBBGG
  943. #undef kBBBBGGGGRRRR
  944.  
  945. #undef kBBRRRRGGGGBB
  946. #undef kGGGGBBBBRRRR
  947.  
  948. #undef kGGBBBBRRRRGG
  949. #undef kRRRRGGGGBBBB
  950.  
  951. break;
  952. }
  953. case k800TVL:
  954. {
  955. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  956. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  957.  
  958. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  959. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  960.  
  961. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  962. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  963.  
  964. /*
  965. kGRRBBG
  966. kGRRBBG
  967. kBBGGRR
  968. kBBGGRR
  969.  
  970. kBRRGGB
  971. kBRRGGB
  972. kGGBBRR
  973. kGGBBRR
  974.  
  975. kGBBRRG
  976. kGBBRRG
  977. kRRGGBB
  978. kRRGGBB
  979. */
  980.  
  981. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  982.  
  983. if(shadow_y < 2)
  984. {
  985. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  986. }
  987. else
  988. {
  989. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  990. }
  991.  
  992. #undef kGRRBBG
  993. #undef kBBGGRR
  994.  
  995. #undef kBRRGGB
  996. #undef kGGBBRR
  997.  
  998. #undef kGBBRRG
  999. #undef kRRGGBB
  1000.  
  1001. break;
  1002. }
  1003. case k1000TVL:
  1004. {
  1005. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  1006. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  1007.  
  1008. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  1009. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  1010.  
  1011. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  1012. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  1013.  
  1014. /*
  1015. kGRRBBG
  1016. kGRRBBG
  1017. kBBGGRR
  1018. kBBGGRR
  1019.  
  1020. kBRRGGB
  1021. kBRRGGB
  1022. kGGBBRR
  1023. kGGBBRR
  1024.  
  1025. kGBBRRG
  1026. kGBBRRG
  1027. kRRGGBB
  1028. kRRGGBB
  1029. */
  1030.  
  1031. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  1032.  
  1033. if(shadow_y < 2)
  1034. {
  1035. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  1036. }
  1037. else
  1038. {
  1039. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  1040. }
  1041.  
  1042. #undef kGRRBBG
  1043. #undef kBBGGRR
  1044.  
  1045. #undef kBRRGGB
  1046. #undef kGGBBRR
  1047.  
  1048. #undef kGBBRRG
  1049. #undef kRRGGBB
  1050.  
  1051. break;
  1052. }
  1053. default:
  1054. {
  1055. break;
  1056. }
  1057. }
  1058.  
  1059. break;
  1060. }
  1061. default:
  1062. {
  1063. break;
  1064. }
  1065. }
  1066.  
  1067. break;
  1068. }
  1069. case kSlotMask:
  1070. {
  1071. #define kMaxSlotSizeX 2
  1072.  
  1073. uint slot_x = uint(floor(mod(current_position.x / kSlotMaskSizeX[(lcd_resolution * kTVLAxis) + crt_resolution], kMaxSlotSizeX)));
  1074. uint slot_y = uint(floor(mod(current_position.y, kSlotMaskSizeY[(lcd_resolution * kTVLAxis) + crt_resolution])));
  1075.  
  1076. uint element = (slot_y * kMaxSlotSizeX) + slot_x;
  1077.  
  1078. uint mask = uint(floor(mod(current_position.x, kSlotMaskSizeX[(lcd_resolution * kTVLAxis) + crt_resolution])));
  1079.  
  1080. switch(lcd_resolution)
  1081. {
  1082. case k1080p:
  1083. {
  1084. switch(crt_resolution)
  1085. {
  1086. case k300TVL:
  1087. {
  1088. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  1089. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  1090. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  1091.  
  1092. /*
  1093. kRGBX, kRGBX
  1094. kRGBX, kXXXX
  1095. kRGBX, kRGBX
  1096. kXXXX, kRGBX
  1097.  
  1098. kRBGX, kRBGX
  1099. kRBGX, kXXXX
  1100. kRBGX, kRBGX
  1101. kXXXX, kRBGX
  1102.  
  1103. kBGRX, kBGRX
  1104. kBGRX, kXXXX
  1105. kBGRX, kBGRX
  1106. kXXXX, kBGRX
  1107. */
  1108.  
  1109. if((element == 3) || (element == 6))
  1110. {
  1111. colour_mask = kBlack;
  1112. }
  1113. else
  1114. {
  1115. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  1116. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1117. }
  1118.  
  1119. #undef kRGBX
  1120. #undef kRBGX
  1121. #undef kBGRX
  1122.  
  1123. break;
  1124. }
  1125. case k600TVL:
  1126. {
  1127. #define kMG (kMagenta << 0) | (kGreen << 6)
  1128. #define kYB (kYellow << 0) | (kBlue << 6)
  1129. #define kGM (kGreen << 0) | (kMagenta << 6)
  1130.  
  1131. /*
  1132. kMG, kMG
  1133. kMG, kXX
  1134. kMG, kMG
  1135. kXX, kMG
  1136.  
  1137. kYB, kYB
  1138. kYB, kXX
  1139. kYB, kYB
  1140. kXX, kYB
  1141.  
  1142. kGM, kGM
  1143. kGM, kXX
  1144. kGM, kGM
  1145. kXX, kGM
  1146. */
  1147.  
  1148. if((element == 3) || (element == 6))
  1149. {
  1150. colour_mask = kBlack;
  1151. }
  1152. else
  1153. {
  1154. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  1155. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  1156. }
  1157.  
  1158. #undef kMG
  1159. #undef kYB
  1160. #undef kGM
  1161.  
  1162. break;
  1163. }
  1164. case k800TVL:
  1165. {
  1166. #define kMaxSlotMaskSize 1
  1167. #define kMaxSlotSizeY 4
  1168.  
  1169. #define kX kBlack
  1170. #define kW kWhite
  1171.  
  1172. /*
  1173. kW, kW
  1174. kW, kX
  1175. kW, kW
  1176. kX, kW
  1177. */
  1178.  
  1179. if((element == 3) || (element == 6))
  1180. {
  1181. colour_mask = kBlack;
  1182. }
  1183. else
  1184. {
  1185. colour_mask = kWhite;
  1186. }
  1187.  
  1188. #undef kMaxSlotMaskSize
  1189. #undef kMaxSlotSizeY
  1190.  
  1191. #undef kX
  1192. #undef kW
  1193.  
  1194. break;
  1195. }
  1196. case k1000TVL:
  1197. {
  1198. #define kMaxSlotMaskSize 1
  1199. #define kMaxSlotSizeY 4
  1200.  
  1201. #define kX kBlack
  1202. #define kW kWhite
  1203.  
  1204. /*
  1205. kW, kW
  1206. kW, kX
  1207. kW, kW
  1208. kX, kW
  1209. */
  1210.  
  1211. if((element == 3) || (element == 6))
  1212. {
  1213. colour_mask = kBlack;
  1214. }
  1215. else
  1216. {
  1217. colour_mask = kWhite;
  1218. }
  1219.  
  1220. #undef kMaxSlotMaskSize
  1221. #undef kMaxSlotSizeY
  1222.  
  1223. #undef kX
  1224. #undef kW
  1225.  
  1226. break;
  1227. }
  1228. default:
  1229. {
  1230. break;
  1231. }
  1232. }
  1233.  
  1234. break;
  1235. }
  1236. case k4K:
  1237. {
  1238. switch(crt_resolution)
  1239. {
  1240. case k300TVL:
  1241. {
  1242. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  1243. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  1244. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  1245.  
  1246. /*
  1247. kRRGGBBX, kRRGGBBX
  1248. kRRGGBBX, kRRGGBBX
  1249. kRRGGBBX, kRRGGBBX
  1250. kRRGGBBX, kXXXXXXX
  1251. kRRGGBBX, kRRGGBBX
  1252. kRRGGBBX, kRRGGBBX
  1253. kRRGGBBX, kRRGGBBX
  1254. kXXXXXXX, kRRGGBBX
  1255.  
  1256. kRRBBGGX, kRRBBGGX
  1257. kRRBBGGX, kRRBBGGX
  1258. kRRBBGGX, kRRBBGGX
  1259. kRRBBGGX, kXXXXXXX
  1260. kRRBBGGX, kRRBBGGX
  1261. kRRBBGGX, kRRBBGGX
  1262. kRRBBGGX, kRRBBGGX
  1263. kXXXXXXX, kRRBBGGX
  1264.  
  1265. kBBGGRRX, kBBGGRRX
  1266. kBBGGRRX, kBBGGRRX
  1267. kBBGGRRX, kBBGGRRX
  1268. kBBGGRRX, kXXXXXXX
  1269. kBBGGRRX, kBBGGRRX
  1270. kBBGGRRX, kBBGGRRX
  1271. kBBGGRRX, kBBGGRRX
  1272. kXXXXXXX, kBBGGRRX
  1273. */
  1274.  
  1275. if((element == 7) || (element == 14))
  1276. {
  1277. colour_mask = kBlack;
  1278. }
  1279. else
  1280. {
  1281. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  1282. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1283. }
  1284.  
  1285. #undef kRRGGBBX
  1286. #undef kRRBBGGX
  1287. #undef kBBGGRRX
  1288.  
  1289. break;
  1290. }
  1291. case k600TVL:
  1292. {
  1293. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  1294. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  1295. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  1296.  
  1297. /*
  1298. kRGBX, kRGBX
  1299. kRGBX, kXXXX
  1300. kRGBX, kRGBX
  1301. kXXXX, kRGBX
  1302.  
  1303. kRBGX, kRBGX
  1304. kRBGX, kXXXX
  1305. kRBGX, kRBGX
  1306. kXXXX, kRBGX
  1307.  
  1308. kBGRX, kBGRX
  1309. kBGRX, kXXXX
  1310. kBGRX, kBGRX
  1311. kXXXX, kBGRX
  1312. */
  1313.  
  1314. if((element == 5) || (element == 10))
  1315. {
  1316. colour_mask = kBlack;
  1317. }
  1318. else
  1319. {
  1320. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  1321. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1322. }
  1323.  
  1324. #undef kRGBX
  1325. #undef kRBGX
  1326. #undef kBGRX
  1327.  
  1328. break;
  1329. }
  1330. case k800TVL:
  1331. {
  1332. #define kBGR (kBlue << 0) | (kGreen << 4) | (kRed << 8)
  1333. #define kGBR (kGreen << 0) | (kBlue << 4) | (kRed << 8)
  1334. #define kRGB (kRed << 0) | (kGreen << 4) | (kBlue << 8)
  1335.  
  1336. /*
  1337. kBGR, kBGR
  1338. kBGR, kXXX
  1339. kBGR, kBGR
  1340. kXXX, kBGR
  1341.  
  1342. kGBR, kGBR
  1343. kGBR, kXXX
  1344. kGBR, kGBR
  1345. kXXX, kGBR
  1346.  
  1347. kRGB, kRGB
  1348. kRGB, kXXX
  1349. kRGB, kRGB
  1350. kXXX, kRGB
  1351. */
  1352.  
  1353. if((element == 3) || (element == 6))
  1354. {
  1355. colour_mask = kBlack;
  1356. }
  1357. else
  1358. {
  1359. const uint rgb_mask[kBGRAxis] = { kBGR, kGBR, kRGB };
  1360. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1361. }
  1362.  
  1363. #undef kBGR
  1364. #undef kGBR
  1365. #undef kRGB
  1366.  
  1367. break;
  1368. }
  1369. case k1000TVL:
  1370. {
  1371. #define kMG (kMagenta << 0) | (kGreen << 6)
  1372. #define kYB (kYellow << 0) | (kBlue << 6)
  1373. #define kGM (kGreen << 0) | (kMagenta << 6)
  1374.  
  1375. /*
  1376. kMG, kMG
  1377. kMG, kXX
  1378. kMG, kMG
  1379. kXX, kMG
  1380.  
  1381. kYB, kYB
  1382. kYB, kXX
  1383. kYB, kYB
  1384. kXX, kYB
  1385.  
  1386. kGM, kGM
  1387. kGM, kXX
  1388. kGM, kGM
  1389. kXX, kGM
  1390. */
  1391.  
  1392. if((element == 3) || (element == 6))
  1393. {
  1394. colour_mask = kBlack;
  1395. }
  1396. else
  1397. {
  1398. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  1399. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  1400. }
  1401.  
  1402. #undef kMG
  1403. #undef kYB
  1404. #undef kGM
  1405.  
  1406. break;
  1407. }
  1408. default:
  1409. {
  1410. break;
  1411. }
  1412. }
  1413.  
  1414. break;
  1415. }
  1416. case k8K:
  1417. {
  1418. switch(crt_resolution)
  1419. {
  1420. case k300TVL:
  1421. {
  1422. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  1423. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  1424. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  1425.  
  1426. /*
  1427. kRRGGBBX, kRRGGBBX
  1428. kRRGGBBX, kRRGGBBX
  1429. kRRGGBBX, kXXXXXXX
  1430. kRRGGBBX, kRRGGBBX
  1431. kRRGGBBX, kRRGGBBX
  1432. kXXXXXXX, kRRGGBBX
  1433.  
  1434. kRRBBGGX, kRRBBGGX
  1435. kRRBBGGX, kRRBBGGX
  1436. kRRBBGGX, kXXXXXXX
  1437. kRRBBGGX, kRRBBGGX
  1438. kRRBBGGX, kRRBBGGX
  1439. kXXXXXXX, kRRBBGGX
  1440.  
  1441. kBBGGRRX, kBBGGRRX
  1442. kBBGGRRX, kBBGGRRX
  1443. kBBGGRRX, kXXXXXXX
  1444. kBBGGRRX, kBBGGRRX
  1445. kBBGGRRX, kBBGGRRX
  1446. kXXXXXXX, kBBGGRRX
  1447. */
  1448.  
  1449. if((element == 5) || (element == 10))
  1450. {
  1451. colour_mask = kBlack;
  1452. }
  1453. else
  1454. {
  1455. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  1456. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1457. }
  1458.  
  1459. #undef kRRGGBBX
  1460. #undef kRRBBGGX
  1461. #undef kBBGGRRX
  1462.  
  1463. break;
  1464. }
  1465. case k600TVL:
  1466. {
  1467. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  1468. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  1469. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  1470.  
  1471. /*
  1472. kRRGGBBX, kRRGGBBX
  1473. kRRGGBBX, kRRGGBBX
  1474. kRRGGBBX, kXXXXXXX
  1475. kRRGGBBX, kRRGGBBX
  1476. kRRGGBBX, kRRGGBBX
  1477. kXXXXXXX, kRRGGBBX
  1478.  
  1479. kRRBBGGX, kRRBBGGX
  1480. kRRBBGGX, kRRBBGGX
  1481. kRRBBGGX, kXXXXXXX
  1482. kRRBBGGX, kRRBBGGX
  1483. kRRBBGGX, kRRBBGGX
  1484. kXXXXXXX, kRRBBGGX
  1485.  
  1486. kBBGGRRX, kBBGGRRX
  1487. kBBGGRRX, kBBGGRRX
  1488. kBBGGRRX, kXXXXXXX
  1489. kBBGGRRX, kBBGGRRX
  1490. kBBGGRRX, kBBGGRRX
  1491. kXXXXXXX, kBBGGRRX
  1492. */
  1493.  
  1494. if((element == 5) || (element == 10))
  1495. {
  1496. colour_mask = kBlack;
  1497. }
  1498. else
  1499. {
  1500. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  1501. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1502. }
  1503.  
  1504. #undef kMaxSlotMaskSize
  1505. #undef kMaxSlotSizeY
  1506.  
  1507. #undef kRRGGBBX
  1508. #undef kRRBBGGX
  1509. #undef kBBGGRRX
  1510.  
  1511. break;
  1512. }
  1513. case k800TVL:
  1514. {
  1515. #define kRYCBX (kRed << 0) | (kYellow << 6) | (kCyan << 12) | (kBlue << 18) | (kBlack << 24)
  1516. #define kRMCGX (kRed << 0) | (kMagenta << 6) | (kCyan << 12) | (kGreen << 18) | (kBlack << 24)
  1517. #define kBCYRX (kBlue << 0) | (kCyan << 6) | (kYellow << 12) | (kRed << 18) | (kBlack << 24)
  1518.  
  1519. /*
  1520. kRYCBX, kRYCBX
  1521. kRYCBX, kXXXXX
  1522. kRYCBX, kRYCBX
  1523. kXXXXX, kRYCBX
  1524.  
  1525. kRMCGX, kRMCGX
  1526. kRMCGX, kXXXXX
  1527. kRMCGX, kRMCGX
  1528. kXXXXX, kRMCGX
  1529.  
  1530. kBCYRX, kBCYRX
  1531. kBCYRX, kXXXXX
  1532. kBCYRX, kBCYRX
  1533. kXXXXX, kBCYRX
  1534. */
  1535.  
  1536. if((element == 3) || (element == 6))
  1537. {
  1538. colour_mask = kBlack;
  1539. }
  1540. else
  1541. {
  1542. const uint rgb_mask[kBGRAxis] = { kRYCBX, kRMCGX, kBCYRX };
  1543. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  1544. }
  1545.  
  1546. #undef kRYCBX
  1547. #undef kRMCGX
  1548. #undef kBCYRX
  1549.  
  1550. break;
  1551. }
  1552. case k1000TVL:
  1553. {
  1554. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  1555. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  1556. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  1557.  
  1558. /*
  1559. kRGBX, kRGBX
  1560. kRGBX, kXXXX
  1561. kRGBX, kRGBX
  1562. kXXXX, kRGBX
  1563.  
  1564. kRBGX, kRBGX
  1565. kRBGX, kXXXX
  1566. kRBGX, kRBGX
  1567. kXXXX, kRBGX
  1568.  
  1569. kBGRX, kBGRX
  1570. kBGRX, kXXXX
  1571. kBGRX, kBGRX
  1572. kXXXX, kBGRX
  1573. */
  1574.  
  1575. if((element == 5) || (element == 10))
  1576. {
  1577. colour_mask = kBlack;
  1578. }
  1579. else
  1580. {
  1581. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  1582. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1583. }
  1584.  
  1585. #undef kRGBX
  1586. #undef kRBGX
  1587. #undef kBGRX
  1588.  
  1589. break;
  1590. }
  1591. default:
  1592. {
  1593. break;
  1594. }
  1595. }
  1596.  
  1597. break;
  1598. }
  1599. default:
  1600. {
  1601. break;
  1602. }
  1603. }
  1604.  
  1605. break;
  1606. }
  1607. default:
  1608. {
  1609. break;
  1610. }
  1611. }
  1612.  
  1613. const float scanline_size = output_size.y / source_size.y;
  1614.  
  1615. const vec3 horizontal_convergence = vec3(HCRT_RED_HORIZONTAL_CONVERGENCE, HCRT_GREEN_HORIZONTAL_CONVERGENCE, HCRT_BLUE_HORIZONTAL_CONVERGENCE);
  1616. const vec3 vertical_convergence = vec3(HCRT_RED_VERTICAL_CONVERGENCE, HCRT_GREEN_VERTICAL_CONVERGENCE, HCRT_BLUE_VERTICAL_CONVERGENCE);
  1617. const vec3 beam_sharpness = vec3(HCRT_RED_BEAM_SHARPNESS, HCRT_GREEN_BEAM_SHARPNESS, HCRT_BLUE_BEAM_SHARPNESS);
  1618. const vec3 beam_attack = vec3(HCRT_RED_BEAM_ATTACK, HCRT_GREEN_BEAM_ATTACK, HCRT_BLUE_BEAM_ATTACK);
  1619. const vec3 scanline_min = vec3(HCRT_RED_SCANLINE_MIN, HCRT_GREEN_SCANLINE_MIN, HCRT_BLUE_SCANLINE_MIN);
  1620. const vec3 scanline_max = vec3(HCRT_RED_SCANLINE_MAX, HCRT_GREEN_SCANLINE_MAX, HCRT_BLUE_SCANLINE_MAX);
  1621. const vec3 scanline_attack = vec3(HCRT_RED_SCANLINE_ATTACK, HCRT_GREEN_SCANLINE_ATTACK, HCRT_BLUE_SCANLINE_ATTACK);
  1622.  
  1623. const uint channel_count = colour_mask & 3;
  1624.  
  1625. vec3 scanline_colour = vec3(0.0f);
  1626.  
  1627. float offset_x = noise(sin(gl_FragCoord.xy) * float(mod(global.FrameCount, 361.)));
  1628. float offset_y = noise(cos(gl_FragCoord.yx) * float(mod(global.FrameCount, 873.)));
  1629.  
  1630. tex_coord = tex_coord + vec2(offset_x, offset_y) * 0.0005;
  1631.  
  1632. if(channel_count > 0)
  1633. {
  1634. const uint channel_0 = (colour_mask >> kFirstChannelShift) & 3;
  1635.  
  1636. const float scanline_channel_0 = GenerateScanline( channel_0,
  1637. tex_coord,
  1638. source_size.xy,
  1639. scanline_size,
  1640. horizontal_convergence[channel_0],
  1641. vertical_convergence[channel_0],
  1642. beam_sharpness[channel_0],
  1643. beam_attack[channel_0],
  1644. scanline_min[channel_0],
  1645. scanline_max[channel_0],
  1646. scanline_attack[channel_0]);
  1647.  
  1648. scanline_colour = scanline_channel_0 * kColourMask[channel_0];
  1649. }
  1650.  
  1651. if(channel_count > 1)
  1652. {
  1653. const uint channel_1 = (colour_mask >> kSecondChannelShift) & 3;
  1654.  
  1655. const float scanline_channel_1 = GenerateScanline(channel_1,
  1656. tex_coord,
  1657. source_size.xy,
  1658. scanline_size,
  1659. horizontal_convergence[channel_1],
  1660. vertical_convergence[channel_1],
  1661. beam_sharpness[channel_1],
  1662. beam_attack[channel_1],
  1663. scanline_min[channel_1],
  1664. scanline_max[channel_1],
  1665. scanline_attack[channel_1]);
  1666.  
  1667. scanline_colour += scanline_channel_1 * kColourMask[channel_1];
  1668. }
  1669.  
  1670. if(channel_count > 2)
  1671. {
  1672. const uint channel_2 = (colour_mask >> kThirdChannelShift) & 3;
  1673.  
  1674. const float scanline_channel_2 = GenerateScanline(channel_2,
  1675. tex_coord,
  1676. source_size.xy,
  1677. scanline_size,
  1678. horizontal_convergence[channel_2],
  1679. vertical_convergence[channel_2],
  1680. beam_sharpness[channel_2],
  1681. beam_attack[channel_2],
  1682. scanline_min[channel_2],
  1683. scanline_max[channel_2],
  1684. scanline_attack[channel_2]);
  1685.  
  1686. scanline_colour += scanline_channel_2 * kColourMask[channel_2];
  1687. }
  1688.  
  1689. vec3 transformed_colour;
  1690.  
  1691. if(HCRT_COLOUR_ACCURATE >= 1.0f)
  1692. {
  1693. if(HCRT_HDR >= 1.0f)
  1694. {
  1695. const vec3 rec2020 = scanline_colour * k2020Gamuts[uint(HCRT_EXPAND_GAMUT)];
  1696. transformed_colour = rec2020 * (HCRT_PAPER_WHITE_NITS / kMaxNitsFor2084);
  1697. }
  1698. else if(HCRT_OUTPUT_COLOUR_SPACE == 2.0f)
  1699. {
  1700. transformed_colour = (scanline_colour * k709_to_XYZ) * kXYZ_to_DCIP3;
  1701. }
  1702. else
  1703. {
  1704. transformed_colour = scanline_colour;
  1705. }
  1706. }
  1707. else
  1708. {
  1709. transformed_colour = scanline_colour;
  1710. }
  1711.  
  1712. vec3 gamma_corrected;
  1713.  
  1714. GammaCorrect(transformed_colour, gamma_corrected);
  1715.  
  1716. FragColor = vec4(gamma_corrected, 1.0f);
  1717. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!