API tools faq
paste
Guest User

crt-sony-megatron.slang

a guest
Dec 25th, 2025
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 69.73 KB | Software | 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. void main()
  230. {
  231. const uint screen_type = uint(HCRT_CRT_SCREEN_TYPE);
  232. const uint crt_resolution = uint(HCRT_CRT_RESOLUTION);
  233. const uint lcd_resolution = uint(HCRT_LCD_RESOLUTION);
  234. const uint lcd_subpixel_layout = uint(HCRT_LCD_SUBPIXEL);
  235. const vec2 source_size = global.SourceSize.xy;
  236. const vec2 output_size = global.OutputSize.xy;
  237.  
  238. vec2 tex_coord = vTexCoord - vec2(0.5f);
  239. tex_coord = tex_coord * vec2(1.0f + (HCRT_PIN_PHASE * tex_coord.y), 1.0f);
  240. tex_coord = tex_coord * vec2(HCRT_H_SIZE, HCRT_V_SIZE);
  241. tex_coord = tex_coord + vec2(0.5f);
  242. tex_coord = tex_coord + (vec2(HCRT_H_CENT, HCRT_V_CENT) / output_size);
  243.  
  244. const vec2 current_position = vTexCoord * output_size;
  245.  
  246. uint colour_mask = 0;
  247.  
  248. switch(screen_type)
  249. {
  250. case kApertureGrille:
  251. {
  252. uint mask = uint(floor(mod(current_position.x, kApertureGrilleMaskSize[(lcd_resolution * kTVLAxis) + crt_resolution])));
  253.  
  254. switch(lcd_resolution)
  255. {
  256. case k1080p:
  257. {
  258. switch(crt_resolution)
  259. {
  260. case k300TVL:
  261. {
  262. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  263. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  264. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  265.  
  266. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  267. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  268.  
  269. #undef kRGBX
  270. #undef kRBGX
  271. #undef kBGRX
  272.  
  273. break;
  274. }
  275. case k600TVL:
  276. {
  277. #define kMG (kMagenta << 0) | (kGreen << 6)
  278. #define kYB (kYellow << 0) | (kBlue << 6)
  279. #define kGM (kGreen << 0) | (kMagenta << 6)
  280.  
  281. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  282. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  283.  
  284. #undef kMG
  285. #undef kYB
  286. #undef kGM
  287.  
  288. break;
  289. }
  290. case k800TVL:
  291. {
  292. colour_mask = kWhite;
  293.  
  294. break;
  295. }
  296. case k1000TVL:
  297. {
  298. colour_mask = kWhite;
  299.  
  300. break;
  301. }
  302. default:
  303. {
  304. break;
  305. }
  306. }
  307.  
  308. break;
  309. }
  310. case k4K:
  311. {
  312. switch(crt_resolution)
  313. {
  314. case k300TVL:
  315. {
  316. #define kXRRGGBB (kBlack << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20) | (kBlue << 24)
  317. #define kXRRBBGG (kBlack << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20) | (kGreen << 24)
  318. #define kXBBGGRR (kBlack << 0) | (kBlue << 4) | (kBlue << 8) | (kGreen << 12) | (kGreen << 16) | (kRed << 20) | (kRed << 24)
  319.  
  320. const uint rgb_mask[kBGRAxis] = { kXRRGGBB, kXRRBBGG, kXBBGGRR };
  321. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  322.  
  323. #undef kXRRGGBB
  324. #undef kXRRBBGG
  325. #undef kXBBGGRR
  326.  
  327. break;
  328. }
  329. case k600TVL:
  330. {
  331. #define kXRGB (kBlack << 0) | (kRed << 4) | (kGreen << 8) | (kBlue << 12)
  332. #define kXRBG (kBlack << 0) | (kRed << 4) | (kBlue << 8) | (kGreen << 12)
  333. #define kXBGR (kBlack << 0) | (kBlue << 4) | (kGreen << 8) | (kRed << 12)
  334.  
  335. const uint rgb_mask[kBGRAxis] = { kXRGB, kXRBG, kXBGR };
  336. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  337.  
  338. #undef kXRGB
  339. #undef kXRBG
  340. #undef kXBGR
  341.  
  342. break;
  343. }
  344. case k800TVL:
  345. {
  346. #define kBGR (kBlue << 0) | (kGreen << 4) | (kRed << 8)
  347. #define kGBR (kGreen << 0) | (kBlue << 4) | (kRed << 8)
  348. #define kRGB (kRed << 0) | (kGreen << 4) | (kBlue << 8)
  349.  
  350. const uint rgb_mask[kBGRAxis] = { kBGR, kGBR, kRGB };
  351. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  352.  
  353. #undef kRGB
  354. #undef kGBR
  355. #undef kBGR
  356.  
  357. break;
  358. }
  359. case k1000TVL:
  360. {
  361. #define kMG (kMagenta << 0) | (kGreen << 6)
  362. #define kYB (kYellow << 0) | (kBlue << 6)
  363. #define kGM (kGreen << 0) | (kMagenta << 6)
  364.  
  365. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  366. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  367.  
  368. #undef kMG
  369. #undef kYB
  370. #undef kGM
  371.  
  372. break;
  373. }
  374. default:
  375. {
  376. break;
  377. }
  378. }
  379.  
  380. break;
  381. }
  382. case k8K:
  383. {
  384. switch(crt_resolution)
  385. {
  386. case k300TVL:
  387. {
  388. #define kMaxApertureGrilleSize 13
  389.  
  390. #define kRRRRGGGGBBBBX kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kBlack
  391. #define kRRRRBBBBGGGGX kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kBlack
  392. #define kBBBBGGGGRRRRX kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed, kBlack
  393.  
  394. const uint kApertureGrilleMasks8K300TVL[kBGRAxis * kMaxApertureGrilleSize] =
  395. {
  396. kRRRRGGGGBBBBX, kRRRRBBBBGGGGX, kBBBBGGGGRRRRX
  397. };
  398.  
  399. colour_mask = kApertureGrilleMasks8K300TVL[(lcd_subpixel_layout * kMaxApertureGrilleSize) + mask];
  400.  
  401. #undef kMaxApertureGrilleSize
  402.  
  403. #undef kRRRRGGGGBBBBX
  404. #undef kRRRRBBBBGGGGX
  405. #undef kBBBBGGGGRRRRX
  406.  
  407. break;
  408. }
  409. case k600TVL:
  410. {
  411. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  412. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  413. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  414.  
  415. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  416.  
  417. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  418.  
  419. #undef kRRGGBBX
  420. #undef kRRBBGGX
  421. #undef kBBGGRRX
  422.  
  423. break;
  424. }
  425. case k800TVL:
  426. {
  427. #define kRYCBX (kRed << 0) | (kYellow << 6) | (kCyan << 12) | (kBlue << 18) | (kBlack << 24)
  428. #define kRMCGX (kRed << 0) | (kMagenta << 6) | (kCyan << 12) | (kGreen << 18) | (kBlack << 24)
  429. #define kBCYRX (kBlue << 0) | (kCyan << 6) | (kYellow << 12) | (kRed << 18) | (kBlack << 24)
  430.  
  431. const uint rgb_mask[kBGRAxis] = { kRYCBX, kRMCGX, kBCYRX };
  432. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  433.  
  434. #undef kRYCBX
  435. #undef kRMCGX
  436. #undef kBCYRX
  437.  
  438. break;
  439. }
  440. case k1000TVL:
  441. {
  442. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  443. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  444. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  445.  
  446. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  447.  
  448. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  449.  
  450. #undef kRGBX
  451. #undef kRBGX
  452. #undef kBGRX
  453.  
  454. break;
  455. }
  456. default:
  457. {
  458. break;
  459. }
  460. }
  461.  
  462. break;
  463. }
  464. default:
  465. {
  466. break;
  467. }
  468. }
  469.  
  470. break;
  471. }
  472. case kShadowMask:
  473. {
  474. uint shadow_y = uint(floor(mod(current_position.y, kShadowMaskSizeY[(lcd_resolution * kTVLAxis) + crt_resolution])));
  475.  
  476. uint mask = uint(floor(mod(current_position.x, kShadowMaskSizeX[(lcd_resolution * kTVLAxis) + crt_resolution])));
  477.  
  478. switch(lcd_resolution)
  479. {
  480. case k1080p:
  481. {
  482. switch(crt_resolution)
  483. {
  484. case k300TVL:
  485. {
  486. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  487. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  488.  
  489. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  490. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  491.  
  492. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  493. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  494.  
  495. /*
  496. kGRRBBG
  497. kGRRBBG
  498. kBBGGRR
  499. kBBGGRR
  500.  
  501. kBRRGGB
  502. kBRRGGB
  503. kGGBBRR
  504. kGGBBRR
  505.  
  506. kGBBRRG
  507. kGBBRRG
  508. kRRGGBB
  509. kRRGGBB
  510. */
  511.  
  512. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  513.  
  514. if(shadow_y < 2)
  515. {
  516. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  517. }
  518. else
  519. {
  520. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  521. }
  522.  
  523. #undef kGRRBBG
  524. #undef kBBGGRR
  525.  
  526. #undef kBRRGGB
  527. #undef kGGBBRR
  528.  
  529. #undef kGBBRRG
  530. #undef kRRGGBB
  531.  
  532. break;
  533. }
  534. case k600TVL:
  535. {
  536. #define kMG (kMagenta << 0) | (kGreen << 6)
  537. #define kGM (kGreen << 0) | (kMagenta << 6)
  538.  
  539. #define kYB (kYellow << 0) | (kBlue << 6)
  540. #define kBY (kBlue << 0) | (kYellow << 6)
  541.  
  542. /*
  543. kMG
  544. kGM
  545.  
  546. kYB
  547. kBY
  548.  
  549. kGM
  550. kMG
  551. */
  552.  
  553. const uint rgb_mask[kBGRAxis * 2] = { kMG, kGM, kYB, kBY, kGM, kMG };
  554.  
  555. if(shadow_y < 1)
  556. {
  557. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 6)) & 0x3F;
  558. }
  559. else
  560. {
  561. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 6)) & 0x3F;
  562. }
  563.  
  564. #undef kMG
  565. #undef kGM
  566.  
  567. #undef kYB
  568. #undef kBY
  569.  
  570. break;
  571. }
  572. case k800TVL:
  573. {
  574. colour_mask = kWhite;
  575.  
  576. break;
  577. }
  578. case k1000TVL:
  579. {
  580. colour_mask = kWhite;
  581.  
  582. break;
  583. }
  584. default:
  585. {
  586. break;
  587. }
  588. }
  589.  
  590. break;
  591. }
  592. case k4K:
  593. {
  594. switch(crt_resolution)
  595. {
  596. case k300TVL:
  597. {
  598. #define kMaxShadowMaskSizeX 12
  599. #define kMaxShadowMaskSizeY 8
  600.  
  601. #define kGGRRRRBBBBGG kGreen, kGreen, kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen
  602. #define kBBBBGGGGRRRR kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed
  603.  
  604. #define kBBRRRRGGGGBB kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue
  605. #define kGGGGBBBBRRRR kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed
  606.  
  607. #define kGGBBBBRRRRGG kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen
  608. #define kRRRRGGGGBBBB kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue
  609.  
  610. /*
  611. kGGRRRRBBBBGG
  612. kGGRRRRBBBBGG
  613. kGGRRRRBBBBGG
  614. kGGRRRRBBBBGG
  615. kBBBBGGGGRRRR
  616. kBBBBGGGGRRRR
  617. kBBBBGGGGRRRR
  618. kBBBBGGGGRRRR
  619.  
  620. kBBRRRRGGGGBB
  621. kBBRRRRGGGGBB
  622. kBBRRRRGGGGBB
  623. kBBRRRRGGGGBB
  624. kGGGGBBBBRRRR
  625. kGGGGBBBBRRRR
  626. kGGGGBBBBRRRR
  627. kGGGGBBBBRRRR
  628.  
  629. kGGBBBBRRRRGG
  630. kGGBBBBRRRRGG
  631. kGGBBBBRRRRGG
  632. kGGBBBBRRRRGG
  633. kRRRRGGGGBBBB
  634. kRRRRGGGGBBBB
  635. kRRRRGGGGBBBB
  636. kRRRRGGGGBBBB
  637. */
  638.  
  639. if(shadow_y < 4)
  640. {
  641. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kGGRRRRBBBBGG, kBBRRRRGGGGBB, kGGBBBBRRRRGG };
  642. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  643. }
  644. else
  645. {
  646. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kBBBBGGGGRRRR, kGGGGBBBBRRRR, kRRRRGGGGBBBB };
  647. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  648. }
  649.  
  650. #undef kMaxShadowMaskSizeX
  651. #undef kMaxShadowMaskSizeY
  652.  
  653. #undef kGGRRRRBBBBGG
  654. #undef kBBBBGGGGRRRR
  655.  
  656. #undef kBBRRRRGGGGBB
  657. #undef kGGGGBBBBRRRR
  658.  
  659. #undef kGGBBBBRRRRGG
  660. #undef kRRRRGGGGBBBB
  661.  
  662. break;
  663. }
  664. case k600TVL:
  665. {
  666. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  667. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  668.  
  669. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  670. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  671.  
  672. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  673. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  674.  
  675. /*
  676. kGRRBBG
  677. kGRRBBG
  678. kBBGGRR
  679. kBBGGRR
  680.  
  681. kBRRGGB
  682. kBRRGGB
  683. kGGBBRR
  684. kGGBBRR
  685.  
  686. kGBBRRG
  687. kGBBRRG
  688. kRRGGBB
  689. kRRGGBB
  690. */
  691.  
  692. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  693.  
  694. if(shadow_y < 2)
  695. {
  696. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  697. }
  698. else
  699. {
  700. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  701. }
  702.  
  703. #undef kGRRBBG
  704. #undef kBBGGRR
  705.  
  706. #undef kBRRGGB
  707. #undef kGGBBRR
  708.  
  709. #undef kGBBRRG
  710. #undef kRRGGBB
  711.  
  712. break;
  713. }
  714. case k800TVL:
  715. {
  716. #define kMG (kMagenta << 0) | (kGreen << 6)
  717. #define kGM (kGreen << 0) | (kMagenta << 6)
  718.  
  719. #define kYB (kYellow << 0) | (kBlue << 6)
  720. #define kBY (kBlue << 0) | (kYellow << 6)
  721.  
  722. /*
  723. kMG
  724. kGM
  725.  
  726. kYB
  727. kBY
  728.  
  729. kGM
  730. kMG
  731. */
  732.  
  733. const uint rgb_mask[kBGRAxis * 2] = { kMG, kGM, kYB, kBY, kGM, kMG };
  734.  
  735. if(shadow_y < 1)
  736. {
  737. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 6)) & 0x3F;
  738. }
  739. else
  740. {
  741. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 6)) & 0x3F;
  742. }
  743.  
  744. #undef kMG
  745. #undef kGM
  746.  
  747. #undef kYB
  748. #undef kBY
  749.  
  750. break;
  751. }
  752. case k1000TVL:
  753. {
  754. #define kMG (kMagenta << 0) | (kGreen << 6)
  755. #define kGM (kGreen << 0) | (kMagenta << 6)
  756.  
  757. #define kYB (kYellow << 0) | (kBlue << 6)
  758. #define kBY (kBlue << 0) | (kYellow << 6)
  759.  
  760. /*
  761. kMG
  762. kGM
  763.  
  764. kYB
  765. kBY
  766.  
  767. kGM
  768. kMG
  769. */
  770.  
  771. const uint rgb_mask[kBGRAxis * 2] = { kMG, kGM, kYB, kBY, kGM, kMG };
  772.  
  773. if(shadow_y < 1)
  774. {
  775. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 6)) & 0x3F;
  776. }
  777. else
  778. {
  779. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 6)) & 0x3F;
  780. }
  781.  
  782. #undef kMG
  783. #undef kGM
  784.  
  785. #undef kYB
  786. #undef kBY
  787.  
  788. break;
  789. }
  790. default:
  791. {
  792. break;
  793. }
  794. }
  795.  
  796. break;
  797. }
  798. case k8K:
  799. {
  800. switch(crt_resolution)
  801. {
  802. case k300TVL:
  803. {
  804. #define kMaxShadowMaskSizeX 12
  805. #define kMaxShadowMaskSizeY 8
  806.  
  807. #define kGGRRRRBBBBGG kGreen, kGreen, kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen
  808. #define kBBBBGGGGRRRR kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed
  809.  
  810. #define kBBRRRRGGGGBB kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue
  811. #define kGGGGBBBBRRRR kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed
  812.  
  813. #define kGGBBBBRRRRGG kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen
  814. #define kRRRRGGGGBBBB kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue
  815.  
  816. /*
  817. kGGRRRRBBBBGG
  818. kGGRRRRBBBBGG
  819. kGGRRRRBBBBGG
  820. kGGRRRRBBBBGG
  821. kBBBBGGGGRRRR
  822. kBBBBGGGGRRRR
  823. kBBBBGGGGRRRR
  824. kBBBBGGGGRRRR
  825.  
  826. kBBRRRRGGGGBB
  827. kBBRRRRGGGGBB
  828. kBBRRRRGGGGBB
  829. kBBRRRRGGGGBB
  830. kGGGGBBBBRRRR
  831. kGGGGBBBBRRRR
  832. kGGGGBBBBRRRR
  833. kGGGGBBBBRRRR
  834.  
  835. kGGBBBBRRRRGG
  836. kGGBBBBRRRRGG
  837. kGGBBBBRRRRGG
  838. kGGBBBBRRRRGG
  839. kRRRRGGGGBBBB
  840. kRRRRGGGGBBBB
  841. kRRRRGGGGBBBB
  842. kRRRRGGGGBBBB
  843. */
  844.  
  845. if(shadow_y < 4)
  846. {
  847. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kGGRRRRBBBBGG, kBBRRRRGGGGBB, kGGBBBBRRRRGG };
  848. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  849. }
  850. else
  851. {
  852. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kBBBBGGGGRRRR, kGGGGBBBBRRRR, kRRRRGGGGBBBB };
  853. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  854. }
  855.  
  856. #undef kMaxShadowMaskSizeX
  857. #undef kMaxShadowMaskSizeY
  858.  
  859. #undef kGGRRRRBBBBGG
  860. #undef kBBBBGGGGRRRR
  861.  
  862. #undef kBBRRRRGGGGBB
  863. #undef kGGGGBBBBRRRR
  864.  
  865. #undef kGGBBBBRRRRGG
  866. #undef kRRRRGGGGBBBB
  867.  
  868. break;
  869. }
  870. case k600TVL:
  871. {
  872. #define kMaxShadowMaskSizeX 12
  873. #define kMaxShadowMaskSizeY 8
  874.  
  875. #define kGGRRRRBBBBGG kGreen, kGreen, kRed, kRed, kRed, kRed, kBlue, kBlue, kBlue, kBlue, kGreen, kGreen
  876. #define kBBBBGGGGRRRR kBlue, kBlue, kBlue, kBlue, kGreen, kGreen, kGreen, kGreen, kRed, kRed, kRed, kRed
  877.  
  878. #define kBBRRRRGGGGBB kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue
  879. #define kGGGGBBBBRRRR kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed
  880.  
  881. #define kGGBBBBRRRRGG kGreen, kGreen, kBlue, kBlue, kBlue, kBlue, kRed, kRed, kRed, kRed, kGreen, kGreen
  882. #define kRRRRGGGGBBBB kRed, kRed, kRed, kRed, kGreen, kGreen, kGreen, kGreen, kBlue, kBlue, kBlue, kBlue
  883.  
  884. /*
  885. kGGRRRRBBBBGG
  886. kGGRRRRBBBBGG
  887. kGGRRRRBBBBGG
  888. kGGRRRRBBBBGG
  889. kBBBBGGGGRRRR
  890. kBBBBGGGGRRRR
  891. kBBBBGGGGRRRR
  892. kBBBBGGGGRRRR
  893.  
  894. kBBRRRRGGGGBB
  895. kBBRRRRGGGGBB
  896. kBBRRRRGGGGBB
  897. kBBRRRRGGGGBB
  898. kGGGGBBBBRRRR
  899. kGGGGBBBBRRRR
  900. kGGGGBBBBRRRR
  901. kGGGGBBBBRRRR
  902.  
  903. kGGBBBBRRRRGG
  904. kGGBBBBRRRRGG
  905. kGGBBBBRRRRGG
  906. kGGBBBBRRRRGG
  907. kRRRRGGGGBBBB
  908. kRRRRGGGGBBBB
  909. kRRRRGGGGBBBB
  910. kRRRRGGGGBBBB
  911. */
  912.  
  913. if(shadow_y < 4)
  914. {
  915. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kGGRRRRBBBBGG, kBBRRRRGGGGBB, kGGBBBBRRRRGG };
  916. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  917. }
  918. else
  919. {
  920. const uint rgb_mask[kBGRAxis * kMaxShadowMaskSizeX] = { kBBBBGGGGRRRR, kGGGGBBBBRRRR, kRRRRGGGGBBBB };
  921. colour_mask = rgb_mask[(lcd_subpixel_layout * kMaxShadowMaskSizeX) + mask];
  922. }
  923.  
  924. #undef kMaxShadowMaskSizeX
  925. #undef kMaxShadowMaskSizeY
  926.  
  927. #undef kGGRRRRBBBBGG
  928. #undef kBBBBGGGGRRRR
  929.  
  930. #undef kBBRRRRGGGGBB
  931. #undef kGGGGBBBBRRRR
  932.  
  933. #undef kGGBBBBRRRRGG
  934. #undef kRRRRGGGGBBBB
  935.  
  936. break;
  937. }
  938. case k800TVL:
  939. {
  940. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  941. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  942.  
  943. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  944. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  945.  
  946. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  947. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  948.  
  949. /*
  950. kGRRBBG
  951. kGRRBBG
  952. kBBGGRR
  953. kBBGGRR
  954.  
  955. kBRRGGB
  956. kBRRGGB
  957. kGGBBRR
  958. kGGBBRR
  959.  
  960. kGBBRRG
  961. kGBBRRG
  962. kRRGGBB
  963. kRRGGBB
  964. */
  965.  
  966. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  967.  
  968. if(shadow_y < 2)
  969. {
  970. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  971. }
  972. else
  973. {
  974. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  975. }
  976.  
  977. #undef kGRRBBG
  978. #undef kBBGGRR
  979.  
  980. #undef kBRRGGB
  981. #undef kGGBBRR
  982.  
  983. #undef kGBBRRG
  984. #undef kRRGGBB
  985.  
  986. break;
  987. }
  988. case k1000TVL:
  989. {
  990. #define kGRRBBG (kGreen << 0) | (kRed << 4) | (kRed << 8) | (kBlue << 12) | (kBlue << 16) | (kGreen << 20)
  991. #define kBBGGRR (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20)
  992.  
  993. #define kBRRGGB (kBlue << 0) | (kRed << 4) | (kRed << 8) | (kGreen << 12) | (kGreen << 16) | (kBlue << 20)
  994. #define kGGBBRR (kGreen << 0) | (kGreen << 4) | (kBlue << 8) | (kBlue << 12) | (kRed << 16) | (kRed << 20)
  995.  
  996. #define kGBBRRG (kGreen << 0) | (kBlue << 4) | (kBlue << 8) | (kRed << 12) | (kRed << 16) | (kGreen << 20)
  997. #define kRRGGBB (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20)
  998.  
  999. /*
  1000. kGRRBBG
  1001. kGRRBBG
  1002. kBBGGRR
  1003. kBBGGRR
  1004.  
  1005. kBRRGGB
  1006. kBRRGGB
  1007. kGGBBRR
  1008. kGGBBRR
  1009.  
  1010. kGBBRRG
  1011. kGBBRRG
  1012. kRRGGBB
  1013. kRRGGBB
  1014. */
  1015.  
  1016. const uint rgb_mask[kBGRAxis * 2] = { kGRRBBG, kBBGGRR, kBRRGGB, kGGBBRR, kGBBRRG, kRRGGBB };
  1017.  
  1018. if(shadow_y < 2)
  1019. {
  1020. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 0] >> (mask * 4)) & 0xF;
  1021. }
  1022. else
  1023. {
  1024. colour_mask = (rgb_mask[(lcd_subpixel_layout * 2) + 1] >> (mask * 4)) & 0xF;
  1025. }
  1026.  
  1027. #undef kGRRBBG
  1028. #undef kBBGGRR
  1029.  
  1030. #undef kBRRGGB
  1031. #undef kGGBBRR
  1032.  
  1033. #undef kGBBRRG
  1034. #undef kRRGGBB
  1035.  
  1036. break;
  1037. }
  1038. default:
  1039. {
  1040. break;
  1041. }
  1042. }
  1043.  
  1044. break;
  1045. }
  1046. default:
  1047. {
  1048. break;
  1049. }
  1050. }
  1051.  
  1052. break;
  1053. }
  1054. case kSlotMask:
  1055. {
  1056. #define kMaxSlotSizeX 2
  1057.  
  1058. uint slot_x = uint(floor(mod(current_position.x / kSlotMaskSizeX[(lcd_resolution * kTVLAxis) + crt_resolution], kMaxSlotSizeX)));
  1059. uint slot_y = uint(floor(mod(current_position.y, kSlotMaskSizeY[(lcd_resolution * kTVLAxis) + crt_resolution])));
  1060.  
  1061. uint element = (slot_y * kMaxSlotSizeX) + slot_x;
  1062.  
  1063. uint mask = uint(floor(mod(current_position.x, kSlotMaskSizeX[(lcd_resolution * kTVLAxis) + crt_resolution])));
  1064.  
  1065. switch(lcd_resolution)
  1066. {
  1067. case k1080p:
  1068. {
  1069. switch(crt_resolution)
  1070. {
  1071. case k300TVL:
  1072. {
  1073. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  1074. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  1075. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  1076.  
  1077. /*
  1078. kRGBX, kRGBX
  1079. kRGBX, kXXXX
  1080. kRGBX, kRGBX
  1081. kXXXX, kRGBX
  1082.  
  1083. kRBGX, kRBGX
  1084. kRBGX, kXXXX
  1085. kRBGX, kRBGX
  1086. kXXXX, kRBGX
  1087.  
  1088. kBGRX, kBGRX
  1089. kBGRX, kXXXX
  1090. kBGRX, kBGRX
  1091. kXXXX, kBGRX
  1092. */
  1093.  
  1094. if((element == 3) || (element == 6))
  1095. {
  1096. colour_mask = kBlack;
  1097. }
  1098. else
  1099. {
  1100. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  1101. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1102. }
  1103.  
  1104. #undef kRGBX
  1105. #undef kRBGX
  1106. #undef kBGRX
  1107.  
  1108. break;
  1109. }
  1110. case k600TVL:
  1111. {
  1112. #define kMG (kMagenta << 0) | (kGreen << 6)
  1113. #define kYB (kYellow << 0) | (kBlue << 6)
  1114. #define kGM (kGreen << 0) | (kMagenta << 6)
  1115.  
  1116. /*
  1117. kMG, kMG
  1118. kMG, kXX
  1119. kMG, kMG
  1120. kXX, kMG
  1121.  
  1122. kYB, kYB
  1123. kYB, kXX
  1124. kYB, kYB
  1125. kXX, kYB
  1126.  
  1127. kGM, kGM
  1128. kGM, kXX
  1129. kGM, kGM
  1130. kXX, kGM
  1131. */
  1132.  
  1133. if((element == 3) || (element == 6))
  1134. {
  1135. colour_mask = kBlack;
  1136. }
  1137. else
  1138. {
  1139. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  1140. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  1141. }
  1142.  
  1143. #undef kMG
  1144. #undef kYB
  1145. #undef kGM
  1146.  
  1147. break;
  1148. }
  1149. case k800TVL:
  1150. {
  1151. #define kMaxSlotMaskSize 1
  1152. #define kMaxSlotSizeY 4
  1153.  
  1154. #define kX kBlack
  1155. #define kW kWhite
  1156.  
  1157. /*
  1158. kW, kW
  1159. kW, kX
  1160. kW, kW
  1161. kX, kW
  1162. */
  1163.  
  1164. if((element == 3) || (element == 6))
  1165. {
  1166. colour_mask = kBlack;
  1167. }
  1168. else
  1169. {
  1170. colour_mask = kWhite;
  1171. }
  1172.  
  1173. #undef kMaxSlotMaskSize
  1174. #undef kMaxSlotSizeY
  1175.  
  1176. #undef kX
  1177. #undef kW
  1178.  
  1179. break;
  1180. }
  1181. case k1000TVL:
  1182. {
  1183. #define kMaxSlotMaskSize 1
  1184. #define kMaxSlotSizeY 4
  1185.  
  1186. #define kX kBlack
  1187. #define kW kWhite
  1188.  
  1189. /*
  1190. kW, kW
  1191. kW, kX
  1192. kW, kW
  1193. kX, kW
  1194. */
  1195.  
  1196. if((element == 3) || (element == 6))
  1197. {
  1198. colour_mask = kBlack;
  1199. }
  1200. else
  1201. {
  1202. colour_mask = kWhite;
  1203. }
  1204.  
  1205. #undef kMaxSlotMaskSize
  1206. #undef kMaxSlotSizeY
  1207.  
  1208. #undef kX
  1209. #undef kW
  1210.  
  1211. break;
  1212. }
  1213. default:
  1214. {
  1215. break;
  1216. }
  1217. }
  1218.  
  1219. break;
  1220. }
  1221. case k4K:
  1222. {
  1223. switch(crt_resolution)
  1224. {
  1225. case k300TVL:
  1226. {
  1227. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  1228. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  1229. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  1230.  
  1231. /*
  1232. kRRGGBBX, kRRGGBBX
  1233. kRRGGBBX, kRRGGBBX
  1234. kRRGGBBX, kRRGGBBX
  1235. kRRGGBBX, kXXXXXXX
  1236. kRRGGBBX, kRRGGBBX
  1237. kRRGGBBX, kRRGGBBX
  1238. kRRGGBBX, kRRGGBBX
  1239. kXXXXXXX, kRRGGBBX
  1240.  
  1241. kRRBBGGX, kRRBBGGX
  1242. kRRBBGGX, kRRBBGGX
  1243. kRRBBGGX, kRRBBGGX
  1244. kRRBBGGX, kXXXXXXX
  1245. kRRBBGGX, kRRBBGGX
  1246. kRRBBGGX, kRRBBGGX
  1247. kRRBBGGX, kRRBBGGX
  1248. kXXXXXXX, kRRBBGGX
  1249.  
  1250. kBBGGRRX, kBBGGRRX
  1251. kBBGGRRX, kBBGGRRX
  1252. kBBGGRRX, kBBGGRRX
  1253. kBBGGRRX, kXXXXXXX
  1254. kBBGGRRX, kBBGGRRX
  1255. kBBGGRRX, kBBGGRRX
  1256. kBBGGRRX, kBBGGRRX
  1257. kXXXXXXX, kBBGGRRX
  1258. */
  1259.  
  1260. if((element == 7) || (element == 14))
  1261. {
  1262. colour_mask = kBlack;
  1263. }
  1264. else
  1265. {
  1266. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  1267. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1268. }
  1269.  
  1270. #undef kRRGGBBX
  1271. #undef kRRBBGGX
  1272. #undef kBBGGRRX
  1273.  
  1274. break;
  1275. }
  1276. case k600TVL:
  1277. {
  1278. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  1279. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  1280. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  1281.  
  1282. /*
  1283. kRGBX, kRGBX
  1284. kRGBX, kXXXX
  1285. kRGBX, kRGBX
  1286. kXXXX, kRGBX
  1287.  
  1288. kRBGX, kRBGX
  1289. kRBGX, kXXXX
  1290. kRBGX, kRBGX
  1291. kXXXX, kRBGX
  1292.  
  1293. kBGRX, kBGRX
  1294. kBGRX, kXXXX
  1295. kBGRX, kBGRX
  1296. kXXXX, kBGRX
  1297. */
  1298.  
  1299. if((element == 5) || (element == 10))
  1300. {
  1301. colour_mask = kBlack;
  1302. }
  1303. else
  1304. {
  1305. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  1306. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1307. }
  1308.  
  1309. #undef kRGBX
  1310. #undef kRBGX
  1311. #undef kBGRX
  1312.  
  1313. break;
  1314. }
  1315. case k800TVL:
  1316. {
  1317. #define kBGR (kBlue << 0) | (kGreen << 4) | (kRed << 8)
  1318. #define kGBR (kGreen << 0) | (kBlue << 4) | (kRed << 8)
  1319. #define kRGB (kRed << 0) | (kGreen << 4) | (kBlue << 8)
  1320.  
  1321. /*
  1322. kBGR, kBGR
  1323. kBGR, kXXX
  1324. kBGR, kBGR
  1325. kXXX, kBGR
  1326.  
  1327. kGBR, kGBR
  1328. kGBR, kXXX
  1329. kGBR, kGBR
  1330. kXXX, kGBR
  1331.  
  1332. kRGB, kRGB
  1333. kRGB, kXXX
  1334. kRGB, kRGB
  1335. kXXX, kRGB
  1336. */
  1337.  
  1338. if((element == 3) || (element == 6))
  1339. {
  1340. colour_mask = kBlack;
  1341. }
  1342. else
  1343. {
  1344. const uint rgb_mask[kBGRAxis] = { kBGR, kGBR, kRGB };
  1345. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1346. }
  1347.  
  1348. #undef kBGR
  1349. #undef kGBR
  1350. #undef kRGB
  1351.  
  1352. break;
  1353. }
  1354. case k1000TVL:
  1355. {
  1356. #define kMG (kMagenta << 0) | (kGreen << 6)
  1357. #define kYB (kYellow << 0) | (kBlue << 6)
  1358. #define kGM (kGreen << 0) | (kMagenta << 6)
  1359.  
  1360. /*
  1361. kMG, kMG
  1362. kMG, kXX
  1363. kMG, kMG
  1364. kXX, kMG
  1365.  
  1366. kYB, kYB
  1367. kYB, kXX
  1368. kYB, kYB
  1369. kXX, kYB
  1370.  
  1371. kGM, kGM
  1372. kGM, kXX
  1373. kGM, kGM
  1374. kXX, kGM
  1375. */
  1376.  
  1377. if((element == 3) || (element == 6))
  1378. {
  1379. colour_mask = kBlack;
  1380. }
  1381. else
  1382. {
  1383. const uint rgb_mask[kBGRAxis] = { kMG, kYB, kGM };
  1384. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  1385. }
  1386.  
  1387. #undef kMG
  1388. #undef kYB
  1389. #undef kGM
  1390.  
  1391. break;
  1392. }
  1393. default:
  1394. {
  1395. break;
  1396. }
  1397. }
  1398.  
  1399. break;
  1400. }
  1401. case k8K:
  1402. {
  1403. switch(crt_resolution)
  1404. {
  1405. case k300TVL:
  1406. {
  1407. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  1408. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  1409. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  1410.  
  1411. /*
  1412. kRRGGBBX, kRRGGBBX
  1413. kRRGGBBX, kRRGGBBX
  1414. kRRGGBBX, kXXXXXXX
  1415. kRRGGBBX, kRRGGBBX
  1416. kRRGGBBX, kRRGGBBX
  1417. kXXXXXXX, kRRGGBBX
  1418.  
  1419. kRRBBGGX, kRRBBGGX
  1420. kRRBBGGX, kRRBBGGX
  1421. kRRBBGGX, kXXXXXXX
  1422. kRRBBGGX, kRRBBGGX
  1423. kRRBBGGX, kRRBBGGX
  1424. kXXXXXXX, kRRBBGGX
  1425.  
  1426. kBBGGRRX, kBBGGRRX
  1427. kBBGGRRX, kBBGGRRX
  1428. kBBGGRRX, kXXXXXXX
  1429. kBBGGRRX, kBBGGRRX
  1430. kBBGGRRX, kBBGGRRX
  1431. kXXXXXXX, kBBGGRRX
  1432. */
  1433.  
  1434. if((element == 5) || (element == 10))
  1435. {
  1436. colour_mask = kBlack;
  1437. }
  1438. else
  1439. {
  1440. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  1441. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1442. }
  1443.  
  1444. #undef kRRGGBBX
  1445. #undef kRRBBGGX
  1446. #undef kBBGGRRX
  1447.  
  1448. break;
  1449. }
  1450. case k600TVL:
  1451. {
  1452. #define kRRGGBBX (kRed << 0) | (kRed << 4) | (kGreen << 8) | (kGreen << 12) | (kBlue << 16) | (kBlue << 20) | (kBlack << 24)
  1453. #define kRRBBGGX (kRed << 0) | (kRed << 4) | (kBlue << 8) | (kBlue << 12) | (kGreen << 16) | (kGreen << 20) | (kBlack << 24)
  1454. #define kBBGGRRX (kBlue << 0) | (kBlue << 4) | (kGreen << 8) | (kGreen << 12) | (kRed << 16) | (kRed << 20) | (kBlack << 24)
  1455.  
  1456. /*
  1457. kRRGGBBX, kRRGGBBX
  1458. kRRGGBBX, kRRGGBBX
  1459. kRRGGBBX, kXXXXXXX
  1460. kRRGGBBX, kRRGGBBX
  1461. kRRGGBBX, kRRGGBBX
  1462. kXXXXXXX, kRRGGBBX
  1463.  
  1464. kRRBBGGX, kRRBBGGX
  1465. kRRBBGGX, kRRBBGGX
  1466. kRRBBGGX, kXXXXXXX
  1467. kRRBBGGX, kRRBBGGX
  1468. kRRBBGGX, kRRBBGGX
  1469. kXXXXXXX, kRRBBGGX
  1470.  
  1471. kBBGGRRX, kBBGGRRX
  1472. kBBGGRRX, kBBGGRRX
  1473. kBBGGRRX, kXXXXXXX
  1474. kBBGGRRX, kBBGGRRX
  1475. kBBGGRRX, kBBGGRRX
  1476. kXXXXXXX, kBBGGRRX
  1477. */
  1478.  
  1479. if((element == 5) || (element == 10))
  1480. {
  1481. colour_mask = kBlack;
  1482. }
  1483. else
  1484. {
  1485. const uint rgb_mask[kBGRAxis] = { kRRGGBBX, kRRBBGGX, kBBGGRRX };
  1486. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1487. }
  1488.  
  1489. #undef kMaxSlotMaskSize
  1490. #undef kMaxSlotSizeY
  1491.  
  1492. #undef kRRGGBBX
  1493. #undef kRRBBGGX
  1494. #undef kBBGGRRX
  1495.  
  1496. break;
  1497. }
  1498. case k800TVL:
  1499. {
  1500. #define kRYCBX (kRed << 0) | (kYellow << 6) | (kCyan << 12) | (kBlue << 18) | (kBlack << 24)
  1501. #define kRMCGX (kRed << 0) | (kMagenta << 6) | (kCyan << 12) | (kGreen << 18) | (kBlack << 24)
  1502. #define kBCYRX (kBlue << 0) | (kCyan << 6) | (kYellow << 12) | (kRed << 18) | (kBlack << 24)
  1503.  
  1504. /*
  1505. kRYCBX, kRYCBX
  1506. kRYCBX, kXXXXX
  1507. kRYCBX, kRYCBX
  1508. kXXXXX, kRYCBX
  1509.  
  1510. kRMCGX, kRMCGX
  1511. kRMCGX, kXXXXX
  1512. kRMCGX, kRMCGX
  1513. kXXXXX, kRMCGX
  1514.  
  1515. kBCYRX, kBCYRX
  1516. kBCYRX, kXXXXX
  1517. kBCYRX, kBCYRX
  1518. kXXXXX, kBCYRX
  1519. */
  1520.  
  1521. if((element == 3) || (element == 6))
  1522. {
  1523. colour_mask = kBlack;
  1524. }
  1525. else
  1526. {
  1527. const uint rgb_mask[kBGRAxis] = { kRYCBX, kRMCGX, kBCYRX };
  1528. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 6)) & 0x3F;
  1529. }
  1530.  
  1531. #undef kRYCBX
  1532. #undef kRMCGX
  1533. #undef kBCYRX
  1534.  
  1535. break;
  1536. }
  1537. case k1000TVL:
  1538. {
  1539. #define kRGBX (kRed << 0) | (kGreen << 4) | (kBlue << 8) | (kBlack << 12)
  1540. #define kRBGX (kRed << 0) | (kBlue << 4) | (kGreen << 8) | (kBlack << 12)
  1541. #define kBGRX (kBlue << 0) | (kGreen << 4) | (kRed << 8) | (kBlack << 12)
  1542.  
  1543. /*
  1544. kRGBX, kRGBX
  1545. kRGBX, kXXXX
  1546. kRGBX, kRGBX
  1547. kXXXX, kRGBX
  1548.  
  1549. kRBGX, kRBGX
  1550. kRBGX, kXXXX
  1551. kRBGX, kRBGX
  1552. kXXXX, kRBGX
  1553.  
  1554. kBGRX, kBGRX
  1555. kBGRX, kXXXX
  1556. kBGRX, kBGRX
  1557. kXXXX, kBGRX
  1558. */
  1559.  
  1560. if((element == 5) || (element == 10))
  1561. {
  1562. colour_mask = kBlack;
  1563. }
  1564. else
  1565. {
  1566. const uint rgb_mask[kBGRAxis] = { kRGBX, kRBGX, kBGRX };
  1567. colour_mask = (rgb_mask[lcd_subpixel_layout] >> (mask * 4)) & 0xF;
  1568. }
  1569.  
  1570. #undef kRGBX
  1571. #undef kRBGX
  1572. #undef kBGRX
  1573.  
  1574. break;
  1575. }
  1576. default:
  1577. {
  1578. break;
  1579. }
  1580. }
  1581.  
  1582. break;
  1583. }
  1584. default:
  1585. {
  1586. break;
  1587. }
  1588. }
  1589.  
  1590. break;
  1591. }
  1592. default:
  1593. {
  1594. break;
  1595. }
  1596. }
  1597.  
  1598. const float scanline_size = output_size.y / source_size.y;
  1599.  
  1600. const vec3 horizontal_convergence = vec3(HCRT_RED_HORIZONTAL_CONVERGENCE, HCRT_GREEN_HORIZONTAL_CONVERGENCE, HCRT_BLUE_HORIZONTAL_CONVERGENCE);
  1601. const vec3 vertical_convergence = vec3(HCRT_RED_VERTICAL_CONVERGENCE, HCRT_GREEN_VERTICAL_CONVERGENCE, HCRT_BLUE_VERTICAL_CONVERGENCE);
  1602. const vec3 beam_sharpness = vec3(HCRT_RED_BEAM_SHARPNESS, HCRT_GREEN_BEAM_SHARPNESS, HCRT_BLUE_BEAM_SHARPNESS);
  1603. const vec3 beam_attack = vec3(HCRT_RED_BEAM_ATTACK, HCRT_GREEN_BEAM_ATTACK, HCRT_BLUE_BEAM_ATTACK);
  1604. const vec3 scanline_min = vec3(HCRT_RED_SCANLINE_MIN, HCRT_GREEN_SCANLINE_MIN, HCRT_BLUE_SCANLINE_MIN);
  1605. const vec3 scanline_max = vec3(HCRT_RED_SCANLINE_MAX, HCRT_GREEN_SCANLINE_MAX, HCRT_BLUE_SCANLINE_MAX);
  1606. const vec3 scanline_attack = vec3(HCRT_RED_SCANLINE_ATTACK, HCRT_GREEN_SCANLINE_ATTACK, HCRT_BLUE_SCANLINE_ATTACK);
  1607.  
  1608. const uint channel_count = colour_mask & 3;
  1609.  
  1610. vec3 scanline_colour = vec3(0.0f);
  1611.  
  1612. if(channel_count > 0)
  1613. {
  1614. const uint channel_0 = (colour_mask >> kFirstChannelShift) & 3;
  1615.  
  1616. const float scanline_channel_0 = GenerateScanline( channel_0,
  1617. tex_coord,
  1618. source_size.xy,
  1619. scanline_size,
  1620. horizontal_convergence[channel_0],
  1621. vertical_convergence[channel_0],
  1622. beam_sharpness[channel_0],
  1623. beam_attack[channel_0],
  1624. scanline_min[channel_0],
  1625. scanline_max[channel_0],
  1626. scanline_attack[channel_0]);
  1627.  
  1628. scanline_colour = scanline_channel_0 * kColourMask[channel_0];
  1629. }
  1630.  
  1631. if(channel_count > 1)
  1632. {
  1633. const uint channel_1 = (colour_mask >> kSecondChannelShift) & 3;
  1634.  
  1635. const float scanline_channel_1 = GenerateScanline(channel_1,
  1636. tex_coord,
  1637. source_size.xy,
  1638. scanline_size,
  1639. horizontal_convergence[channel_1],
  1640. vertical_convergence[channel_1],
  1641. beam_sharpness[channel_1],
  1642. beam_attack[channel_1],
  1643. scanline_min[channel_1],
  1644. scanline_max[channel_1],
  1645. scanline_attack[channel_1]);
  1646.  
  1647. scanline_colour += scanline_channel_1 * kColourMask[channel_1];
  1648. }
  1649.  
  1650. if(channel_count > 2)
  1651. {
  1652. const uint channel_2 = (colour_mask >> kThirdChannelShift) & 3;
  1653.  
  1654. const float scanline_channel_2 = GenerateScanline(channel_2,
  1655. tex_coord,
  1656. source_size.xy,
  1657. scanline_size,
  1658. horizontal_convergence[channel_2],
  1659. vertical_convergence[channel_2],
  1660. beam_sharpness[channel_2],
  1661. beam_attack[channel_2],
  1662. scanline_min[channel_2],
  1663. scanline_max[channel_2],
  1664. scanline_attack[channel_2]);
  1665.  
  1666. scanline_colour += scanline_channel_2 * kColourMask[channel_2];
  1667. }
  1668.  
  1669. vec3 transformed_colour;
  1670.  
  1671. if(HCRT_COLOUR_ACCURATE >= 1.0f)
  1672. {
  1673. if(HCRT_HDR >= 1.0f)
  1674. {
  1675. const vec3 rec2020 = scanline_colour * k2020Gamuts[uint(HCRT_EXPAND_GAMUT)];
  1676. transformed_colour = rec2020 * (HCRT_PAPER_WHITE_NITS / kMaxNitsFor2084);
  1677. }
  1678. else if(HCRT_OUTPUT_COLOUR_SPACE == 2.0f)
  1679. {
  1680. transformed_colour = (scanline_colour * k709_to_XYZ) * kXYZ_to_DCIP3;
  1681. }
  1682. else
  1683. {
  1684. transformed_colour = scanline_colour;
  1685. }
  1686. }
  1687. else
  1688. {
  1689. transformed_colour = scanline_colour;
  1690. }
  1691.  
  1692. vec3 gamma_corrected;
  1693.  
  1694. GammaCorrect(transformed_colour, gamma_corrected);
  1695.  
  1696. FragColor = vec4(gamma_corrected, 1.0f);
  1697. }
  1698.  
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!